程序博客网 > windows xp虚拟机镜像

通用i2c驱动

来源：互联网 发布：windows xp虚拟机镜像 编辑：程序博客网 时间：2024/06/06 04:25

了解I2C的同志都知道，常规I2C驱动中的最重点就是这4个结构体：i2c_driver、i2c_client、i2c_adapter 和i2c_algorithm，而且他们之间的关系错综复杂，我看了好长一段时间，也没看出多少头绪来，而且代码的可移植性很差劲，换个平台，要该的地方一大堆，改了之后还不一定对呢委屈，所以，下面介绍的通用I2C驱动就很必要了。

    大家都知道， I2C总线仅仅使用SCL、SDA这两根信号线就实现了设备之间的数据交互，极大地简化了对硬件资源和PCB板布线空间的占用。因此，I2C总线应用非常的广泛。而工作中，我需要通过I2C实现Hi35XX控制视频芯片CX25828，我是这样做的，首先，把I2C当做一个字符设备，然后用2个GPIO管脚模拟数据线和时钟线，一个管脚控制方向，实现电平的高低控制，这样就可以模拟I2C通信了（CPU与设备间的通信）。

 

 

1.当做一个字符设备

     看到这个，相信大家一定很熟悉了，对了，这就是我们入门时再熟悉不过的东东了，上层可直接对dev下的“gpioi2c”的这个节点open、write、read、close（不过，就目前这个，无read、write接口，只有ioctl了），接下来，你懂的。（在网上有很多比较成熟的I2C驱动，也是同我这个原理实现的，改改GPIO口地址就可以了大笑）。

[cpp] view plaincopyprint?
  1. <span style="font-size:14px;">//打开和关闭设备  
  2. int gpioi2c_open(struct inode * inode, struct file * file)  
  3. {  
  4.     return 0;  
  5. }  
  6. int gpioi2c_close(struct inode * inode, struct file * file)  
  7. {  
  8.     return 0;  
  9. }  
  10.   
  11. //最重要的结构体，文件描述符指针，上层直接ioctl就可通过底层调用gpioi2c_ioctl函数。  
  12. //当然，可以有其他的成员，如read、write等。  
  13. static struct file_operations gpioi2c_fops =  
  14. {  
  15.     .owner      = THIS_MODULE,  
  16.     .ioctl      = gpioi2c_ioctl,  
  17.     .open       = gpioi2c_open,  
  18.     .release    = gpioi2c_close  
  19. };  
  20.   
  21. static struct miscdevice gpioi2c_dev =  
  22. {  
  23.     .minor       = MISC_DYNAMIC_MINOR,  
  24.     .name        = "gpioi2c",//在dev下可以找到这个节点，上层就是通过open、read/write这个节点而对设备操作的。  
  25.      .fops  = &gpioi2c_fops,  
  26. };  
  27.   
  28. //导入导出  
  29. static int __init gpio_i2c_init(void)  
  30. {  
  31.     int ret;  
  32.     printk("hello dvr iic\n");  
  33.     //注册设备  
  34.      ret = misc_register(&gpioi2c_dev);  
  35.     if(0 != ret)  
  36.         return -1;  
  37.   
  38.     i2c_set(SCL | SDA);  
  39.   
  40.     return 0;  
  41. }  
  42. static void __exit gpio_i2c_exit(void)  
  43. {  
  44.     //卸载设备  
  45.      misc_deregister(&gpioi2c_dev);  
  46. }  
  47.   
  48. //导入导出内核设备  
  49. module_init(gpio_i2c_init);  
  50. module_exit(gpio_i2c_exit);  
  51.   
  52. MODULE_INFO(build, UTS_VERSION);  
  53. MODULE_LICENSE("GPL");</span>  


 

2.对字符设备的控制：ioctl函数

     提供给上层的接口，arg参数其实是一个地址，这个地址里面必须存放三个信息：设备地址+寄存器地址+data。通过设备地址找到设备，然后通过寄存器地址配置相应的寄存器。关于每次通信的信息量，这要看上层接口函数ioctl：int ioctl(int file_operations, int cmd, void *addr)时arg地址内存放的内容了，如果内容是int类型即4个字节，就如下。如果这个地址内存放的是结构体，而且sizeof这个结构体的大小为12byte（即设备地址、寄存器地址、以及数据各占4个字节），就不需要移动了，直接填进去。

