i2c驱动之设备模型建立

一：设备模型建立流程图







二：重要函数分析

（1）新适配器加入内核：



int i2c_add_numbered_adapter(struct i2c_adapter *adap)

{

int id;

int status;

if (adap->nr & ~MAX_ID_MASK)

return -EINVAL;

retry://为i2c_adapter_idr分配内存

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

*///让指针adap关联一个ID，这个ID值从adap->nr开始

status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);

if (status == 0 && id != adap->nr) {

status = -EBUSY;//分配的ID值必须与adap->nr相等

idr_remove(&i2c_adapter_idr, id);

}

mutex_unlock(&core_lock);

if (status == -EAGAIN)

goto retry;

if (status == 0)//表示ID分配成功。

status = i2c_register_adapter(adap);//注册一个适配器。

return status;

}



static int i2c_register_adapter(struct i2c_adapter *adap)

{

int res = 0, dummy;

/* Can't register until after driver model init */

if (unlikely(WARN_ON(!i2c_bus_type.p)))

return -EAGAIN;

mutex_init(&adap->bus_lock);

mutex_init(&adap->clist_lock);

INIT_LIST_HEAD(&adap->clients);

mutex_lock(&core_lock);

/* Add the adapter to the driver core.

* If the parent pointer is not set up,

* we add this adapter to the host bus.

*/

if (adap->dev.parent == NULL) {

adap->dev.parent = &platform_bus;

pr_debug("I2C adapter driver [%s] forgot to specify "

"physical device\n", adap->name);

}

/* 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.release = &i2c_adapter_dev_release;

////将适配器设备归类，在驱动注册的时候会根据这个类找寻

//这个类中匹配的适配器。

//这个类表示该设备是一个适配器，而adap->class表示该设备支持的设备类型

adap->dev.class = &i2c_adapter_class;

res = device_register(&adap->dev);//注册该设备

//到此适配器设备已被完全注册到了内核。

if (res)

goto out_list;

dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);

/* create pre-declared device nodes for new-style drivers */

/*

结构体board_info包含了一些平台信息，和I2C设备地址。该结构

由函数i2c_register_board_info()加到链表__i2c_board_list上。

函数i2c_scan_static_board_info在该链表上找一个满足这样条件的

devinfo->busnum == adapter->nr的结构体，然后根据board_info中的

client->flags = info->flags;

client->addr = info->addr;

client->irq = info->irq;

注册一个client（它代表一个具体的设备），并且

client->dev.parent = &client->adapter->dev;最终将将client->dev

挂到链表adapter->dev->p->klist_children上。

函数device_for_each_child就是根据该链表来找出适配器上的每一个client的。

*/

if (adap->nr < __i2c_first_dynamic_bus_num)

i2c_scan_static_board_info(adap);

/* Notify drivers */

/*

寻找每一个总线类型为i2c_bus_type的驱动，这些驱动都被包装为i2c_driver.

如果驱动类型i2c_driver->class和适配器类型adapter->class匹配，并且

驱动支持的设备地址driver->address_data在适配器中没有被占用。就会根据

这个地址注册一个client挂到这个适配器上。

另一个任务是调用函数driver->attach_adapter，注册一个有设备号的设备

并将这个适配器与这个设备关联。该driver是i2c_driver并不是所有的driver

都有为一个适配器创建设备节点的能力即有函数driver->attach_adapter。。。。

*/

dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap,

i2c_do_add_adapter);

out_unlock:

mutex_unlock(&core_lock);

return res;

out_list:

idr_remove(&i2c_adapter_idr, adap->nr);

goto out_unlock;

}



static void i2c_scan_static_board_info(struct i2c_adapter *adapter)

