织梦CMS - 轻松建站从此开始！
高级搜索|网站地图|TAG标签RSS订阅[设为首页] [加入收藏]

罗索

搜索

热门标签:

当前位置: 主页>嵌入式开发>固件驱动开发>

驱动模块使用I2C总线范例

jackyhwei 发布于 2011-09-28 20:31 点击:次 
在嵌入式中，I2C接口的意义非常重大，许多外围芯片控制接口都采用I2C。因此，了解在驱动模块中如何进行I2C总线通信是很有必要的。我们先看看I2C驱动代码的树形结构
TAG:

在嵌入式中，I2C接口的意义非常重大，许多外围芯片控制接口都采用I2C。因此，了解在驱动模块中如何进行I2C总线通信是很有必要的。我们先看看I2C驱动代码的树形结构：

.

|-- Kconfig
|-- Makefile
|-- algos
|   |-- Kconfig
|   |-- Makefile
|   |-- i2c-algo-bit.c
|   |-- i2c-algo-pca.c
|   |-- i2c-algo-pcf.c
|   `-- i2c-algo-pcf.h
|-- busses
|   |-- Kconfig
|   |-- Makefile
|   |-- i2c-acorn.c
|   |-- ...
|   |-- i2c-gpio.c
|   |-- ...
|   |-- i2c-pxa.c
|   |-- i2c-s3c2410.c
|   `-- ...
|-- chips
|   |-- Kconfig
|   |-- Makefile
|   |-- ds1682.c
|   |-- pca963x.c
|   `-- tsl2550.c
|-- i2c-boardinfo.c
|-- i2c-core.c
|-- i2c-core.h
`-- i2c-dev.c

3 directories, 86 files

其中i2c-core.c是I2C核心部分，提供接口函数，i2c_adapter和i2c_driver在模块初始化时分别调用i2c_add_numbered_adapter()和i2c_add_driver()将其注册到I2C Core中。

i2c-dev.c是I2C设备部分，实现字符设备访问接口，对硬件的具体访问是通过i2c_adapter来实现的。它在初始化时，需要向I2C Core注册一个i2c_driver。我认为这部分仅仅是让用户层访问I2C总线的，如果内核态访问I2C总线的话，则没有必要理会它；但是我们需要参 考它来实现我们自己的i2c_driver，并且需要将这个i2c_driver注册到I2C Core。

busses目录下有许多个文件，为各种平台的I2C总线驱动，如s2c2410、pxa、mpc等等，跟硬件spec息息相关。一个总线驱动需要两个模块，用结构体i2c_adapter和i2c_algorithm来描述。

algos目录是对bus中的i2c_algorithm的补充，特别的i2c_algorithm可在这里实现。chips是I2C Slave芯片驱动代码，如I2C控制接口的eeprom、LED段码显示芯片等。

更详细的有关I2C驱动架构介绍的文章见：http://blog168.chinaunix.net/space.php?uid=11134731&do=blog&id=33193