[cpp] view plaincopyprint?
  1. <span style="font-size:14px;">int gpioi2c_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)  
  2. {  
  3.     unsigned int val;  
  4.     char device_addr, reg_addr;  
  5.     short reg_val;  
  6.   
  7.     switch(cmd)  
  8.     {  
  9.         case GPIO_I2C_READ:  
  10.             val = *(unsigned int *)arg;  
  11.             device_addr = (val&0xff000000)>>24;  
  12.             reg_addr = (val&0xffff00)>>8;  
  13.   
  14.             reg_val = gpio_i2c_read(device_addr, reg_addr);  
  15.             *(unsigned int *)arg = (val&0xffffff00)|reg_val;  
  16.             break;  
  17.   
  18.         case GPIO_I2C_WRITE:  
  19.             val = *(unsigned int *)arg;  
  20.             device_addr = (val&0xff000000)>>24;  
  21.             reg_addr = (val&0xffff00)>>8;  
  22.   
  23.             reg_val = val&0xff;  
  24.             gpio_i2c_write(device_addr, reg_addr, reg_val);  
  25.             break;  
  26.   
  27.         default:  
  28.             return -1;  
  29.     }  
  30.     return 0;  
  31. }  
  32. </span>  

 

 

3.对设备的读写：read、write

     CX25828中，寄存器的地址为16位，设备地址为8位，所有，I2C每次只能read、write1个字节的数据。。总线空闲时，上拉电阻使SDA和SCL线都保持高电平。当 SCL 稳定在高电平时，SDA 由高到低的变化将产生一个开始位，而由低到高的变化则产生一个停止位。开始位和停止位都由 I2C 主设备产生。在选择从设备时，如果从设备采用 7 位地址，则主设备在发起传输过程前，需先发送1字节的地址信息，前 7 位为设备地址，最后 1 位为读写标志。之后，每次传输的数据也是 1 个字节，从 MSB 位开始传输。每个字节传完后，在SCL的第9个上升沿到来之前，接收方应该发出 1 个 ACK 位。SCL上的时钟脉冲由I2C主控方发出， 在第8个时钟周期之后。

                 

[cpp] view plaincopyprint?
  1. <span style="font-size:14px;">//读1个字节（其实可以2,或者4个字节，这个地方是实现读写功能以及决定字节数的，IIC支持）  
  2. unsigned short  gpio_i2c_read(unsigned char devaddress, unsigned int address)  
  3. {  
  4.     unsigned short rxdata=0  
  5.     unsigned int tmp=0;  
  6.     int dev_addr=devaddress;  
  7.   
  8.    //发送设备地址：8位  
  9.     i2c_start_bit();  
  10.     i2c_send_byte((unsigned char)(dev_addr));  
  11.     i2c_receive_ack();  
  12.   
  13.     //寄存器地址：16位  
  14.      tmp=address&0xff00;  
  15.     tmp=tmp>>8;  
  16.     i2c_send_byte((unsigned char)tmp);  
  17.     i2c_receive_ack();  
  18.     tmp=address&0xff;  
  19.     i2c_send_byte((unsigned char)tmp);  
  20.     i2c_receive_ack();  
  21.   
  22.      //发送:读状态  
  23.      i2c_start_bit();  
  24.     i2c_send_byte((unsigned char)(dev_addr) | 1);  
  25.     i2c_receive_ack();  
  26.   
  27.     //接收数据：8bit  
  28.     rxdata = i2c_receive_byte();  
  29.   
  30.     //停止接收数据  
  31.     i2c_stop_bit();  
  32.     rxdata=rxdata&0xff;  
  33.   
  34.     return rxdata;  
  35. }  
  36.   
  37. //写一个字节  
  38. void gpio_i2c_write(unsigned char devaddress, unsigned int address, unsigned int data)  
  39. {  
  40.     int tmp;  
  41.     unsigned short devaddr=devaddress&0xfe;//在手册中可以看到，读写状态占1bit，读为1，写为0.  
  42.   
  43.     //设备地址:8bit  
  44.     i2c_start_bit();  
  45.     i2c_send_byte((unsigned char)(devaddr));  
  46.     i2c_receive_ack();//ACK  
  47.   
  48.     //寄存器地址：16bit  
  49.     tmp=address&0xff00;  
  50.     tmp=tmp>>8;  
  51.     i2c_send_byte((unsigned char)tmp);  
  52.     i2c_receive_ack();  
  53.     tmp=address&0xff;   
  54.     i2c_send_byte((unsigned char)tmp);  
  55.     i2c_receive_ack();  
  56.   
  57.     //发送数据：8bit  
  58.     tmp=data&0xff;  
  59.     i2c_send_byte((unsigned char)tmp);  
  60.     i2c_receive_ack();  
  61.   
  62.     //停止接收数据   
  63.     i2c_stop_bit();  
  64. }</span>  

 

