linux中的IIC设备驱动

linux中的IIC驱动很庞大，驱动中随处可见

智能手机和平板电脑上用的sensor几乎都是IIC设备，比如：camera，电容触摸屏，重力/加速度sensor，环境光sensor，指南针sensor

IIC驱动主要分为Master和Slave，Master就是主机控制器，像S3C2440内部的IIC控制器就是一个Master

Slave就是IIC从机设备，它要被挂接到Master上才能工作

Master驱动这里就不说了，每种带有IIC控制器的处理器都有相应的驱动，假设我的内核已经支持了Master的IIC驱动

最近在android下调camera驱动，下面整理一下IIC设备驱动的写法，编写camera驱动的IIC部分，IIC设备驱动的写法很灵活，这里只介绍最简单基本的框架

首先在每个驱动文件中都要包含IIC的头文件

#include <linux/i2c.h>

重要的结构体有：

i2c_board_info  i2c_client  i2c_msg

主要的函数：

i2c_register_board_info

i2c_add_driver

i2c_check_functionality

i2c_transfer

在bsp文件中:

1. //In machine init code:
   
2. i2c_register_board_info(i2c_bus_num, cam_i2c_board_info, ARRAY_SIZE(cam_i2c_board_info));

i2c_bus_num是指定设备挂接在哪个IIC总线上，用0,1,2....数字表示（有的平台只有一路IIC，有的平台有多路）

1. #define I2C_CAM_SLAVE_ADDRESS        0x42 //device address
   
2. 
   
3. //自己构建的平台数据结构
   
4. struct i2c_slave_platform_data cam_pdata = {
   
5.     //your code
   
6. };
   
7. 
   
8. //i2c_board_info
   
9. static struct i2c_board_info __initdata cam_i2c_board_info[] = {
   
10.     {
    
11.         I2C_BOARD_INFO("i2c_dev_name", (I2C_CAM_SLAVE_ADDRESS >> 1)),
    
12.         .platform_data = (void *)&cam_pdata,
    
13.         .irq = IRQ_CAM,
    
14.     },    
    
15.     {
    
16.         //other i2c device code
    
17.     },
    
18. };

这样就完成了IIC设备在这个平台的IIC总线上的注册

在驱动文件中:

1. //in init code:
   
2. i2c_add_driver(&i2c_driver_cam);
   
3. 
   
4. struct i2c_driver i2c_driver_cam = {
   
5.     .driver = {
   
6.          .name = "i2c_dev_name",
   
7.          },
   
8.     .id_table = cam_i2c_id_table,
   
9.     .probe = cam_i2c_probe,
   
10.     .remove = cam_i2c_remove,
    
11.     .command = cam_i2c_command,
    
12. };
    
13. 
    
14. struct i2c_device_id cam_i2c_id_table[] = {
    
15.     {"i2c_dev_name", 0},
    
16.     {}
    
17. };

“i2c_dev_name”是一个字符串，代表IIC的设备名，要保持一致才能成功注册

定义一个全局变量，用于获得i2c_client

1. static struct i2c_client *this_client;
   
2. 
   
3. //probe
   
4. static int cam_i2c_probe(struct i2c_client *client, const struct i2c_device_id *dev_id)
   
5. {
   
6.     struct cam_data *ddata;
   
7. 
   
8.     if(dev_id)
   
9.     {
   
10.         printk("cam_i2c_probe, dev_id.name (%s) \r\n",dev_id->name);        
    
11.     }
    
12. 
    
13.     //检查IIC设备的功能
    
14.     if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
    
15.         err = -ENODEV;
    
16.         goto exit_check_functionality_failed;
    
17.     }
    
18. 
    
19.     ddata = kzalloc(sizeof(struct cam_data), GFP_KERNEL);
    
20.     if (!akm) {
    
21.         err = -ENOMEM;
    
22.         goto exit_alloc_data_failed;
    
23.     }
    
24. 
    
25.     i2c_set_clientdata(client, ddata);
    
26.     this_client = client; //将client赋给全局变量
    
27. 
    
28.     //other init code
    
29. 
    
30.     return 0;
    
31. }
    
32. 
    
33. //remove
    
34. static int cam_i2c_remove(struct i2c_client *client)
    
35. {
    
36.     struct cam_data *ddata = i2c_get_clientdata(client);
    
37. 
    
38.     //remove code    
    
39. 
    
40.     return 0;
    
41. }

i2c_command函数一般用不到，不用实现

IIC的读写函数：

1. //IIC write
   
2. static int CamI2C_WriteData(char *txData, int length)
   
3. {
   
4.     struct i2c_msg msg[] = {
   
5.         {
   
6.          .addr = this_client->addr,
   
7.          .flags = 0,
   
8.          .len = length,
   
9.          .buf = txData,
   
10.          },
    
11.     };
    
12. 
    
13.     if (i2c_transfer(this_client->adapter, msg, 1) < 0) {
    
14.         printk(KERN_ERR "CamI2C_WriteData: transfer error\n");
    
15.         return -EIO;
    
16.     } else
    
17.         return 0;
    
18. }    
    
19. 
    
20. //IIC Read
    
21. static int CAMI2C_ReadData(char *rxData, int length)
    
22. {
    
23.     struct i2c_msg msgs[] = {
    
24.         {
    
25.          .addr = this_client->addr,
    
26.          .flags = 0,
    
27.          .len = 1,
    
28.          .buf = rxData,
    
29.         },
    
30.         {
    
31.          .addr = this_client->addr,
    
32.          .flags = I2C_M_RD,
    
33.          .len = length,
    
34.          .buf = rxData,
    
35.         },
    
36.     };
    
37. 
    
38. 
    
39.     if (i2c_transfer(this_client->adapter, msgs, 2) < 0) {
    
40.         printk(KERN_ERR "CAMI2C_RxData: transfer error\n");
    
41.         return -EIO;
    
42.     } else
    
43.         return 0;
    
44. }

如果IIC设备支持smbus，可以使用smbus方式:

1. if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_BYTE_DATA)) {
   
2.     printk(KERN_ERR "I2C-Adapter doesn't support I2C_FUNC_SMBUS_BYTE\n");
   
3.     return -EIO;
   
4. }
   
5. 
   
6. //smbus read
   
7. static int Read_Data(struct i2c_client *client, const unsigned char reg)
   
8. {
   
9.     unsigned char ret = i2c_smbus_read_byte_data(client, reg);
   
10.     return ret;
    
11. }
    
12. 
    
13. //smbus write
    
14. static int Write_Data(struct i2c_client *client, const unsigned char reg, const unsigned char data)
    
15. {
    
16.     return i2c_smbus_write_bype_data(client, reg, data);
    
17. }

如果是16位数据，同样有i2c_smbus_read_word_data和i2c_smbus_read_word_data

在sensor设备驱动中，IIC只是做为一条总线传输数据，驱动的主体部分主要还是由input子层来完成的，在android中这是一种很常见的驱动模式