下面是正题，附上示范代码，碰到相关场合，直接将其复制过去使用即可。

  1. #define AZURE_I2C_ADDR   0x1a 
  2. #define AZURE_I2C_BUS_NO 0 
  3.  
  4. static struct i2c_client *azure_i2c; 
  5.  
  6. static int azure_i2c_probe(struct i2c_client *i2c, 
  7.     const struct i2c_device_id *id) 
  8. { 
  9.     azure_i2c = i2c; 
  10.     i2c->addr = AZURE_I2C_ADDR; 
  11.      
  12.     return 0; 
  13. } 
  14.  
  15. static int azure_i2c_remove(struct i2c_client *client) 
  16. { 
  17.     return 0; 
  18. } 
  19.  
  20. static const struct i2c_device_id azure_i2c_id[] = { 
  21.     { "azure", 0 }, 
  22.     { } 
  23. }; 
  24. MODULE_DEVICE_TABLE(i2c, azure_i2c_id); 
  25.  
  26. static struct i2c_driver azure_i2c_driver = { 
  27.     .driver  = { 
  28.         .name  = "AZURE I2C", 
  29.         .owner = THIS_MODULE, 
  30.     }, 
  31.     .probe    = azure_i2c_probe, 
  32.     .remove   = azure_i2c_remove, 
  33.     .id_table = azure_i2c_id, 
  34. }; 
  35.  
  36. static int azure_add_i2c_device() 
  37. { 
  38.     struct i2c_board_info info; 
  39.     struct i2c_adapter *adapter; 
  40.     struct i2c_client *client; 
  41.     int ret; 
  42.  
  43.     memset(&info, 0, sizeof(struct i2c_board_info)); 
  44.     info.addr = AZURE_I2C_ADDR; 
  45.     strlcpy(info.type, "azure", I2C_NAME_SIZE); 
  46.      
  47.     adapter = i2c_get_adapter(AZURE_I2C_BUS_NO); 
  48.     if (!adapter) { 
  49.         printk(KERN_ERR "can't get i2c adapter %d/n", AZURE_I2C_BUS_NO); 
  50.         goto err_driver; 
  51.     } 
  52.      
  53.     client = i2c_new_device(adapter, &info); 
  54.     i2c_put_adapter(adapter); 
  55.      
  56.     if (!client) { 
  57.         printk(KERN_ERR "can't add i2c device at 0x%x/n", (unsigned int)info.addr); 
  58.         goto err_driver; 
  59.     } 
  60.      
  61.     ret = i2c_add_driver(&azure_i2c_driver); 
  62.     if (ret != 0) { 
  63.         printk(KERN_ERR "can't add i2c driver/n"); 
  64.         return ret; 
  65.     } 
  66.      
  67.     return 0; 
  68.      
  69. err_driver: 
  70.     i2c_del_driver(&azure_i2c_driver); 
  71.     return -ENODEV; 
  72. } 

然后在模块初始化的时候调用azure_add_i2c_device()即将一个i2c_driver注册到I2C Core，之后便可调用i2c_master_recv()和i2c_master_send()进行I2C总线读写操作。 i2c_master_send()/i2c_master_recv()第一个参数client由azure_i2c传入。

 