4.模拟数据线时钟线以及需要调用的一些函数

[html] view plaincopyprint?
  1. <span style="font-size:14px;">#include "gpio_i2c.h"  
  2. #define GPIO_0_BASE 0x20150000  
  3. #define GPIO_0_DIR IO_ADDRESS(GPIO_0_BASE + 0x400)  //GPIO方向控制  
  4.   
  5. #define SCL                 (1 << 1)    /* GPIO 0_1 */  
  6. #define SDA                 (1 << 0)    /* GPIO 0_0 */  
  7. #define GPIO_I2C_SDA_REG    IO_ADDRESS(GPIO_0_BASE + 0x4)//数据线GPIO管脚  
  8. #define GPIO_I2C_SCL_REG    IO_ADDRESS(GPIO_0_BASE + 0x8)//时钟线GPIO管脚  
  9. #define GPIO_I2C_SCLSDA_REG IO_ADDRESS(GPIO_0_BASE + 0xc)  
  10. #define HW_REG(reg)         *((volatile unsigned int *)(reg))  
  11. #define DELAY(us)           time_delay_us(us)  
  12.   
  13. //拉低数据线/时钟线  
  14. static void i2c_clr(unsigned char whichline)  
  15. {  
  16.     unsigned char regvalue;  
  17.       
  18.     //拉低时钟线  
  19.      if(whichline == SCL)  
  20.     {  
  21.       //方向：输入/输出  
  22.           regvalue = HW_REG(GPIO_0_DIR);  
  23.         regvalue |= SCL;  
  24.         HW_REG(GPIO_0_DIR) = regvalue;  
  25.           
  26.     //置零  
  27.         HW_REG(GPIO_I2C_SCL_REG) = 0;  
  28.       return;  
  29.     }  
  30.     else if(whichline == SDA)  
  31.     {  
  32.         regvalue = HW_REG(GPIO_0_DIR);  
  33.         regvalue |= SDA;  
  34.         HW_REG(GPIO_0_DIR) = regvalue;  
  35.   
  36.         HW_REG(GPIO_I2C_SDA_REG) = 0;  
  37.         return;  
  38.     }  
  39.     else if(whichline == (SDA|SCL))  
  40.     {  
  41.         regvalue = HW_REG(GPIO_0_DIR);  
  42.         regvalue |= (SDA|SCL);  
  43.         HW_REG(GPIO_0_DIR) = regvalue;  
  44.   
  45.         HW_REG(GPIO_I2C_SCLSDA_REG) = 0;  
  46.         return;  
  47.     }  
  48.     else  
  49.     {  
  50.         printk("Error input.\n");  
  51.         return;  
  52.     }  
  53.   
  54. }  
  55.   
  56. //拉高数据线/时钟线  
  57. static void  i2c_set(unsigned char whichline)  
  58. {  
  59.     unsigned char regvalue;  
  60.     //拉高时钟线  
  61.      if(whichline == SCL)  
  62.     {  
  63.         regvalue = HW_REG(GPIO_0_DIR);  
  64.         regvalue |= SCL;  
  65.         HW_REG(GPIO_0_DIR) = regvalue;  
  66.           
  67.         HW_REG(GPIO_I2C_SCL_REG) = SCL;  
  68.         return;  
  69.     }  
  70.     else if(whichline == SDA)  
  71.     {  
  72.         regvalue = HW_REG(GPIO_0_DIR);  
  73.         regvalue |= SDA;  
  74.         HW_REG(GPIO_0_DIR) = regvalue;  
  75.   
  76.         HW_REG(GPIO_I2C_SDA_REG) = SDA;  
  77.         return;  
  78.     }  
  79.     else if(whichline == (SDA|SCL))  
  80.     {  
  81.         regvalue = HW_REG(GPIO_0_DIR);  
  82.         regvalue |= (SDA|SCL);  
  83.         HW_REG(GPIO_0_DIR) = regvalue;  
  84.   
  85.         HW_REG(GPIO_I2C_SCLSDA_REG) = (SDA|SCL);  
  86.         return;  
  87.     }  
  88.     else  
  89.     {  
  90.         printk("Error input.\n");  
  91.         return;  
  92.     }  
  93. }  
  94.   
  95. //延时usec微秒  
  96. void time_delay_us(unsigned int usec)  
  97. {  
  98.     int i,j;  
  99.   
  100.     for(i=0; i<usec * 5; i++)  
  101.     {  
  102.         for(j=0; j<64; j++)  
  103.         {  
  104.             ;  
  105.         }  
  106.     }  
  107. }  
  108.   
  109. //开始IIC通信  
  110. static void i2c_start_bit(void)  
  111. {  
  112.     DELAY(1);  
  113.     //拉高双线,拉低数据线，开始发送数据。  
  114.      i2c_set(SDA | SCL);  
  115.     DELAY(1);  
  116.     i2c_clr(SDA);  
  117.     DELAY(2);  
  118. }  
  119.   
  120. //停止IIC通信  
  121. static void i2c_stop_bit(void)  
  122. {  
  123.     //时钟响应  
  124.     DELAY(1);  
  125.     i2c_set(SCL);  
  126.     DELAY(1);  
  127.     i2c_clr(SCL);  
  128.   
  129.     //数据线为高，数据线由低->高：结束通信  
  130.     DELAY(1);  
  131.     i2c_clr(SDA);  
  132.     DELAY(1);  
  133.     i2c_set(SCL);  
  134.     DELAY(1);  
  135.     i2c_set(SDA);  
  136.     DELAY(1);  
  137. }  
  138.   
  139. //读取数据：1bit  
  140. static unsigned char i2c_data_read(void)  
  141. {  
  142.     unsigned char regvalue;  
  143.   
  144.     regvalue = HW_REG(GPIO_0_DIR);  
  145.     regvalue &= (~SDA);  
  146.     HW_REG(GPIO_0_DIR) = regvalue;  
  147.     DELAY(1);  
  148.   
  149.     regvalue = HW_REG(GPIO_I2C_SDA_REG);  
  150.     if((regvalue&SDA) != 0)  
  151.         return 1;  
  152.     else  
  153.         return 0;  
  154. }  
  155.   
  156. //发送数据：1byte  
  157. static void i2c_send_byte(unsigned char c)  
  158. {  
  159.     int i;  
  160.     //屏蔽中断  
  161.     local_irq_disable();  
  162.     for(i=0; i<8; i++)  
  163.     {  
  164.         DELAY(1);  
  165.         i2c_clr(SCL);  
  166.         DELAY(1);  
  167.           
  168.       //发送1（这个是重点哦<img alt="大笑" src="http://static.blog.csdn.net/xheditor/xheditor_emot/default/laugh.gif">）  
  169.         if(c & (1<<(7-i)))  
  170.             i2c_set(SDA);  
  171.         else//发送0  
  172.             i2c_clr(SDA);  
  173.   
  174.         DELAY(1);  
  175.         i2c_set(SCL);  
  176.         DELAY(1);  
  177.         i2c_clr(SCL);  
  178.     }  
  179.     DELAY(1);  
  180.     local_irq_enable();  
  181. }  
  182.   
  183. //接收数据：1byte  
  184. static unsigned char i2c_receive_byte(void)  
  185. {  
  186.     int j=0;  
  187.     int i;  
  188.     unsigned char regvalue;  
  189.   
  190.     local_irq_disable();  
  191.     for(i=0; i<8; i++)  
  192.     {  
  193.         DELAY(1);  
  194.         i2c_clr(SCL);  
  195.         DELAY(2);  
  196.         i2c_set(SCL);  
  197.   
  198.         regvalue = HW_REG(GPIO_0_DIR);  
  199.         regvalue &= (~SDA);  
  200.         HW_REG(GPIO_0_DIR) = regvalue;  
  201.         DELAY(1);  
  202.   
  203.         if(i2c_data_read())  
  204.             j+=(1<<(7-i));  
  205.   
  206.         DELAY(1);  
  207.         i2c_clr(SCL);  
  208.     }  
  209.     local_irq_enable();  
  210.     DELAY(1);  
  211.   
  212.   
  213.     return j;  
  214. }  
  215.   
  216. //响应（每发送一个字节，都要响应），返回值为0：成功。  
  217. static int i2c_receive_ack(void)  
  218. {  
  219.     int nack;  
  220.     unsigned char regvalue;  
  221.   
  222.     DELAY(1);  
  223.     regvalue = HW_REG(GPIO_0_DIR);  
  224.     regvalue &= (~SDA);//数据线置零  
  225.     HW_REG(GPIO_0_DIR) = regvalue;  
  226.     DELAY(1);  
  227.     i2c_clr(SCL);  
  228.     DELAY(1);  
  229.     i2c_set(SCL);  
  230.     DELAY(1);  
  231.     nack = i2c_data_read();  
  232.     DELAY(1);  
  233.     i2c_clr(SCL);  
  234.     DELAY(1);  
  235.     if(nack == 0)  
  236.         return 1;  
  237.   
  238.     return 0;  
  239. }</span>  

 

