版权声明：本文为博主原创文章，未经博主允许不得转载。

目录(?)[-]

1. 预备知识
2. linux设备驱动到底复杂在什么地方
3. linux驱动中 i2c驱动架构
4. 架构层次分类
5. 具体分析
1. i2c_driver
2. i2c_client
3. i2c_adapter
4. i2c_algorithm
6. 梳理图
7. ov2715设备i2c驱动源码分析

1. i2c_adapter1_ReadWrite_i2c_device1();
2. i2c_adapter1_ReadWrite_i2c_device2()
3. i2c_adapter1_ReadWrite_i2c_device3()
4. i2c_adapter2_ReadWrite_i2c_device1()
5. i2c_adapter2_ReadWrite_i2c_device2()
6. i2c_adapter2_ReadWrite_i2c_device3()

1. struct i2c_driver {
2. int id;
3. unsigned int class;
4. int (*attach_adapter)(struct i2c_adapter *);
5. int (*detach_adapter)(struct i2c_adapter *);
6. int (*detach_client)(struct i2c_client *);
7. int (*command)(struct i2c_client *client,unsigned int cmd, void *arg);
8. struct device_driver driver;
9. struct list_head list;
10. };

1. struct i2c_client {
2. unsigned int flags;     /* div., see below      */
3. unsigned short addr;        /* chip address - NOTE: 7bit    */
4. /* addresses are stored in the  */
5. /* _LOWER_ 7 bits       */
6. struct i2c_adapter *adapter;    /* the adapter we sit on    */
7. struct i2c_driver *driver;  /* and our access routines  */
8. int usage_count;        /* How many accesses currently  */
9. /* to the client        */
10. struct device dev;      /* the device structure     */
11. struct list_head list;
12. char name[I2C_NAME_SIZE];
13. struct completion released;
14. };

1. struct i2c_adapter {
2. struct module *owner;
3. unsigned int id;
4. unsigned int class;
5. struct i2c_algorithm *algo;/* the algorithm to access the bus   */
6. void *algo_data;
7. /* --- administration stuff. */
8. int (*client_register)(struct i2c_client *);
9. int (*client_unregister)(struct i2c_client *);
10. /* data fields that are valid for all devices   */
11. struct mutex bus_lock;
12. struct mutex clist_lock;
13. int timeout;
14. int retries;
15. struct device dev;      /* the adapter device */
16. struct class_device class_dev;  /* the class device */
17. int nr;
18. struct list_head clients;
19. struct list_head list;
20. char name[I2C_NAME_SIZE];
21. struct completion dev_released;
22. struct completion class_dev_released;
23. };

1. struct i2c_algorithm {
2. int (*master_xfer)(struct i2c_adapter *adap,struct i2c_msg *msgs,
3. int num);
4. int (*slave_send)(struct i2c_adapter *,char*,int);
5. int (*slave_recv)(struct i2c_adapter *,char*,int);
6. u32 (*functionality) (struct i2c_adapter *);
7. };

1. /*
2. * I2C Message - used for pure i2c transaction, also from /dev interface
3. */
4. struct i2c_msg {
5. __u16 addr; /* slave address            */
6. __u16 flags;
7. __u16 len;      /* msg length               */
8. __u8 *buf;      /* pointer to msg data          */
9. };

1. EXPORT_SYMBOL(i2c_add_adapter);
2. EXPORT_SYMBOL(i2c_del_adapter);
3. EXPORT_SYMBOL(i2c_del_driver);
4. EXPORT_SYMBOL(i2c_attach_client);
5. EXPORT_SYMBOL(i2c_detach_client);
6. EXPORT_SYMBOL(i2c_transfer);

1. int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
2. {
3. int ret;
4. if (adap->algo->master_xfer) {//如果master_xfer函数存在，则调用，否则返回错误
5. ret = adap->algo->master_xfer(adap,msgs,num);//这个函数在硬件相关的代码中给algorithm赋值
6. return ret;
7. } else {
8. return -ENOSYS;
9. }
10. }

1. int i2c_attach_client(struct i2c_client *client)
2. {
3. ...
4. device_register(&client->dev);
5. device_create_file(&client->dev, &dev_attr_client_name);
6. ...
7. return 0;
8. }

