Linux设备驱动之I2C架构分析

你的名字 2022-09-29 15:59 189阅读 0赞

一:前言

I2c是philips提出的外设总线.I2C只有两条线,一条串行数据线:SDA,一条是时钟线SCL.正因为这样,它方便了工程人员的布线.另外,I2C是一种多主机控制总线.它和USB总线不同,USB是基于master-slave机制,任何设备的通信必须由主机发起才可以.而I2C是基于multi master机制.一同总线上可允许多个master.关于I2C协议的知识,这里不再赘述.可自行下载spec阅读即可.

二:I2C架构概述

在linux中,I2C驱动架构如下所示:

![110219082036791.jpg][]

如上图所示,每一条I2C对应一个adapter.在kernel中,每一个adapter提供了一个描述的结构(struct i2c\_adapter),也定义了adapter支持的操作(struct i2c\_adapter).再通过i2c core层将i2c设备与i2c adapter关联起来.

这个图只是提供了一个大概的框架.在下面的代码分析中,从下至上的来分析这个框架图.以下的代码分析是基于linux 2.6.26.分析的代码基本位于: linux-2.6.26.3/drivers/i2c/位置.

三:adapter注册

在kernel中提供了两个adapter注册接口,分别为i2c\_add\_adapter()和i2c\_add\_numbered\_adapter().由于在系统中可能存在多个adapter,因为将每一条I2C总线对应一个编号,下文中称为I2C总线号.这个总线号的PCI中的总线号不同.它和硬件无关,只是软件上便于区分而已.

对于i2c\_add\_adapter()而言,它使用的是动态总线号,即由系统给其分析一个总线号,而i2c\_add\_numbered\_adapter()则是自己指定总线号,如果这个总线号非法或者是被占用,就会注册失败.

分别来看一下这两个函数的代码:

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

在这里涉及到一个idr结构.idr结构本来是为了配合page cache中的radix tree而设计的.在这里我们只需要知道,它是一种高效的搜索树,且这个树预先存放了一些内存.避免在内存不够的时候出现问题.所在,在往idr中插入结构的时候,首先要调用idr\_pre\_get()为它预留足够的空闲内存,然后再调用idr\_get\_new\_above()将结构插入idr中,该函数以参数的形式返回一个id.以后凭这个id就可以在idr中找到相对应的结构了.对这个数据结构操作不太理解的可以查阅本站<< linux文件系统之文件的读写>>中有关radix tree的分析.

注意一下idr\_get\_new\_above(&i2c\_adapter\_idr, adapter,\_\_i2c\_first\_dynamic\_bus\_num, &id)的参数的含义,它是将adapter结构插入到i2c\_adapter\_idr中,存放位置的id必须要大于或者等于\_\_i2c\_first\_dynamic\_bus\_num,

然后将对应的id号存放在adapter->nr中.调用i2c\_register\_adapter(adapter)对这个adapter进行进一步注册.

看一下另外一人注册函数: i2c\_add\_numbered\_adapter( ),如下所示:

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;

对比一下就知道差别了,在这里它已经指定好了adapter->nr了.如果分配的id不和指定的相等,便返回错误.

过一步跟踪i2c\_register\_adapter().代码如下:

static int i2c\_register\_adapter(struct i2c\_adapter \*adap)

int res = 0, dummy;

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

sprintf(adap->dev.bus\_id, "i2c-%d", adap->nr);

adap->dev.release = &i2c\_adapter\_dev\_release;

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

if (adap->nr < \_\_i2c\_first\_dynamic\_bus\_num)

i2c\_scan\_static\_board\_info(adap);

/\* let legacy drivers scan this bus for matching devices \*/

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;

首先对adapter和adapter中内嵌的struct device结构进行必须的初始化.之后将adapter内嵌的struct device注册.

在这里注意一下adapter->dev的初始化.它的类别为i2c\_adapter\_class,如果没有父结点,则将其父结点设为platform\_bus.adapter->dev的名字为i2c + 总线号.

测试一下:

\[eric@mochow i2c\]$ cd /sys/class/i2c-adapter/

\[eric@mochow i2c-adapter\]$ ls

i2c-0

可以看到,在我的PC上,有一个I2C adapter,看下详细信息:

\[eric@mochow i2c-adapter\]$ tree