5.上层调用

[cpp] view plaincopyprint?
  1. /***** IIC写数据 ********************************************************************************************/  
[cpp] view plaincopyprint?
  1. //参数分别为设备地址、寄存器地址、值。  
[cpp] view plaincopyprint?
  1. //如果writeval为结构体（最好12字节），而非unsiged long类型，就不需要移动了（底层驱动支持情况下）  
  2. void IIC_Write(int devAddr, int regAddr, int val)  
  3. {  
  4.     unsigned long writeval, ret;      
  5.     writeval = (((devAddr & 0xff) << 24) | ((regAddr & 0xffff) << 8) | (val & 0xff));  
  6.     ret = ioctl(i2cfd, I2C_WRITE, &writeval);  
  7.     if(0 > ret)  
  8.     {  
  9.         _ERROR("write iic ERROR");  
  10.     }         
  11. }  
  12.   
  13. /***** IIC读数据 ********************************************************************************************/  
  14. unsigned int IIC_Read(int devAddr, int regAddr)  
  15. {  
  16.     unsigned long readval, ret;  
  17.       
  18.     readval = (((devAddr & 0xff) << 24) | ((regAddr & 0xffff) << 8));  
  19.     ret = ioctl(i2cfd, I2C_READ, &readval);  
  20.     if(0 > ret)  
  21.     {  
  22.         _ERROR("read iic ERROR");  
  23.     }     
  24.       
  25.     readval &= 0xff;  
  26.     return readval;  
  27. }  