1. int i2c_detach_client(struct i2c_client *client)
2. {
3. ...
4. device_remove_file(&client->dev, &dev_attr_client_name);
5. device_unregister(&client->dev);
6. ...
7. return res;
8. }

1. /* -----
2. * i2c_add_adapter is called from within the algorithm layer,
3. * when a new hw adapter registers. A new device is register to be
4. * available for clients.
5. */
6. int i2c_add_adapter(struct i2c_adapter *adap)
7. {
8. ...
9. device_register(&adap->dev);
10. device_create_file(&adap->dev, &dev_attr_name);
11. ...
12. /* inform drivers of new adapters */
13. list_for_each(item,&drivers) {
14. driver = list_entry(item, struct i2c_driver, list);
15. if (driver->attach_adapter)
16. /* We ignore the return code; if it fails, too bad */
17. driver->attach_adapter(adap);
18. }
19. ...
20. }

1. int i2c_del_adapter(struct i2c_adapter *adap)
2. {
3. ...
4. list_for_each(item,&drivers) {
5. driver = list_entry(item, struct i2c_driver, list);
6. if (driver->detach_adapter)
7. if ((res = driver->detach_adapter(adap))) {
8. }
9. }
10. ...
11. list_for_each_safe(item, _n, &adap->clients) {
12. client = list_entry(item, struct i2c_client, list);
13. if ((res=client->driver->detach_client(client))) {
14. }
15. }
16. ...
17. device_remove_file(&adap->dev, &dev_attr_name);
18. device_unregister(&adap->dev);
19. }

1. static struct platform_driver davinci_i2c_driver = {
2. .probe      = davinci_i2c_probe,
3. .remove     = davinci_i2c_remove,
4. .driver     = {
5. .name   = "i2c_davinci",
6. .owner  = THIS_MODULE,
7. },
8. };
9. /* I2C may be needed to bring up other drivers */
10. static int __init davinci_i2c_init_driver(void)
11. {
12. return platform_driver_register(&davinci_i2c_driver);
13. }
14. subsys_initcall(davinci_i2c_init_driver);
15. static void __exit davinci_i2c_exit_driver(void)
16. {
17. platform_driver_unregister(&davinci_i2c_driver);
18. }
19. module_exit(davinci_i2c_exit_driver);

1. static struct i2c_algorithm i2c_davinci_algo = {
2. .master_xfer    = i2c_davinci_xfer,
3. .functionality  = i2c_davinci_func,
4. };

1. adap->algo = &i2c_davinci_algo;

1. typedef struct {
2. int devAddr;
3. struct i2c_client client;   //!< Data structure containing general access routines.
4. struct i2c_driver driver;   //!< Data structure containing information specific to each client.
5. char name[20];
6. int nameSize;
7. int users;
8. } I2C_Obj;

1. #define I2C_DEV_MAX_ADDR  (0xFF)
2. #define I2C_TRANSFER_BUF_SIZE_MAX   (256)
3. typedef struct {
4. struct cdev cdev;             /* Char device structure    */
5. int     major;
6. struct semaphore semLock;
7. I2C_Obj *pObj[I2C_DEV_MAX_ADDR];
8. uint8_t reg[I2C_TRANSFER_BUF_SIZE_MAX];
9. uint16_t reg16[I2C_TRANSFER_BUF_SIZE_MAX];
10. uint8_t buffer[I2C_TRANSFER_BUF_SIZE_MAX*4];
11. } I2C_Dev;