以上并不是聪明的做法。如果有N个模块要用到I2C，那么在N个模块就要添加基本一样的代码。更好的解决方法是为内核调用I2C写一个独立的模块，EXPORT_SYMBOL读写接口函数，在其他模块里就只需要调用这些读写接口函数就可以了。如下是模块代码：

  1. #include <linux/kernel.h> 
  2. #include <linux/module.h> 
  3. #include <linux/init.h> 
  4. #include <linux/errno.h> 
  5. #include <linux/init.h> 
  6. #include <linux/list.h> 
  7. #include <linux/i2c.h> 
  8. #include <linux/smp_lock.h> 
  9.  
  10. #define I2C_API_FAKE_ADDR 0x7f 
  11. #define I2C_MINORS        256 
  12.  
  13. int  i2c_api_attach(struct i2c_adapter *adapter); 
  14. int  i2c_api_detach(struct i2c_adapter *adapter); 
  15.  
  16. struct i2c_api { 
  17.     struct list_head list; 
  18.     struct i2c_client *client; 
  19. }; 
  20.  
  21. static LIST_HEAD(i2c_api_list); 
  22. static DEFINE_SPINLOCK(i2c_api_list_lock); 
  23.  
  24. static const unsigned short normal_addr[] = { I2C_API_FAKE_ADDR, I2C_CLIENT_END }; 
  25. static const unsigned short ignore[]      = { I2C_CLIENT_END }; 
  26. static struct i2c_client_address_data addr_data =  
  27. { 
  28.     .normal_i2c = normal_addr, 
  29.     .probe      = ignore, 
  30.     .ignore     = ignore, 
  31.     .forces     = NULL, 
  32. }; 
  33.  
  34. static const struct i2c_device_id id[] = { 
  35.     {"I2C-API", 0}, 
  36.     {}  
  37. };       
  38. MODULE_DEVICE_TABLE(i2c, id); 
  39.  
  40. static struct i2c_driver i2c_api_driver = { 
  41.     .id_table       = id, 
  42.     .attach_adapter = i2c_api_attach, 
  43.     .detach_adapter = i2c_api_detach, 
  44.     .command        = NULL, 
  45.     .driver         = { 
  46.         .name  = "I2C-API", 
  47.         .owner = THIS_MODULE, 
  48.     }, 
  49.     .address_data   = &addr_data, 
  50. }; 
  51.  
  52. static struct i2c_api *get_i2c_api(int bus_id) 
  53. { 
  54.     struct i2c_api *i2c_api; 
  55.  
  56.     spin_lock(&i2c_api_list_lock); 
  57.     list_for_each_entry(i2c_api, &i2c_api_list, list) { 
  58.         if (i2c_api->client->adapter->nr == bus_id) 
  59.             goto found; 
  60.     } 
  61.     i2c_api = NULL; 
  62.      
  63. found: 
  64.     spin_unlock(&i2c_api_list_lock); 
  65.     return i2c_api; 
  66. } 
  67.  
  68. static struct i2c_api *add_i2c_api(struct i2c_client *client) 
  69. { 
  70.     struct i2c_api *i2c_api; 
  71.  
  72.     if (client->adapter->nr >= I2C_MINORS) { 
  73.         printk(KERN_ERR "i2c_api: Out of device minors (%d)/n", 
  74.             client->adapter->nr); 
  75.         return NULL; 
  76.     } 
  77.  
  78.     i2c_api = kzalloc(sizeof(*i2c_api), GFP_KERNEL); 
  79.     if (!i2c_api) 
  80.         return NULL; 
  81.     i2c_api->client = client; 
  82.  
  83.     spin_lock(&i2c_api_list_lock); 
  84.     list_add_tail(&i2c_api->list, &i2c_api_list); 
  85.     spin_unlock(&i2c_api_list_lock); 
  86.     return i2c_api; 
  87. } 
  88.  
  89. static void del_i2c_api(struct i2c_api *i2c_api) 
  90. { 
  91.     spin_lock(&i2c_api_list_lock); 
  92.     list_del(&i2c_api->list); 
  93.     spin_unlock(&i2c_api_list_lock); 
  94.     kfree(i2c_api); 
  95. } 
  96.  
  97. static int i2c_api_do_xfer(int bus_id, char chip_addr, char sub_addr, int mode,  
  98.     char *buf, unsigned int size) 
  99. { 
  100. /** 
  101.  * you can define more transfer mode here, implement it below. 
  102.  */ 
  103. #define I2C_API_XFER_MODE_SEND            0x0 /* standard send */ 
  104. #define I2C_API_XFER_MODE_RECV            0x1 /* standard receive */ 
  105. #define I2C_API_XFER_MODE_SEND_NO_SUBADDR 0x2 /* send with no sub address */ 
  106. #define I2C_API_XFER_MODE_RECV_NO_SUBADDR 0x3 /* receive with no sub address */ 
  107.  
  108.     int ret = 0; 
  109.     char *tmp; 
  110.     struct i2c_api *i2c_api = get_i2c_api(bus_id); 
  111.  
  112.     if (!i2c_api) 
  113.         return -ENODEV; 
  114.      
  115.     i2c_api->client->addr = chip_addr; 
  116.     switch (mode) { 
  117.     case I2C_API_XFER_MODE_SEND: 
  118.         tmp = kmalloc(size + 1,GFP_KERNEL); 
  119.         if (tmp == NULL) 
  120.             return -ENOMEM; 
  121.         tmp[0] = sub_addr; 
  122.         memcpy(&tmp[1], buf, size); 
  123.         ret = i2c_master_send(i2c_api->client, tmp, size + 1); 
  124.         ret = (ret == size + 1) ? size : ret; 
  125.         break; 
  126.          
  127.     case I2C_API_XFER_MODE_RECV: 
  128.         ret = i2c_master_send(i2c_api->client, &sub_addr, 1); 
  129.         if (ret < 0) 
  130.             return ret; 
  131.         ret = i2c_master_recv(i2c_api->client, buf, size); 
  132.         break; 
  133.      
  134.     case I2C_API_XFER_MODE_SEND_NO_SUBADDR: 
  135.         ret = i2c_master_send(i2c_api->client, buf, size); 
  136.         break; 
  137.          
  138.     case I2C_API_XFER_MODE_RECV_NO_SUBADDR: 
  139.         ret = i2c_master_recv(i2c_api->client, buf, size); 
  140.         break; 
  141.              
  142.     default: 
  143.         return -EINVAL; 
  144.     } 
  145.     return ret; 
  146. } 
  147.  
  148. int i2c_api_do_send(int bus_id, char chip_addr, char sub_addr, char *buf, unsigned int size) 
  149. { 
  150.     return i2c_api_do_xfer(bus_id, chip_addr, sub_addr, I2C_API_XFER_MODE_SEND, buf, size); 
  151. } 
  152.  
  153. int i2c_api_do_recv(int bus_id, char chip_addr, char sub_addr, char *buf, unsigned int size) 
  154. { 
  155.     return i2c_api_do_xfer(bus_id, chip_addr, sub_addr, I2C_API_XFER_MODE_RECV, buf, size); 
  156. } 
  157.  
  158. int i2c_api_attach(struct i2c_adapter *adap) 
  159. { 
  160.     struct i2c_board_info info; 
  161.     struct i2c_client *client; 
  162.      
  163.     memset(&info, 0, sizeof(struct i2c_board_info)); 
  164.         strlcpy(info.type, "i2c_api", I2C_NAME_SIZE); 
  165.     info.addr = I2C_API_FAKE_ADDR; 
  166.     client = i2c_new_device(adap, &info); 
  167.     if (client) 
  168.         add_i2c_api(client); 
  169.     printk(KERN_INFO "i2c_api_attach adap[%d]/n", adap->nr); 
  170.     return 0; 
  171. } 
  172.  
  173. int i2c_api_detach(struct i2c_adapter *adap) 
  174. {    
  175.     struct i2c_api *i2c_api; 
  176.  
  177.     i2c_api = get_i2c_api(adap->nr); 
  178.     if (i2c_api) 
  179.         del_i2c_api(i2c_api); 
  180.     return 0; 
  181. } 
  182.  
  183. static int __init i2c_api_init(void) 
  184. {    
  185.     int ret = i2c_add_driver(&i2c_api_driver); 
  186.      
  187.     if (ret) { 
  188.         printk(KERN_ERR "[%s] Driver registration failed, module not inserted./n"
  189. , __func__); 
  190.         return ret; 
  191.     } 
  192.  
  193.     return 0 ;   
  194. } 
  195.  
  196. static void __exit i2c_api_exit(void) 
  197. {    
  198.     i2c_del_driver(&i2c_api_driver); 
  199. } 
  200.  
  201. MODULE_AUTHOR("Loon, <sepnic@gmail.com>"); 
  202. MODULE_DESCRIPTION("I2C i2c_api Driver"); 
  203. MODULE_LICENSE("GPL"); 
  204.  
  205. module_init(i2c_api_init); 
  206. module_exit(i2c_api_exit); 
  207.  
  208. EXPORT_SYMBOL_GPL(i2c_api_do_send); 
  209. EXPORT_SYMBOL_GPL(i2c_api_do_recv); 

内核版本是2.6.32，i2c_driver结构体成员attach_adapter和detach_adapter可能以后有增删，届时需要对模块里的i2c_api_attach()和i2c_api_detach()做调整。

加载该模块后，其他模块即可调用i2c_api_do_recv()/i2c_api_do_send()读写I2C总线。

(sepnic)
本站文章除注明转载外，均为本站原创或编译欢迎任何形式的转载，但请务必注明出处，尊重他人劳动，同学习共成长。转载请注明：文章转载自：罗索实验室 [http://www.rosoo.net/a/201109/15073.html]
本文出处：blog.csdn.net/sepnic　作者：sepnic
顶一下
(0)
0%
踩一下
(0)
0%
------分隔线----------------------------
相关文章
发表评论
请自觉遵守互联网相关的政策法规，严禁发布色情、暴力、反动的言论。
评价:
表情:
用户名: 验证码:点击我更换图片
最新评论 进入详细评论页>>
栏目列表
将本文分享到微信
织梦二维码生成器
推荐内容
热点内容