{

struct i2c_devinfo *devinfo;

mutex_lock(&__i2c_board_lock);

/*

devinfo被函数i2c_register_board_info挂到链表__i2c_board_list上。

本函数是在链表__i2c_board_list上找一个结构体devinfo，该结构体满足

devinfo->busnum == adapter->nr。

devinfo中包含了地址，flags，type等信息，可用于初始化一个client

并注册到内核。



结构体devinfo中的信息与平台相关。因此该结构的注册应该是在平台

的初始化时进行。

*/

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);

}

mutex_unlock(&__i2c_board_lock);

}





（2）一个新的驱动加入内核：



int i2c_register_driver(struct module *owner, struct i2c_driver *driver)

{

int res;

/* Can't register until after driver model init */

if (unlikely(WARN_ON(!i2c_bus_type.p)))

return -EAGAIN;

/* new style driver methods can't mix with legacy ones */

/*

"new style" driver:

is_newstyle_driver(d) ((d)->probe || (d)->remove || (d)->detect)

"legacy"driver:

driver->detach_adapter || driver->detach_client

attach_adapter和detach_adapter；detach_client和attach_client是两对

操作相反的函数，必须成对出现。

这两类驱动的区别就是他们所拥有的函数不一样。

不能出现这两类驱动的混合体，即兼有这两类驱动的标志函数的驱动。

*/

if (is_newstyle_driver(driver)) {

if (driver->detach_adapter || driver->detach_client) {

printk(KERN_WARNING

"i2c-core: driver [%s] is confused\n",

driver->driver.name);

return -EINVAL;

}

}

/* add the driver to the list of i2c drivers in the driver core */

driver->driver.owner = owner;

driver->driver.bus = &i2c_bus_type;//设置它的总线类型

/* for new style drivers, when registration returns the driver core

* will have called probe() for all matching-but-unbound devices.

*/

res = driver_register(&driver->driver);//注册驱动

if (res)

return res;

/*

到这里该驱动已被完全注册到了内核。它可以去匹配内核中已存在的

client而后执行probe函数了。

但是一个i2c_driver还有着其他的使命。如果该驱动是一个携带地址信息的

"new style" driver，则它要把这些每一个地址对应一个client注册到内核。

如果是一个"legacy"driver，则它要用它的driver->attach_adapter函数

去处理每一个adapter->nr空闲的适配器。

每一个函数driver->attach_adapter的操作都跟adapter->nr有关，在这些函数

中都会对adapter->nr进行判断，所以driver->attach_adapter并不是，一个驱动

的函数attach_adapter对每一个适配器都会成功执行。

比如在驱动i2cdev_driver中函数attach_adapter的执行会创建一个设备节点，

但是对同一个适配器两次执行函数attach_adapter就不会产生两个设备节点，

因为产生设备节点的次设备号是由adapter->nr来决定的。内核是不会允许

对同一个设备号注册两次的。

*/

mutex_lock(&core_lock);

pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);

INIT_LIST_HEAD(&driver->clients);//初始化链表头用于挂接client

/* Walk the adapters that are already present */

/*

寻找类型为i2c_adapter_class的所有设备，即适配器。



如果驱动为"new style" driver将在函数__attach_adapter中

执行函数i2c_detect，如果当前找到的适配器所支持的设备类型

与驱动所支持的设备类型相匹配，就将驱动所携带的地址信息

driver->address_data，对应着client注册到内核，并插入该适配器。

适配器所支持的设备类型由adapter->class决定，而不是

adapter->dev->class,adapter->dev->class的类型应为i2c_adapter_class。

驱动所支持的设备类型为driver->class。



如果该驱动为"legacy"driver，则在函数__attach_adapter中将执行

函数driver->attach_adapter，将在类i2c_adapter_class上找到的

所有适配器都执行一遍本驱动的driver->attach_adapter函数。

当然并不是所有驱动都能成功执行该函数。该函数的执行会判断

adapter->nr。

*/

class_for_each_device(&i2c_adapter_class, NULL, driver,

__attach_adapter);

mutex_unlock(&core_lock);

return 0;

}