1. int I2C_devInit(void)
2. {
3. int     result, i;
4. dev_t   dev = 0;
5. result = alloc_chrdev_region(&dev, 0, 1, I2C_DRV_NAME);//分配字符设备空间
6. for(i=0; i<I2C_DEV_MAX_ADDR; i++)
7. {
8. gI2C_dev.pObj[i]=NULL;
9. }
10. gI2C_dev.major = MAJOR(dev);//保存设备主编号
11. sema_init(&gI2C_dev.semLock, 1);//信号量初始化
12. cdev_init(&gI2C_dev.cdev, &gI2C_devFileOps);//使用gI2C_devFileOps初始化该字符设备，gI2C_devFileOps见下文
13. gI2C_dev.cdev.owner = THIS_MODULE;//常规赋值
14. gI2C_dev.cdev.ops = &gI2C_devFileOps;//常规赋值 result = cdev_add(&gI2C_dev.cdev, dev, 1);//添加设备到字符设备中 return result;}void I2C_devExit(void){ dev_t devno = MKDEV(gI2C_dev.major, 0); cdev_del(&gI2C_dev.cdev);//从字符设备中删除该设备 unregister_chrdev_region(devno, 1);//回收空间}
15. gI2c_devFileOps全局变量，驱动初始化会用到该结构体变量
16. struct file_operations gI2C_devFileOps = {
17. .owner = THIS_MODULE,
18. .open = I2C_devOpen,
19. .release = I2C_devRelease,
20. .ioctl = I2C_devIoctl,
21. };

1. int I2C_devIoctl(struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg)
2. {
3. I2C_Obj *pObj;
4. int status=0;
5. I2C_TransferPrm transferPrm;
6. pObj = (I2C_Obj *)filp->private_data;
7. if(!I2C_IOCTL_CMD_IS_VALID(cmd))
8. return -1;
9. cmd = I2C_IOCTL_CMD_GET(cmd);//cmd命令转换，防止混淆，具体原因参见上一篇文章：ioctl中的cmd
10. down_interruptible(&gI2C_dev.semLock);      //信号量down
11. switch(cmd)
12. {
13. case I2C_CMD_SET_DEV_ADDR://命令1，设置设备地址
14. filp->private_data = I2C_create(arg);
15. case I2C_CMD_WRITE:  //命令2，写寄存器值
16. status = copy_from_user(&transferPrm, (void *)arg, sizeof(transferPrm));
17. ...
18. break;
19. case I2C_CMD_READ:  //命令3，读寄存器值
20. status = copy_from_user(&transferPrm, (void *)arg, sizeof(transferPrm));
21. ...
22. break;
23. default:
24. status = -1;
25. break;
26. }
27. up(&gI2C_dev.semLock);      //信号量up
28. return status;
29. }

1. void *I2C_create(int devAddr) {
2. int ret;
3. struct i2c_driver *driver;
4. struct i2c_client *client = client;
5. I2C_Obj *pObj;
6. devAddr >>= 1;
7. if(devAddr>I2C_DEV_MAX_ADDR)  //变量合法性判断
8. return NULL;
9. if(gI2C_dev.pObj[devAddr]!=NULL) {  //变量合法性判断，如果该地址的设备已经创建，则调过，防止上层错误调用
10. // already allocated, increment user count, and return the allocated handle
11. gI2C_dev.pObj[devAddr]->users++;
12. return gI2C_dev.pObj[devAddr];
13. }
14. pObj = (void*)kmalloc( sizeof(I2C_Obj), GFP_KERNEL); //为pObj分配空间
15. gI2C_dev.pObj[devAddr] = pObj;  //将分配的空间地址保存在全局变量里
16. memset(pObj, 0, sizeof(I2C_Obj));
17. pObj->client.adapter = NULL;
18. pObj->users++;    //用户基数，初始化为0，当前设为1
19. pObj->devAddr = devAddr;  //保存设备地址
20. gI2C_curAddr = pObj->devAddr;  //gI2C_curAddr为全局的整型变量，用于保存当前的设备地址
21. driver = &pObj->driver;  //将成员变量driver单独抽取出来，因为线面要使用driver来初始化驱动
22. pObj->nameSize=0;//i2c设备名称，注意，这里不是在/dev下面的设备节点名
23. pObj->name[pObj->nameSize++] = 'I';
24. pObj->name[pObj->nameSize++] = '2';
25. pObj->name[pObj->nameSize++] = 'C';
26. pObj->name[pObj->nameSize++] = '_';
27. pObj->name[pObj->nameSize++] = 'A' + ((pObj->devAddr >> 0) & 0xF);
28. pObj->name[pObj->nameSize++] = 'B' + ((pObj->devAddr >> 4) & 0xF);
29. pObj->name[pObj->nameSize++] = 0;
30. driver->driver.name = pObj->name; //保存刚才设置的name
31. driver->id = I2C_DRIVERID_MISC;
32. driver->attach_adapter = I2C_attachAdapter;   //这个很重要，将驱动连接到i2c适配器上，在后面分析
33. driver->detach_client = I2C_detachClient;    //这个很重，在后面分析
34. if((ret = i2c_add_driver(driver)))  //使用i2c-core（i2c_register_driver函数）的接口，注册该驱动，i2c_add_driver实质调用了driver_register()
35. {
36. printk( KERN_ERR "I2C: ERROR: Driver registration failed (address=%x), module not inserted.\n", pObj->devAddr);
37. }
38. if(ret<0) {
39. gI2C_dev.pObj[pObj->devAddr] = NULL;
40. kfree(pObj);
41. return NULL;
42. }
43. return pObj;
44. }

1. int I2C_write(I2C_Obj *pObj, uint8_t *reg, uint8_t *buffer, uint8_t count, uint8_t dataSize)
2. {
3. uint8_t i;
4. int err;
5. struct i2c_client *client;
6. struct i2c_msg msg[1];
7. unsigned char data[8];
8. if(pObj==NULL)
9. return -ENODEV;
10. client = &pObj->client;//得到client信息
11. if(!client->adapter)
12. return -ENODEV;
13. if(dataSize<=0||dataSize>4)
14. return -1;
15. for(i=0; i<count; i++) {
16. msg->addr = client->addr;//设置要写的i2c设备地址
17. msg->flags= 0;//一直为0
18. msg->buf  = data;//date为准备i2c通信的缓冲区，这个缓冲区除了不包含设备地址外，要包括要目标寄存器地址，和要写入该寄存器的值
19. data[0] = reg[i];//寄存器地址赋值
20. if(dataSize==1) {//寄存器值长度为1
21. data[1]  = buffer[i];//寄存器值赋值
22. msg->len = 2;     //设置data长度为2
23. }   else if(dataSize==2) {//寄存器值长度为2
24. data[1] = buffer[2*i+1];
25. data[2] = buffer[2*i];
26. msg->len = 3;
27. }
28. err = i2c_transfer(client->adapter, msg, 1);//调用i2c-core中的i2c_transfer发送i2c数据
29. if( err < 0 )
30. return err;
31. }
32. return 0;
33. }

1. driver->driver.name = pObj->name;
2. driver->id = I2C_DRIVERID_MISC;
3. driver->attach_adapter = I2C_attachAdapter;
4. driver->detach_client = I2C_detachClient;

1. /* Notifies the driver that a new bus has appeared. This routine
2. * can be used by the driver to test if the bus meets its conditions
3. * & seek for the presence of the chip(s) it supports. If found, it
4. * registers the client(s) that are on the bus to the i2c admin. via
5. * i2c_attach_client.
6. */

1. int I2C_attachAdapter(struct i2c_adapter *adapter)
2. {
3. return I2C_detectClient(adapter, gI2C_curAddr);
4. }
5. int I2C_detectClient(struct i2c_adapter *adapter, int address)
6. {
7. I2C_Obj *pObj;
8. struct i2c_client *client;
9. int err = 0;
10. if(address > I2C_DEV_MAX_ADDR) {
11. printk( KERN_ERR "I2C: ERROR: Invalid device address %x\n", address);
12. return -1;
13. }
14. pObj = gI2C_dev.pObj[address];
15. if(pObj==NULL) {
16. printk( KERN_ERR "I2C: ERROR: Object not found for address %x\n", address);
17. return -1;
18. }
19. client = &pObj->client;
20. if(client->adapter)
21. return -EBUSY;  /* our client is already attached */
22. memset(client, 0x00, sizeof(struct i2c_client));
23. client->addr = pObj->devAddr;
24. client->adapter = adapter;
25. client->driver = &pObj->driver;
26. if((err = i2c_attach_client(client)))
27. {
28. printk( KERN_ERR "I2C: ERROR: Couldn't attach %s (address=%x)\n", pObj->name, pObj->devAddr);
29. client->adapter = NULL;
30. return err;
31. }
32. return 0;
33. }

1. /* tells the driver that a client is about to be deleted & gives it
2. * the chance to remove its private data. Also, if the client struct
3. * has been dynamically allocated by the driver in the function above,
4. * it must be freed here.
5. */

1. int I2C_detachClient(struct i2c_client *client)
2. {
3. int err;
4. if(!client->adapter)
5. return -ENODEV; /* our client isn't attached */
6. if((err = i2c_detach_client(client))) {
7. printk( KERN_ERR "Client deregistration failed (address=%x), client not detached.\n", client->addr);
8. return err;
9. }
10. client->adapter = NULL;
11. return 0;
12. }