二.i2c子系统操作函数，i2c-core.c
1.
kernel/driver/linux/i2c/i2c-core.c
/**
* i2c_add_adapter - declare i2c adapter, use dynamic bus number
* @adapter: the adapter to add
* Context: can sleep
*
* This routine is used to declare an I2C adapter when its bus number
* doesn't matter. Examples: for I2C adapters dynamically added by
* USB links or PCI plugin cards.
*
* When this returns zero, a new bus number was allocated and stored
* in adap->nr, and the specified adapter became available for clients.
* Otherwise, a negative errno value is returned.
*/
int i2c_add_adapter(struct i2c_adapter *adapter)
{
int id, res = 0;
retry:
if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
return -ENOMEM;
mutex_lock(&core_lock);
/* "above" here means "above or equal to", sigh */
res = idr_get_new_above(&i2c_adapter_idr, adapter,
__i2c_first_dynamic_bus_num, &id);
mutex_unlock(&core_lock);
if (res < 0) {
if (res == -EAGAIN)
goto retry;
return res;
}
adapter->nr = id;
return i2c_register_adapter(adapter);
}
i2c_add_adapter 注册i2c适配器到系统，主要功能是首先通过ird机制给i2c适配器分配指针，然后注册该i2c适配器
idr_pre_get 预分配i2c适配器指针
idr_get_new_above 给i2c适配器分配指针并和id关联
i2c_register_adapter i2c注册适配器
kernel/driver/linux/i2c/i2c-core.c
static int i2c_register_adapter(struct i2c_adapter *adap)
{
int res = 0;
/* Can't register until after driver model init */
if (unlikely(WARN_ON(!i2c_bus_type.p))) {
res = -EAGAIN;
goto out_list;
}
/* Sanity checks */
if (unlikely(adap->name[0] == '\0')) {
pr_err("i2c-core: Attempt to register an adapter with "
"no name!\n");
return -EINVAL;
}
if (unlikely(!adap->algo)) {
pr_err("i2c-core: Attempt to register adapter '%s' with "
"no algo!\n", adap->name);
return -EINVAL;
}
rt_mutex_init(&adap->bus_lock);
mutex_init(&adap->userspace_clients_lock);
INIT_LIST_HEAD(&adap->userspace_clients);
/* Set default timeout to 1 second if not already set */
if (adap->timeout == 0)
adap->timeout = HZ;
dev_set_name(&adap->dev, "i2c-%d", adap->nr);
adap->dev.bus = &i2c_bus_type;
adap->dev.type = &i2c_adapter_type;
res = device_register(&adap->dev);
if (res)
goto out_list;
dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);
#ifdef CONFIG_I2C_COMPAT
res = class_pat_create_link(i2c_adapter_pat_class, &adap->dev,
adap->dev.parent);
if (res)
dev_warn(&adap->dev,
"Failed to create patibility class link\n");
#endif
/* create pre-declared device nodes */
if (adap->nr < __i2c_first_dynamic_bus_num)
i2c_scan_static_board_info(adap);
/* Notify drivers */
mutex_lock(&core_lock);
bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);
mutex_unlock(&core_lock);
return 0;
out_list:
mutex_lock(&core_lock);
idr_remove(&i2c_adapter_idr, adap->nr);
mutex_unlock(&core_lock);
return res;
}
i2c_register_adapter 注册适配器
unlikely(WARN_ON(!i2c_bus_type.p 检查总线是否初始化完成
unlikely(adap->name[0] == '\0') 检查适配器名称是否为空
unlikely(!adap->algo) 检查适配器算法是否为空
rt_mutex_init(&adap->bus_lock); 初始化实时互斥锁
mutex_init(&adap->userspace_clients_lock); 初始化用户设备锁
INIT_LIST_HEAD(&adap->userspace_clients); 初始化i2c设备链表
dev_set_name(&adap->dev, "i2c-%d", adap->nr); 设置适配器设备驱动模型设备名称
adap->dev.bus = &i2c_bus_type; 初始化适配器设备驱动模型设备的总线类型
adap->dev.type = &i2c_adapter_type; 初始化适配器设备驱动模型设备类型
device_register(&adap->dev); 注册适配器设备到设备驱动模型
i2c_scan_static_board_info(adap); 扫描静态声明的i2c设备信息，该方法也对应i2c设备静态声明注册
kernel/driver/linux/i2c/i2c-core.c
static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
{
struct i2c_devinfo*devinfo;
down_read(&__i2c_board_lock);
list_for_each_entry(devinfo, &__i2c_board_list, list) {
if (devinfo->busnum == adapter->nr
&& !i2c_new_device(adapter,
&devinfo->board_info))
dev_err(&adapter->dev,
"Can't create device at 0x%02x\n",
devinfo->board_info.addr);
}
up_read(&__i2c_board_lock);
}
kernel/driver/linux/i2c/i2c-core.h
struct i2c_devinfo {
struct list_headlist;
int busnum;
struct i2c_board_infoboard_info;
};
上面结构体封装了i2c_board_info和链表，因此可以通过链表遍历i2c板信息。
down_read 读信号量
list_for_each_entry 遍历i2c板信息
i2c_new_device(adapter,&devinfo->board_info) i2c适配器增加新i2c设备，根据 i2c_board_info 静态设备声明信息
kernel/driver/linux/i2c/i2c-core.c
struct i2c_client * i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
{
struct i2c_client*client;
int status;
client = kzalloc(sizeof *client, GFP_KERNEL);
if (!client)
return NULL;
client->adapter = adap;
client->dev.platform_data = info->platform_data;
if (info->archdata)
client->dev.archdata = *info->archdata;
client->flags = info->flags;
client->addr = info->addr;
client->irq = info->irq;
strlcpy(client->name, info->type, sizeof(client->name));
/* Check for address validity */
status = i2c_check_client_addr_validity(client);
if (status) {
dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
goto out_err_silent;
}
/* Check for address business */
status = i2c_check_addr_busy(adap, client->addr);
if (status)
goto out_err;
client->dev.parent = &client->adapter->dev;
client->dev.bus = &i2c_bus_type;
client->dev.type = &i2c_client_type;
client->dev.of_node = info->of_node;
dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
client->addr);
status = device_register(&client->dev);
if (status)
goto out_err;
dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
client->name, dev_name(&client->dev));
return client;
out_err:
dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
"(%d)\n", client->name, client->addr, status);
out_err_silent:
kfree(client);
return NULL;
}
client->adapter = adap; 给i2c设备设置适配器
client->dev.platform_data = info->platform_data;
client->dev.archdata = *info->archdata;
client->flags = info->flags;
client->addr = info->addr;
client->irq = info->irq;
上面是利用i2c板级信息给i2c设备赋值
strlcpy(client->name, info->type, sizeof(client->name)); 设置设备名称
i2c_check_client_addr_validity(client); 检查地址有效性
i2c_check_addr_busy(adap, client->addr); 检查设备地址是否和其他冲突
client->dev.parent = &client->adapter->dev;
client->dev.bus = &i2c_bus_type;
client->dev.type = &i2c_client_type;
client->dev.of_node = info->of_node;
上面是给i2c设备驱动模型的设备赋值
dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),client->addr); 给设备驱动模型设备设置名称，名称是总线号以及设备地址组合
device_register(&client->dev); 注册设备到设备驱动模型
小结：i2c_scan_static_board_info 扫描静态声明的i2c设备信息 -》down_read读信号量
list_for_each_entry遍历i2c板信息 -》i2c_new_devicei2c适配器增加新i2c设备，根据 i2c_board_info 静态设备声明信息-》device_register注册设备到设备驱动模型
bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter); 遍历总线上的i2c驱动，动态探测添加i2c设备，该方法主要为了适配器动态加载时比i2c驱动晚注册的情况。
kernel/driver/base/bus.c
int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
void *data, int (*fn)(struct device_driver *, void *))
{
struct klist_iter i;
struct device_driver *drv;
int error = 0;
if (!bus)
return -EINVAL;
klist_iter_init_node(&bus->p->klist_drivers, &i,
start ? &start->p->knode_bus : NULL);
while ((drv = next_driver(&i)) && !error)
error = fn(drv, data);
klist_iter_exit(&i);
return error;
}
klist_iter_init_node(&bus->p->klist_drivers, &i, start ? &start->p->knode_bus : NULL); 初始化内核链表遍历节点
next_driver(&i) 获取下一个设备驱动指针
fn(drv, data); 调用处理函数即__process_new_adapter
__process_new_adapter 添加新适配器处理函数，结合设备驱动动态探测i2c设备
kernel/driver/linux/i2c/i2c-core.c
static int __process_new_adapter(struct device_driver *d, void *data)
{
return i2c_do_add_adapter(to_i2c_driver(d), data);
}
kernel/driver/linux/i2c/i2c-core.c
i2c_do_add_adapter(data, to_i2c_adapter(dev)); i2c驱动和适配器探测添加i2c设备
static int i2c_do_add_adapter(struct i2c_driver *driver,
struct i2c_adapter *adap)
{
/* Detect supported devices on that bus, and instantiate them */
i2c_detect(adap, driver);
/* Let legacy drivers scan this bus for matching devices */
if (driver->attach_adapter) {
dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",
driver->driver.name);
dev_warn(&adap->dev, "Please use another way to instantiate "
"your i2c_client\n");
/* We ignore the return code; if it fails, too bad */
driver->attach_adapter(adap);
}
return 0;
}
i2c_detect(adap, driver); i2c驱动和适配器来探测i2c设备并实例化
kernel/driver/linux/i2c/i2c-core.c
static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)
{
const unsigned short *address_list;
struct i2c_client *temp_client;
int i, err = 0;
int adap_id = i2c_adapter_id(adapter);
address_list = driver->address_list;
if (!driver->detect || !address_list)
return 0;
/* Stop here if the classes do not match */
if (!(adapter->class & driver->class))
return 0;
/* Set up a temporary client to help detect callback */
temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);
if (!temp_client)
return -ENOMEM;
temp_client->adapter = adapter;
for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {
dev_dbg(&adapter->dev, "found normal entry for adapter %d, "
"addr 0x%02x\n", adap_id, address_list[i]);
temp_client->addr = address_list[i];
err = i2c_detect_address(temp_client, driver);
if (unlikely(err))
break;
}
kfree(temp_client);
return err;
}
i2c_adapter_id(adapter);获取适配器号
address_list = driver->address_list; 获取驱动支持地址链表
if (!(adapter->class & driver->class)) 判断i2c驱动和适配器是否匹配，不匹配则不进行设备探测
temp_client->adapter = adapter; 客户端初始化适配器
temp_client->addr = address_list[i]; 客户端初始化地址
i2c_detect_address(temp_client, driver); i2c驱动根据设备地址探测设备函数
static int i2c_detect_address(struct i2c_client *temp_client,
struct i2c_driver *driver)
{
struct i2c_board_info info;
struct i2c_adapter *adapter = temp_client->adapter;
int addr = temp_client->addr;
int err;
/* Make sure the address is valid */
err = i2c_check_addr_validity(addr);
if (err) {
dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",
addr);
return err;
}
/* Skip if already in use */
if (i2c_check_addr_busy(adapter, addr))
return 0;
/* Make sure there is something at this address */
if (!i2c_default_probe(adapter, addr))
return 0;
/* Finally call the custom detection function */
memset(&info, 0, sizeof(struct i2c_board_info));
info.addr = addr;
err = driver->detect(temp_client, &info);
if (err) {
/* -ENODEV is returned if the detection fails. We catch it
here as this isn't an error. */
return err == -ENODEV ? 0 : err;
}
/* Consistency check */
if (info.type[0] == '\0') {
dev_err(&adapter->dev, "%s detection function provided "
"no name for 0x%x\n", driver->driver.name,
addr);
} else {
struct i2c_client *client;
/* Detection sueeded, instantiate the device */
dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",
info.type, info.addr);
client = i2c_new_device(adapter, &info);
if (client)
list_add_tail(&client->detected, &driver->clients);
else
dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",
info.type, info.addr);
}
return 0;
}
i2c_check_addr_validity(addr);检查地址有效性
i2c_check_addr_busy(adapter, addr)) 检查该地址是否被其他设备使用，具体过程就是先获取该适配器父节点，然后再遍历父节点适配器的子设备链表，看是否有适配器和本适配器地址冲突
i2c_default_probe(adapter, addr) 用smbus通信算法
driver->detect(temp_client, &info); 调用i2c驱动的i2c设备探测函数
i2c_new_device(adapter, &info); i2c适配器增加新i2c设备，根据 i2c_board_info 静态设备声明信息
kernel/driver/linux/i2c/i2c-core.c
struct i2c_client *
i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
{
struct i2c_client*client;
int status;
client = kzalloc(sizeof *client, GFP_KERNEL);
if (!client)
return NULL;
client->adapter = adap;
client->dev.platform_data = info->platform_data;
if (info->archdata)
client->dev.archdata = *info->archdata;
client->flags = info->flags;
client->addr = info->addr;
client->irq = info->irq;
strlcpy(client->name, info->type, sizeof(client->name));
/* Check for address validity */
status = i2c_check_client_addr_validity(client);
if (status) {
dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
goto out_err_silent;
}
/* Check for address business */
status = i2c_check_addr_busy(adap, client->addr);
if (status)
goto out_err;
client->dev.parent = &client->adapter->dev;
client->dev.bus = &i2c_bus_type;
client->dev.type = &i2c_client_type;
client->dev.of_node = info->of_node;
dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
client->addr);
status = device_register(&client->dev);
if (status)
goto out_err;
dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
client->name, dev_name(&client->dev));
return client;
out_err:
dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
"(%d)\n", client->name, client->addr, status);
out_err_silent:
kfree(client);
return NULL;
}
client->adapter = adap; 给i2c设备设置适配器
client->dev.platform_data = info->platform_data;
client->dev.archdata = *info->archdata;
client->flags = info->flags;
client->addr = info->addr;
client->irq = info->irq;
上面是利用i2c板级信息给i2c设备赋值
strlcpy(client->name, info->type, sizeof(client->name)); 设置设备名称
i2c_check_client_addr_validity(client); 检查地址有效性
i2c_check_addr_busy(adap, client->addr); 检查设备地址是否和其他冲突
client->dev.parent = &client->adapter->dev;
client->dev.bus = &i2c_bus_type;
client->dev.type = &i2c_client_type;
client->dev.of_node = info->of_node;
上面是给i2c设备驱动模型的设备赋值
dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),client->addr); 给设备驱动模型设备设置名称，名称是总线号以及设备地址组合
device_register(&client->dev); 注册设备到设备驱动模型
小结：i2c_detect-》i2c_detect_address-》i2c_check_addr_validity
i2c_check_addr_busy
i2c_default_probe
driver->detect
i2c_new_device -》 device_register(&client->dev);
driver->attach_adapter(adap); i2c驱动绑定适配器，此函数已经被移除，这是为了保持兼容性
小结：bus_for_each_drv遍历总线上的i2c驱动，动态添加i2c设备-》next_driver获取下一个设备驱动指针-》__process_new_adapter添加新适配器处理函数，结合设备驱动动态探测i2c设备-》i2c_detect i2c驱动和适配器来探测i2c设备并实例化
总结：
i2c_add_adapter 注册i2c适配器到系统-》idr_pre_get预分配i2c适配器指针
idr_get_new_above 给i2c适配器分配指针并和id关联
i2c_register_adapter i2c注册适配器-》device_register注册适配器设备到设备驱动模型
i2c_scan_static_board_info 扫描静态声明的i2c设备信息
bus_for_each_drv遍历总线上的i2c驱动，动态添加i2c设备
2. i2c_add_numbered_adapter 注册具有静态总线号的i2c适配器的函数
kernel/driver/linux/i2c/i2c-core.c
int i2c_add_numbered_adapter(struct i2c_adapter *adap)
{
int id;
int status;
if (adap->nr & ~MAX_ID_MASK)
return -EINVAL;
retry:
if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
return -ENOMEM;
mutex_lock(&core_lock);
/* "above" here means "above or equal to", sigh;
* we need the "equal to" result to force the result
*/
status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
if (status == 0 && id != adap->nr) {
status = -EBUSY;
idr_remove(&i2c_adapter_idr, id);
}
mutex_unlock(&core_lock);
if (status == -EAGAIN)
goto retry;
if (status == 0)
status = i2c_register_adapter(adap);
return status;
}
if (adap->nr & ~MAX_ID_MASK) 判断适配器号是否超过最大值
idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) idr机制预分配指针
idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id); idr机制整数id与指针建立关系
i2c_register_adapter(adap); 注册i2c适配器
总结: i2c_add_numbered_adapter 注册具有静态总线号的i2c适配器的函数 ->idr_pre_get idr机制预分配指针
idr_get_new_aboveidr机制整数id与指针建立关系
i2c_register_adapter注册i2c适配器
更多推荐
子系统,代码,linux,i2c
发布评论