\`-- i2c-0

|-- device -> ../../../devices/pci0000:00/0000:00:1f.3/i2c-0

|-- name

|-- subsystem -> ../../../class/i2c-adapter

\`-- uevent

3 directories, 2 files

可以看到,该adapter是一个PCI设备.

继续往下看:

之后,在注释中看到,有两种类型的driver,一种是new-style drivers,另外一种是legacy drivers

New-style drivers是在2.6近版的kernel加入的.它们最主要的区别是在adapter和i2c driver的匹配上.

int res;

printk(KERN\_INFO "i2c /dev entries driver/n");

res = register\_chrdev(I2C\_MAJOR, "i2c", &i2cdev\_fops);

if (res)

goto out;

i2c\_dev\_class = class\_create(THIS\_MODULE, "i2c-dev");

if (IS\_ERR(i2c\_dev\_class))

goto out\_unreg\_chrdev;

res = i2c\_add\_driver(&i2cdev\_driver);

if (res)

goto out\_unreg\_class;

return 0;

out\_unreg\_class:

class\_destroy(i2c\_dev\_class);

out\_unreg\_chrdev:

unregister\_chrdev(I2C\_MAJOR, "i2c");

out:

printk(KERN\_ERR "%s: Driver Initialisation failed/n", \_\_FILE\_\_);

return res;

首先为主册了一个主设备号为I2C\_MAJOR(89),操作集为i2cdev\_fops的字符设备.然后注册了一个名为”i2c-dev”的class.之后再注册了一个i2c的driver.如下所示:

res = i2c\_add\_driver(&i2cdev\_driver);

if (res)

goto out\_unreg\_class;

i2cdev\_driver定义如下:

static struct i2c\_driver i2cdev\_driver = \{

.driver = \{

.name   = "dev\_driver",

\},

.id     = I2C\_DRIVERID\_I2CDEV,

.attach\_adapter = i2cdev\_attach\_adapter,

.detach\_adapter = i2cdev\_detach\_adapter,

.detach\_client  = i2cdev\_detach\_client,

\};

也就是说,当它注册或者有新的adapter注册后,就会它的attach\_adapter()函数.该函数代码如下:

static int i2cdev\_attach\_adapter(struct i2c\_adapter \*adap)

struct i2c\_dev \*i2c\_dev;

int res;

i2c\_dev = get\_free\_i2c\_dev(adap);

if (IS\_ERR(i2c\_dev))

return PTR\_ERR(i2c\_dev);

/\* register this i2c device with the driver core \*/

i2c\_dev->dev = device\_create(i2c\_dev\_class, &adap->dev,

MKDEV(I2C\_MAJOR, adap->nr),

"i2c-%d", adap->nr);

if (IS\_ERR(i2c\_dev->dev)) \{

res = PTR\_ERR(i2c\_dev->dev);

goto error;

res = device\_create\_file(i2c\_dev->dev, &dev\_attr\_name);

if (res)

goto error\_destroy;

pr\_debug("i2c-dev: adapter \[%s\] registered as minor %d/n",

adap->name, adap->nr);

return 0;

error\_destroy:

device\_destroy(i2c\_dev\_class, MKDEV(I2C\_MAJOR, adap->nr));

error:

return\_i2c\_dev(i2c\_dev);

return res;

这个函数也很简单,首先调用get\_free\_i2c\_dev()分配并初始化了一个struct i2c\_dev结构,使i2c\_dev->adap指向操作的adapter.之后,该i2c\_dev会被链入链表i2c\_dev\_list中.再分别以I2C\_MAJOR, adap->nr为主次设备号创建了一个device.如果此时系统配置了udev或者是hotplug,那么就么在/dev下自动创建相关的设备节点了.

刚才我们说过,所有主设备号为I2C\_MAJOR的设备节点的操作函数是i2cdev\_fops.它的定义如下所示:

static const struct file\_operations i2cdev\_fops = \{

.owner      = THIS\_MODULE,

.llseek     = no\_llseek,

.read       = i2cdev\_read,

.write      = i2cdev\_write,

.ioctl      = i2cdev\_ioctl,

.open       = i2cdev\_open,

.release    = i2cdev\_release,

\};

7.1:i2c dev的open操作

Open操作对应的函数为i2cdev\_open().代码如下:

static int i2cdev\_open(struct inode \*inode, struct file \*file)

unsigned int minor = iminor(inode);

struct i2c\_client \*client;

struct i2c\_adapter \*adap;

struct i2c\_dev \*i2c\_dev;

//以次设备号从i2c\_dev\_list链表中取得i2c\_dev

i2c\_dev = i2c\_dev\_get\_by\_minor(minor);

if (!i2c\_dev)

return -ENODEV;

//以apapter的总线号从i2c\_adapter\_idr中找到adapter

adap = i2c\_get\_adapter(i2c\_dev->adap->nr);

if (!adap)

return -ENODEV;

/\* This creates an anonymous i2c\_client, which may later be

\* pointed to some address using I2C\_SLAVE or I2C\_SLAVE\_FORCE.

\* This client is \*\* NEVER REGISTERED \*\* with the driver model

\* or I2C core code!!  It just holds private copies of addressing

\* information and maybe a PEC flag.

\*/

//分配并初始化一个i2c\_client结构

client = kzalloc(sizeof(\*client), GFP\_KERNEL);

if (!client) \{

i2c\_put\_adapter(adap);

return -ENOMEM;

snprintf(client->name, I2C\_NAME\_SIZE, "i2c-dev %d", adap->nr);

client->driver = &i2cdev\_driver;

//clinet->adapter指向操作的adapter

client->adapter = adap;

//关联到file

file->private\_data = client;

return 0;

注意这里分配并初始化了一个struct i2c\_client结构.但是没有注册这个clinet.此外,这个函数中还有一个比较奇怪的操作.不是在前面已经将i2c\_dev->adap指向要操作的adapter么?为什么还要以adapter->nr为关键字从i2c\_adapter\_idr去找这个操作的adapter呢?注意了,调用i2c\_get\_adapter()从总线号nr找到操作的adapter的时候,还会增加module的引用计数.这样可以防止模块意外被释放掉.也许有人会有这样的疑问,那 i2c\_dev->adap->nr操作,如果i2c\_dev->adap被释放掉的话,不是一样会引起系统崩溃么?这里因为,在i2cdev\_attach\_adapter()间接的增加了一次adapter的一次引用计数.如下:

tatic int i2cdev\_attach\_adapter(struct i2c\_adapter \*adap)

．．．．．．

i2c\_dev->dev = device\_create(i2c\_dev\_class, &adap->dev,

MKDEV(I2C\_MAJOR, adap->nr),

"i2c-%d", adap->nr);

．．．．．．

看到了么，i2c\_dev内嵌的device是以adap->dev为父结点,在device\_create()中会增次adap->dev的一次引用计数.

好了,open()操作到此就完成了.

7.2:read操作

Read操作对应的操作函数如下示:

static ssize\_t i2cdev\_read (struct file \*file, char \_\_user \*buf, size\_t count,

loff\_t \*offset)

char \*tmp;

int ret;

struct i2c\_client \*client = (struct i2c\_client \*)file->private\_data;

if (count > 8192)

count = 8192;

tmp = kmalloc(count,GFP\_KERNEL);

if (tmp==NULL)

return -ENOMEM;

pr\_debug("i2c-dev: i2c-%d reading %zd bytes./n",

iminor(file->f\_path.dentry->d\_inode), count);

ret = i2c\_master\_recv(client,tmp,count);

if (ret >= 0)

ret = copy\_to\_user(buf,tmp,count)?-EFAULT:ret;

kfree(tmp);

return ret;

首先从file结构中取得struct i2c\_clinet.然后在kernel同分配相同长度的缓存区,随之调用i2c\_master\_recv()从设备中读取数据.再将读取出来的数据copy到用户空间中.

I2c\_master\_recv()代码如下:

int i2c\_master\_recv(struct i2c\_client \*client, char \*buf ,int count)

struct i2c\_adapter \*adap=client->adapter;

struct i2c\_msg msg;

int ret;

msg.addr = client->addr;

msg.flags = client->flags & I2C\_M\_TEN;

msg.flags |= I2C\_M\_RD;

msg.len = count;

msg.buf = buf;

ret = i2c\_transfer(adap, &msg, 1);

/\* If everything went ok (i.e. 1 msg transmitted), return \#bytes

transmitted, else error code. \*/

return (ret == 1) ? count : ret;

看完前面的代码之后,这个函数应该很简单了,就是为读操作初始化了一个i2c\_msg.然后调用i2c\_tanster().代码中的client->flags & I2C\_M\_TEN表示adapter是否采用10位寻址的方式.在这里就不再详细分析了.

另外,有人可能看出了一个问题.这里clinet->addr是从哪来的呢?对,在read之前应该还要有一步操作来设置clinet->addr的值.这个过程是ioctl的操作.ioctl可以设置PEC标志,重试次数,超时时间,和发送接收数据等,我们在这里只看一下clinet->addr的设置.代码片段如下示:

static int i2cdev\_ioctl(struct inode \*inode, struct file \*file,

unsigned int cmd, unsigned long arg)

．．．．．．

switch ( cmd ) \{

case I2C\_SLAVE:

case I2C\_SLAVE\_FORCE:

/\* NOTE:  devices set up to work with "new style" drivers

\* can't use I2C\_SLAVE, even when the device node is not

\* bound to a driver.  Only I2C\_SLAVE\_FORCE will work.

\* Setting the PEC flag here won't affect kernel drivers,

\* which will be using the i2c\_client node registered with

\* the driver model core.  Likewise, when that client has

\* the PEC flag already set, the i2c-dev driver won't see

\* (or use) this setting.

\*/

if ((arg > 0x3ff) ||

(((client->flags & I2C\_M\_TEN) == 0) && arg > 0x7f))

return -EINVAL;

if (cmd == I2C\_SLAVE && i2cdev\_check\_addr(client->adapter, arg))

return -EBUSY;

/\* REVISIT: address could become busy later \*/

client->addr = arg;

return 0;

．．．．．．

由此可见,调用I2C\_SLAVE或者I2C\_SLAVE\_FORCE的Ioctl就会设置clinet->addr.另外,注释中也说得很清楚了.如果是I2C\_SLAVE的话,还会调用其所长i2cdev\_check\_addr().进行地址检查,如果adapter已经关联到这个地址的设备,就会检查失败.

7.2:write操作

Write操作如下所示:

static ssize\_t i2cdev\_write (struct file \*file, const char \_\_user \*buf, size\_t count,

loff\_t \*offset)

int ret;

char \*tmp;

struct i2c\_client \*client = (struct i2c\_client \*)file->private\_data;

if (count > 8192)

count = 8192;

tmp = kmalloc(count,GFP\_KERNEL);

if (tmp==NULL)

return -ENOMEM;