（3）适配器与设备进行类型匹配，探测驱动中的可用地址，并将地址对应于一个client注册到内核



在适配器设备和驱动注册到内核后调用了两个相似的函数如下：



在适配器设备注册到内核后调用函数：

static int i2c_do_add_adapter(struct device_driver *d, void *data)

{

struct i2c_driver *driver = to_i2c_driver(d);

struct i2c_adapter *adap = data;

/* 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) {//使适配器关联一个设备号或者。。。。。。

/* We ignore the return code; if it fails, too bad */

driver->attach_adapter(adap);

}

return 0;

}

驱动注册到内核后调用函数：

static int __attach_adapter(struct device *dev, void *data)

{

struct i2c_adapter *adapter = to_i2c_adapter(dev);

struct i2c_driver *driver = data;

//如果驱动的类与适配器的类相匹配，则将驱动支持的设备插入适配器。

i2c_detect(adapter, driver);

/* Legacy drivers scan i2c busses directly */

if (driver->attach_adapter)//使适配器关联一个设备号或者。。。。。。

driver->attach_adapter(adapter);

return 0;

}

两函数的对比：

static int __attach_adapter(struct device *dev, void *data)

与

static int i2c_do_add_adapter(struct device_driver *d, void *data)

前者是在新的驱动加入内核时调用函数class_for_each_device时调用的函数。

函数class_for_each_device是在类i2c_adapter_class中找一个适配器设备

与新驱动匹配。该函数变化的是设备不变的是加入的新的驱动（void *data）



后者是在新的适配器加入内核时调用函数 bus_for_each_drv时调用的函数。

函数bus_for_each_drv是在总线类型为i2c_bus_type的驱动中找到一个驱动

与新加入的适配器匹配。该函数变化的是驱动，不变的是新加入的适配器

（void *data）。



相同点都是执行函数i2c_detect和函数driver->attach_adapter。

其实在bus_for_each_drv和class_for_each_device并不执行匹配的操作。

只是简单的取出所有的驱动或是适配器，执行函数i2c_detect和attach_adapter。

真正的匹配是在函数i2c_detect和attach_adapter中进行的。

函数i2c_detect中会去判断驱动支持的设备类和适配器所支持的设备类

是否匹配。

函数driver->attach_adapter中会判断adapter->nr是不是自己需要处理的

适配器，或者是是不是该适配器已被处理过了。

当然函数i2c_detect和函数driver->attach_adapter是绝不会同时执行的。

因为函数i2c_detect的执行需要用到函数driver->detect而该函数是

"new style" drivers的标志函数。而函数driver->attach_adapter是

"legacy" drivers的标志函数。i2c_driver中是没有兼有这两种驱动的混合体

驱动的。



static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)

{

const struct i2c_client_address_data *address_data;

struct i2c_client *temp_client;

int i, err = 0;

int adap_id = i2c_adapter_id(adapter);

address_data = driver->address_data;

/*

因为注册一个client要调用函数i2c_new_device(adapter, &info);

该函数要用结构体info为client提供必要的信息。所以函数

driver->detect的主要作用是填充结构体info。

client代表一个具体设备而每个设备都有它的地址address_data。

所以driver->detect和address_data都是必不可少。

*/

if (!driver->detect || !address_data)

return 0;

/* Set up a temporary client to help detect callback */

/*

分配一个临时的temp_client，因为temp_client得设备并没有被注册，

也没有被插入适配器，它只是暂存了一些client信息。

*/

temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);

if (!temp_client)

return -ENOMEM;

temp_client->adapter = adapter;

/* Force entries are done first, and are not affected by ignore

entries */

/*

为什么是forces？

因为跳过了适配器支持的设备类和驱动支持的设备类匹配判断

if (!(adapter->class & driver->class))

goto exit_free;

也就是说即使不匹配，这些设备地址只要满足某些条件也要将其插入适配器。

*/