windows xp虚拟机镜像 windows xp虚拟机镜像
原创粉丝点击
热门IT博客
网络设计师培训网络设计师培训
杭州微点网络联系方式杭州微点网络联系方式
淘宝直通车移动折扣
淘宝直通车要求等级
实时滤镜软件
电商大米销售数据
玉兔飞控调参软件
阿里云代理
mac jenkins git
淘宝上买开刃的刀
ppt解密软件
淘宝刷六单多少钱
上海程序员缺口
lrtimelapse windows
网络安全工程师英文
淘宝网男装休闲外套
租车网络平台如何盈利
软件外包开发管理制度
淘宝怎么分享到微信
淘宝源代码
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 海带作用 吃海带 海带怎么煮 炖海带 海带炒肉 海带炒 海带图片 海带绿豆汤 排骨海带汤 海带怎么洗 海带怎么炒 海带炖豆腐 干海带 韩国海带汤 海带减肥吗 海带骨头汤 海带蛋花汤 海带减肥 海带的价格 盐渍海带 海带海带 煮海带 凉拌海带丝做法 凉拌海带做法 海带不能和什么一起吃 海带丝怎么拌好吃 海带丝的做法 孕妇可以吃海带 孕妇可以吃海带吗 孕妇能吃海带 清热祛湿海带汤 孕妇能吃海带吗 海带怎么炒好吃又简单 正宗韩式海带汤 干海带怎么泡发 海带丝怎么做好吃 痛风能吃海带吗 痛风能吃海带 海带排骨汤做法 海带建议多久吃一次 尿酸高能吃海带

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里