if (address_data->forces) {

const unsigned short * const *forces = address_data->forces;

int kind;

for (kind = 0; forces[kind]; kind++) {

for (i = 0; forces[kind][i] != I2C_CLIENT_END;

i += 2) {//adap_id即是分配的与结构体adapter相关联的ID

if (forces[kind][i] == adap_id

|| forces[kind][i] == ANY_I2C_BUS) {

dev_dbg(&adapter->dev, "found force "

"parameter for adapter %d, "

"addr 0x%02x, kind %d\n",

adap_id, forces[kind][i + 1],

kind);

temp_client->addr = forces[kind][i + 1];

//将这个地址的设备插入适配器。

err = i2c_detect_address(temp_client,

kind, driver);

if (err)

goto exit_free;

}

}

}

}

/* Stop here if the classes do not match */

//适配器和驱动的类型要匹配此处的驱动为i2c_driver

if (!(adapter->class & driver->class))

goto exit_free;

/* Stop here if we can't use SMBUS_QUICK */

//如果该适配器不支持I2C_FUNC_SMBUS_QUICK功能则就此结束。

if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_QUICK)) {

if (address_data->probe[0] == I2C_CLIENT_END

&& address_data->normal_i2c[0] == I2C_CLIENT_END)

goto exit_free;

dev_warn(&adapter->dev, "SMBus Quick command not supported, "

"can't probe for chips\n");

err = -EOPNOTSUPP;

goto exit_free;

}

/* Probe entries are done second, and are not affected by ignore

entries either */

//address_data->probe支持的设备地址不受

//address_data->ignore（忽略某些地址）的影响

//而address_data->normal_i2c[i]中的地址就要受到ignore的影响

for (i = 0; address_data->probe[i] != I2C_CLIENT_END; i += 2) {

if (address_data->probe[i] == adap_id

|| address_data->probe[i] == ANY_I2C_BUS) {

dev_dbg(&adapter->dev, "found probe parameter for "

"adapter %d, addr 0x%02x\n", adap_id,

address_data->probe[i + 1]);

temp_client->addr = address_data->probe[i + 1];

//将这个地址对应的设备插入适配器。

err = i2c_detect_address(temp_client, -1, driver);

if (err)

goto exit_free;

}

}

/* Normal entries are done last, unless shadowed by an ignore entry */

//驱动中所支持的地址一般都存于address_data->normal_i2c中

for (i = 0; address_data->normal_i2c[i] != I2C_CLIENT_END; i += 1) {

int j, ignore;

ignore = 0;

for (j = 0; address_data->ignore[j] != I2C_CLIENT_END;

j += 2) {

if ((address_data->ignore[j] == adap_id ||

address_data->ignore[j] == ANY_I2C_BUS)

&& address_data->ignore[j + 1]

== address_data->normal_i2c[i]) {

dev_dbg(&adapter->dev, "found ignore "

"parameter for adapter %d, "

"addr 0x%02x\n", adap_id,

address_data->ignore[j + 1]);

ignore = 1;

break;

}

}

if (ignore)

continue;

dev_dbg(&adapter->dev, "found normal entry for adapter %d, "

"addr 0x%02x\n", adap_id,

address_data->normal_i2c[i]);

temp_client->addr = address_data->normal_i2c[i];

//将这个地址对应的设备插入适配器。

err = i2c_detect_address(temp_client, -1, driver);

if (err)

goto exit_free;

}

exit_free:

kfree(temp_client);

return err;

}



static int i2c_detect_address(struct i2c_client *temp_client, int kind,

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 */

if (addr < 0x03 || addr > 0x77) {

dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",

addr);

return -EINVAL;

}

/* Skip if already in use */

//检测这个地址在适配器adapter中是否被占用。

if (i2c_check_addr(adapter, addr))

return 0;

/* Make sure there is something at this address, unless forced */

if (kind < 0) {

if (i2c_smbus_xfer(adapter, addr, 0, 0, 0,

I2C_SMBUS_QUICK, NULL) < 0)

return 0;

/* prevent 24RF08 corruption */

if ((addr & ~0x0f) == 0x50)

i2c_smbus_xfer(adapter, addr, 0, 0, 0,

I2C_SMBUS_QUICK, NULL);

}

/* Finally call the custom detection function */

//清空构体info准备存放信息

memset(&info, 0, sizeof(struct i2c_board_info));

info.addr = addr;

//该函数为结构体info填充一些信息。

err = driver->detect(temp_client, kind, &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 */

/*

info.type在函数driver->detect中将把driver->name拷给它。

info.type最终将在函数i2c_new_device中

strlcpy(client->name, info->type, sizeof(client->name))；

client代表一个具体的设备，驱动对应着设备，当驱动与设备

相匹配时执行初始化函数函数probe。

在总线i2c_bus_type上驱动与设备匹配的条件是，name相同。

*/

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 succeeded, instantiate the device */

dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",

info.type, info.addr);

//获取了足够的建立client的信息（info）则注册client，并插入适配器

client = i2c_new_device(adapter, &info);

if (client)//这些设备都是driver所支持的，所以要挂到driver->clients上。

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;

}





struct i2c_client *

i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)

{

struct i2c_client *client;

int status;

//将结构体info中存储的各种信息用来初始化client。

//函数driver->detect(temp_client, kind, &info);

//是用来填充info中的值的，由此可见该函数的重要性。

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;

//为结构体client命名该名来至携带client地址信息的驱动

strlcpy(client->name, info->type, sizeof(client->name));

/* a new style driver may be bound to this device when we

* return from this function, or any later moment (e.g. maybe

* hotplugging will load the driver module). and the device

* refcount model is the standard driver model one.

*/

//device_register(&client->dev);注册设备并

//client->dev.parent = &client->adapter->dev;

//以上设置很重要是函数device_for_each_child实现的基础。

status = i2c_attach_client(client);

if (status < 0) {

kfree(client);

client = NULL;

}

return client;

}



int i2c_attach_client(struct i2c_client *client)

{

struct i2c_adapter *adapter = client->adapter;

int res;

/* Check for address business */

//检测地址client->addr在适配器adapter中是否已被占据

res = i2c_check_addr(adapter, client->addr);

if (res)

return res;

//该适配器是所有它支持的设备的父设备

client->dev.parent = &client->adapter->dev;

client->dev.bus = &i2c_bus_type;

if (client->driver)

client->dev.driver = &client->driver->driver;

/*

有两种驱动new-style drivers 和"legacy" drivers前者只注册

client，匹配相应驱动，执行函数probe()。后者是添加适配器

创建设备节点。

*/

if (client->driver && !is_newstyle_driver(client->driver)) {

/*

在函数i2c_client_release中调用complete(&client->released);

通知完成released。在函数i2c_detach_client中有

wait_for_completion(&client->released);

*/

client->dev.release = i2c_client_release;

dev_set_uevent_suppress(&client->dev, 1);

} else

client->dev.release = i2c_client_dev_release;

//注意client->dev->name与client->name的区分

dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adapter),

client->addr);

res = device_register(&client->dev);//注册设备

if (res)

goto out_err;

mutex_lock(&adapter->clist_lock);

//将适配器支持的设备插入适配器

list_add_tail(&client->list, &adapter->clients);

mutex_unlock(&adapter->clist_lock);

dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",

client->name, dev_name(&client->dev));

//好像该做的都做完了，函数adapter->client_register或许

//在某些特定的场合有着它特定的作用

if (adapter->client_register) {

if (adapter->client_register(client)) {

dev_dbg(&adapter->dev, "client_register "

"failed for client [%s] at 0x%02x\n",

client->name, client->addr);

}

}

return 0;

out_err:

dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "

"(%d)\n", client->name, client->addr, res);

return res;

}