驱动专题：第四章 IIC驱动 4. IIC协议/裸驱/adapter驱动程序分析

最新推荐文章于 2022-08-08 14:23:36 发布
最新推荐文章于 2022-08-08 14:23:36 发布
阅读量586 收藏 1
点赞数
分类专栏： linux驱动 文章标签： IIC

开发板：mini2440

内核  ：linux2.6.32.2

参考  ：韦东山毕业班I2C视频教程


1、i2c协议简要分析

    i2c中线是一种由 PHILIPS 公司开发的串行总线，用于连接微控制器及其外围设备，它具有以下特点。
        1、只有两条总线线路：一条串行数据线SDA,一条串行时钟线SCL。
        2、每个连接到总线的器件都可以使用软件根据它的唯一的地址来确定。
        3、传输数据的设备之间是简单的主从关系。
        4、主机可以用作主机发送器或者主机接收器。
        5、它是一个真正的多主机总线，两个或多个主机同时发起数据传输时，可以通过冲突检测和仲裁来防止数据被破坏。
        6、串行的8位双向传输，位速在标准模式下可达 100kbit/s,在快速模式下可达400kbit/s，在高速模式下可待3.4Mbit/s。
        7、片上的滤波器可以增加抗干扰能力，保证数据的完整性。

        8、连接到同一总线上的IC数量只受到总线的最大电容400Pf的限制。


    如上图所示，启动一个传输时，主机先发送一个S信号，然后发送8位数据。这8位数据的前7位为从机地址，第八位表示传输的方向（0表示写，1表示读），如果有数据则继续发送，最后发出P信号停止。


信号类型：

    注意：正常数据传输时，SDA 在 SCL 为低电平时改变，在 SCL 为高电平时保持稳定。
    开始信号 S 信号：
        SCL 为高电平时，SDA由高电平向低电平跳变，开始传送数据。
    结束信号 P 信号：
        SCL 为高电平时，SDA由低电平向高电平跳变，结束传送数据。
    响应信号 ACK：
        接收器在接收到8位数据后，在第9个时钟周期，拉低 SDA 电平
    注意：在第9个时钟周期，发送器保持SDA为高，如果有ACK，那么第9个时钟周期SDA为低电平，如果没有为高电平，发送器根据电平高低分辨是否有ACK信号。
          如果使能了IIC中断，发送完8bit数据后，主机自动进入中断处理函数，此时SCL被发送器拉低，让接收器被迫等待。恢复传输只需要清除中断挂起。

2、 s3c2440 读写流程


    1、设置传输模式 IICSTAT[7-6]，我们做实验与AT24C08通信时，2440作为主机，因此只用到主机发模式和主机收模式。
    2、写入从机地址到 IICDS[7-1]，此时IICDS[7-1]位表示从机地址，第0位不关心。如 AT24C08 为 0xA0(最低位写0了，发送到数据线上的7位地址的后边以为才表示收发，这里虽然写0但并不是根据这里的0来真正发送的)。
    3、写 0xF0(写) 或 0xB0(读)到 IICSTAT 寄存器, 高两位表示 传输模式前边设置过了，设置IICSTT[5-4] 为 11,使能传输，发送S信号。
    4、IIC控制器自动将第2步中设置的 IICDS[7-1] 再根据 传输模式 补充 IICDS[0]位，发送出去。
    5、进入第9个时钟周期，此时，从机决定是否发出ACK信号，主机进入中断，判断是否收到ACK信号，以及是否继续传输。
    继续发送：
        1、将数据写入 IICDS 
        2、清除中断挂起，SCL时钟恢复，IICDS的数据被自动发送到 SDA 线上，回到第5步。
    停止发送：
        1、写 0xD0(写) 和 0x90(读) 到 IICATAT ，IICATAT[7-6]还是表示的传输模式，IICATAT[5-4] == 0 1，发送停止信号
        2、清除中断挂起，SCL时钟恢复，发出停止信号
        3、延时，等待停止信号发出



3、 AT24C08 读写分析

    1、写过程


    写过程与2440芯片的里的写流程相一致，按照流程写就OK

    2、读过程


    读过程是由2440芯片里的一个写流程加一个读流程组合而成，其中写流程结束没有发出P信号，而是直接发出了S信号开始读流程，也就是我为什么加了一道红线的原因。

附上一份简单的裸机程序，仅供参考：基于MINI2440

  1. #include <stdio.h>
  2. #include "s3c2440.h"
  4. void Delay(int time);
  6. #define WRDATA (1)
  7. #define RDDATA (2)
  9. typedef struct tI2C {
  10. unsigned char *pData; /* 数据缓冲区 */
  11. volatile int DataCount; /* 等待传输的数据长度 */
  12. volatile int Status; /* 状态 */
  13. volatile int Mode; /* 模式：读/写 */
  14. volatile int Pt; /* pData中待传输数据的位置 */
  15. }tS3C24xx_I2C, *ptS3C24xx_I2C;
  17. static tS3C24xx_I2C g_tS3C24xx_I2C;
  19. /*
  20. * I2C初始化
  21. */
  22. void i2c_init(void)
  23. {
  24. GPEUP |= 0xc000; // 禁止内部上拉
  25. /*
  26. * AT24C08 两根线 I2CSCL I2CSDA 与 2440芯片相连
  27. * 配置2440 GPECON GPE15 GPE14引脚为I2C功能
  28. */
  29. GPECON |= 0xa0000000; // 选择引脚功能：GPE15:IICSDA, GPE14:IICSCL
  30. /* 开INT_IIC中断 */
  31. //INTMSK &= ~(BIT_IIC);
  33. /* bit[7] = 1, 使能ACK
  34. * bit[6] = 0, IICCLK = PCLK/16
  35. * bit[5] = 1, 使能中断
  36. * bit[3:0] = 0xf, Tx clock = IICCLK/16
  37. * PCLK = 50MHz, IICCLK = 3.125MHz, Tx Clock = 0.195MHz
  38. */
  39. IICCON = ( 1<< 7) | ( 0<< 6) | ( 1<< 5) | ( 0xf); // 0xaf
  41. //IICADD = 0x10; // S3C24xx slave address = [7:1]
  42. IICSTAT = 0x10; // I2C串行输出使能(Rx/Tx)
  43. }
  45. void I_Write(unsigned int slvaddr, unsigned char addr, unsigned char data)
  46. {
  47. unsigned int ack;
  48. // 写从地址
  49. IICSTAT |= 0x1<< 6; //主机写模式
  50. IICSTAT |= 0x1<< 7;
  51. IICDS = slvaddr; //0xa0; //write slave address to IICDS
  52. IICCON&=~ 0x10; //clear pending bit
  53. IICSTAT = 0xf0; //(M/T start)
  54. while((IICCON & 1<< 4) == 0); //udelay(10);//ack period and then interrupt is pending
  55. // 写寄存器地址
  56. IICDS = addr;
  57. IICCON&=~ 0x10; //clear pending bit
  58. while((IICCON & 1<< 4) == 0); //udelay(10);//ack period and then interrupt is pending
  59. // 写数据
  60. IICDS = data;
  61. IICCON&=~ 0x10; //clear pending bit
  62. while((IICCON & 1<< 4) == 0); //udelay(10);//ack period and then interrupt is pending
  63. // 发出停止信号
  64. IICSTAT = 0xD0; //write (M/T stop to IICSTAT)
  65. IICCON&=~ 0x10; //clear pending bit
  67. while((IICSTAT & 1<< 5) == 1);
  68. }
  69. unsigned char I_Read(unsigned int slvaddr, unsigned char addr)
  70. {
  71. unsigned char data = 1;
  72. int ack;
  73. // 写从地址
  74. IICSTAT |= 0x1<< 6; //主机写模式
  75. IICSTAT |= 0x1<< 7;
  76. slvaddr = 0xA0;
  77. IICDS = slvaddr; //0xa0; //write slave address to IICDS
  78. IICCON&=~ 0x10; //clear pending bit
  79. IICSTAT = 0xf0; //(M/T start)
  80. while((IICCON & 1<< 4) == 0); //udelay(10);//ack period and then interrupt is pending
  82. // 写寄存器地址
  83. IICDS = addr;
  84. IICCON&=~ 0x10; //clear pending bit
  85. while((IICCON & 1<< 4) == 0); //udelay(10);//ack period and then interrupt is pending
  87. // 写从地址(读模式)
  88. slvaddr = 0xA1;
  89. IICSTAT &= ~( 0x1<< 6); //主机接受模式
  90. IICSTAT |= 0x1<< 7;
  91. IICDS = slvaddr;
  92. IICCON&=~ 0x10; //clear pending bit
  93. IICSTAT = 0xb0; //(M/R Start)
  94. while((IICCON & 1<< 4) == 0); //udelay(10);//uart_SendByte('o');//ack period and then interrupt is pending::
  96. // 读数据
  97. data = IICDS;
  98. //IICCON&=~0x10; //clear pending bit
  99. IICCON = 0x2f; //清挂起状态，并设置无应答
  100. while((IICCON & 1<< 4) == 0); //udelay(10);//ack period and then interrupt is pending
  101. data = IICDS;
  103. //IICCON&=~0x10; //clear pending bit
  104. IICCON = 0x2f; //清挂起状态，并设置无应答
  105. while((IICCON & 1<< 4) == 0); //udelay(10);//ack period and then interrupt is pending
  108. IICSTAT = 0x90;
  109. IICCON = 0xaf;
  110. //IICCON &= ~0x10; //clear pending bit
  112. while((IICSTAT & 1<< 5) == 1);
  114. return data;
  116. }


4、adapter驱动程序
    这里，我们主要分析驱动里的发送核心算法，至于注册中断，IO内存映射，设置寄存器不在讨论。
    static int xxx_i2c_xfer(struct i2c_adapter *adpap, struct i2c_msg *msg,int num)
    这个算法函数的作用就是将上层封装好的一些i2c_msg 进行解析，将数据写入寄存器，发送出去。在设备驱动层，我们使用了类似i2c_smbus_write_byte 等函数，类似的函数有很多，它们的作用就是封装i2c_msg 结构(比如读和写的 msg 肯定不一样，读一个字节和读多个字节也不一样)，然后调用 i2c_smbus_xfer_emulated->i2c_transfer，最终调用到我们的xxx_i2c_xfer函数进行传输。通过分析i2c_smbus_xfer_emulated函数，我们可以了解i2c_msg是如何封装的。下面，我们简单分析一下，知道最上层想干什么，我们才能知道实现哪些底层的功能不是。
  1. struct i2c_msg {
  2. __u16 addr; //从机地址
  3. __u16 flags;
  4. __u16 len; // buf 里 有多少个字节
  5. __u8 *buf; // 本 msg 含有的数据，可能是1个字节，可有可能是多个字节
  6. };

    此函数，省略了很多内容，举例分析而已~，细节请看源码

  1. static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
  2. unsigned short flags,
  3. char read_write, u8 command, int size,
  4. union i2c_smbus_data * data)
  5. {
  6. unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+ 3];
  7. unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+ 2];
  8. int num = read_write == I2C_SMBUS_READ? 2: 1; // 写操作两个Msg 读操作一个msg 这和我们前面分析AT24c08是一致的
  9. struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
  10. { addr, flags | I2C_M_RD, 0, msgbuf1 }
  11. };
  12. msgbuf0[ 0] = command; // 从机地址右移1位得到的，比如AT24C08 为 0x50
  13. switch(size) {
  14. case I2C_SMBUS_BYTE_DATA: // 单字节读写
  15. if (read_write == I2C_SMBUS_READ)
  16. msg[ 1].len = 1;
  17. /*
  18. * 读：
  19. * msgbuf0[0] = command
  20. * msg[1].len = 1 ,数据会读到 msgbuf0[1] 里
  21. */
  22. else {
  23. msg[ 0].len = 2;
  24. msgbuf0[ 1] = data->byte;
  25. /*
  26. * 写：
  27. * msgbuf0[0] = command
  28. * msgbuf0[1] = data->byte
  29. */
  30. }
  31. break;
  32. }
  33. status = i2c_transfer(adapter, msg, num);
  34. }
    上面代码跟我们分析AT24C08的时候如出一辙，对于一个写操作，我们只需要一个2440的写流程对应于这里的一个Msg，然而对于读操作，我们需要2440的两个流程，对应于这里的两个Msg。那么，我们底层控制器驱动需要做的工作就是，取出所有的Msg，将每一个Msg里buf里的数据发送出去，如果有下一个Msg, 那么再将下一个Msg里的buf发送完毕，最后发出P停止信号。还有一点，每发送一个Msg都要先发出S开始信号。

    在看adapter程序之前，我们先来简单思考一下，发出S开始信号之后，可能有以下3中情况：
        1、当前msg.len == 0 ，如果有ACK直接发出stop信号。这种情况出现在，控制器枚举设备的时候，因为它只发送S信号以及设备地址，不发送数据。
        2、根据msg->flags 为 I2C_M_RD 等信息判断读写，msg->flags 最低位为1表示读，最低位为0表示写。
            #define I2C_M_TEN0x0010          /* this is a ten bit chip address */
            #define I2C_M_RD0x0001           /* read data, from slave to master */
            #define I2C_M_NOSTART0x4000      /* if I2C_FUNC_PROTOCOL_MANGLING */
            #define I2C_M_REV_DIR_ADDR0x2000 /* if I2C_FUNC_PROTOCOL_MANGLING */
            #define I2C_M_IGNORE_NAK0x1000   /* if I2C_FUNC_PROTOCOL_MANGLING */
            #define I2C_M_NO_RD_ACK0x0800    /* if I2C_FUNC_PROTOCOL_MANGLING */
            #define I2C_M_RECV_LEN0x0400     /* length will be first received byte */
        2.1 如果是读
            恢复 IIC 传输，开始读就行了，在下一个中断里将寄存器数据取出，如果是最后一个要读取的数据，不能发送ACK（禁用ACK）。
        2.2 如果是写
         将数据写入 IICDS 寄存器，恢复 IIC 传输。


附上韦东山老师的程序：

    看程序之前，看一个大致的流程图，对于理解程序有帮助


  1. #include <linux/kernel.h>
  2. #include <linux/module.h>
  4. #include <linux/i2c.h>
  5. #include <linux/init.h>
  6. #include <linux/time.h>
  7. #include <linux/interrupt.h>
  8. #include <linux/delay.h>
  9. #include <linux/errno.h>
  10. #include <linux/err.h>
  11. #include <linux/platform_device.h>
  12. #include <linux/pm_runtime.h>
  13. #include <linux/clk.h>
  14. #include <linux/cpufreq.h>
  15. #include <linux/slab.h>
  16. #include <linux/io.h>
  17. #include <linux/of_i2c.h>
  18. #include <linux/of_gpio.h>
  19. #include <plat/gpio-cfg.h>
  20. #include <mach/regs-gpio.h>
  22. #include <asm/irq.h>
  24. #include <plat/regs-iic.h>
  25. #include <plat/iic.h>
  27. //#define PRINTK printk
  28. #define PRINTK(...)
  30. enum s3c24xx_i2c_state {
  31. STATE_IDLE,
  32. STATE_START,
  33. STATE_READ,
  34. STATE_WRITE,
  35. STATE_STOP
  36. };
  38. struct s3c2440_i2c_regs {
  39. unsigned int iiccon;
  40. unsigned int iicstat;
  41. unsigned int iicadd;
  42. unsigned int iicds;
  43. unsigned int iiclc;
  44. };
  46. struct s3c2440_i2c_xfer_data {
  47. struct i2c_msg *msgs;
  48. int msn_num;
  49. int cur_msg;
  50. int cur_ptr;
  51. int state;
  52. int err;
  53. wait_queue_head_t wait;
  54. };
  56. static struct s3c2440_i2c_xfer_data s3c2440_i2c_xfer_data;
  59. static struct s3c2440_i2c_regs *s3c2440_i2c_regs;
  62. static void s3c2440_i2c_start(void)
  63. {
  64. s3c2440_i2c_xfer_data.state = STATE_START;
  66. if (s3c2440_i2c_xfer_data.msgs->flags & I2C_M_RD) /* 读 */
  67. {
  68. s3c2440_i2c_regs->iicds = s3c2440_i2c_xfer_data.msgs->addr << 1;
  69. s3c2440_i2c_regs->iicstat = 0xb0; // 主机接收，启动
  70. }
  71. else /* 写 */
  72. {
  73. s3c2440_i2c_regs->iicds = s3c2440_i2c_xfer_data.msgs->addr << 1;
  74. s3c2440_i2c_regs->iicstat = 0xf0; // 主机发送，启动
  75. }
  76. }
  78. static void s3c2440_i2c_stop(int err)
  79. {
  80. s3c2440_i2c_xfer_data.state = STATE_STOP;
  81. s3c2440_i2c_xfer_data.err = err;
  83. PRINTK( "STATE_STOP, err = %d\n", err);
  86. if (s3c2440_i2c_xfer_data.msgs->flags & I2C_M_RD) /* 读 */
  87. {
  88. // 下面两行恢复I2C操作，发出P信号
  89. s3c2440_i2c_regs->iicstat = 0x90;
  90. s3c2440_i2c_regs->iiccon = 0xaf;
  91. ndelay( 50); // 等待一段时间以便P信号已经发出
  92. }
  93. else /* 写 */
  94. {
  95. // 下面两行用来恢复I2C操作，发出P信号
  96. s3c2440_i2c_regs->iicstat = 0xd0;
  97. s3c2440_i2c_regs->iiccon = 0xaf;
  98. ndelay( 50); // 等待一段时间以便P信号已经发出
  99. }
  101. /* 唤醒 */
  102. wake_up(&s3c2440_i2c_xfer_data.wait);
  104. }
  106. static int s3c2440_i2c_xfer(struct i2c_adapter *adap,
  107. struct i2c_msg *msgs, int num)
  108. {
  109. unsigned long timeout;
  111. /* 把num个msg的I2C数据发送出去/读进来 */
  112. s3c2440_i2c_xfer_data.msgs = msgs;
  113. s3c2440_i2c_xfer_data.msn_num = num;
  114. s3c2440_i2c_xfer_data.cur_msg = 0;
  115. s3c2440_i2c_xfer_data.cur_ptr = 0;
  116. s3c2440_i2c_xfer_data.err = -ENODEV;
  118. s3c2440_i2c_start();
  120. /* 休眠 */
  121. timeout = wait_event_timeout(s3c2440_i2c_xfer_data.wait, (s3c2440_i2c_xfer_data.state == STATE_STOP), HZ * 5);
  122. if ( 0 == timeout)
  123. {
  124. printk( "s3c2440_i2c_xfer time out\n");
  125. return -ETIMEDOUT;
  126. }
  127. else
  128. {
  129. return s3c2440_i2c_xfer_data.err;
  130. }
  131. }
  133. static u32 s3c2440_i2c_func(struct i2c_adapter *adap)
  134. {
  135. return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_PROTOCOL_MANGLING;
  136. }
  139. static const struct i2c_algorithm s3c2440_i2c_algo = {
  140. // .smbus_xfer = ,
  141. .master_xfer = s3c2440_i2c_xfer,
  142. .functionality = s3c2440_i2c_func,
  143. };
  145. /* 1. 分配/设置i2c_adapter
  146. */
  147. static struct i2c_adapter s3c2440_i2c_adapter = {
  148. .name = "s3c2440_100ask",
  149. .algo = &s3c2440_i2c_algo,
  150. .owner = THIS_MODULE,
  151. };
  153. static int isLastMsg(void)
  154. {
  155. return (s3c2440_i2c_xfer_data.cur_msg == s3c2440_i2c_xfer_data.msn_num - 1);
  156. }
  158. static int isEndData(void)
  159. {
  160. return (s3c2440_i2c_xfer_data.cur_ptr >= s3c2440_i2c_xfer_data.msgs->len);
  161. }
  163. static int isLastData(void)
  164. {
  165. return (s3c2440_i2c_xfer_data.cur_ptr == s3c2440_i2c_xfer_data.msgs->len - 1);
  166. }
  168. static irqreturn_t s3c2440_i2c_xfer_irq(int irq, void *dev_id)
  169. {
  170. unsigned int iicSt;
  171. iicSt = s3c2440_i2c_regs->iicstat;
  173. if(iicSt & 0x8){ printk( "Bus arbitration failed\n\r"); }
  175. switch (s3c2440_i2c_xfer_data.state)
  176. {
  177. case STATE_START : /* 发出S和设备地址后,产生中断 */
  178. {
  179. PRINTK( "Start\n");
  180. /* 如果没有ACK, 返回错误 */
  181. if (iicSt & S3C2410_IICSTAT_LASTBIT)
  182. {
  183. s3c2440_i2c_stop(-ENODEV);
  184. break;
  185. }
  187. if (isLastMsg() && isEndData())
  188. {
  189. s3c2440_i2c_stop( 0);
  190. break;
  191. }
  193. /* 进入下一个状态 */
  194. if (s3c2440_i2c_xfer_data.msgs->flags & I2C_M_RD) /* 读 */
  195. {
  196. s3c2440_i2c_xfer_data.state = STATE_READ;
  197. goto next_read;
  198. }
  199. else
  200. {
  201. s3c2440_i2c_xfer_data.state = STATE_WRITE;
  202. }
  203. }
  205. case STATE_WRITE:
  206. {
  207. PRINTK( "STATE_WRITE\n");
  208. /* 如果没有ACK, 返回错误 */
  209. if (iicSt & S3C2410_IICSTAT_LASTBIT)
  210. {
  211. s3c2440_i2c_stop(-ENODEV);
  212. break;
  213. }
  215. if (!isEndData()) /* 如果当前msg还有数据要发送 */
  216. {
  217. s3c2440_i2c_regs->iicds = s3c2440_i2c_xfer_data.msgs->buf[s3c2440_i2c_xfer_data.cur_ptr];
  218. s3c2440_i2c_xfer_data.cur_ptr++;
  220. // 将数据写入IICDS后，需要一段时间才能出现在SDA线上
  221. ndelay( 50);
  223. s3c2440_i2c_regs->iiccon = 0xaf; // 恢复I2C传输
  224. break;
  225. }
  226. else if (!isLastMsg())
  227. {
  228. /* 开始处理下一个消息 */
  229. s3c2440_i2c_xfer_data.msgs++;
  230. s3c2440_i2c_xfer_data.cur_msg++;
  231. s3c2440_i2c_xfer_data.cur_ptr = 0;
  232. s3c2440_i2c_xfer_data.state = STATE_START;
  233. /* 发出START信号和发出设备地址 */
  234. s3c2440_i2c_start();
  235. break;
  236. }
  237. else
  238. {
  239. /* 是最后一个消息的最后一个数据 */
  240. s3c2440_i2c_stop( 0);
  241. break;
  242. }
  244. break;
  245. }
  247. case STATE_READ:
  248. {
  249. PRINTK( "STATE_READ\n");
  250. /* 读出数据 */
  251. s3c2440_i2c_xfer_data.msgs->buf[s3c2440_i2c_xfer_data.cur_ptr] = s3c2440_i2c_regs->iicds;
  252. s3c2440_i2c_xfer_data.cur_ptr++;
  253. next_read:
  254. if (!isEndData()) /* 如果数据没读写, 继续发起读操作 */
  255. {
  256. if (isLastData()) /* 如果即将读的数据是最后一个, 不发ack */
  257. {
  258. s3c2440_i2c_regs->iiccon = 0x2f; // 恢复I2C传输，接收到下一数据时无ACK
  259. }
  260. else
  261. {
  262. s3c2440_i2c_regs->iiccon = 0xaf; // 恢复I2C传输，接收到下一数据时发出ACK
  263. }
  264. break;
  265. }
  266. else if (!isLastMsg())
  267. {
  268. /* 开始处理下一个消息 */
  269. s3c2440_i2c_xfer_data.msgs++;
  270. s3c2440_i2c_xfer_data.cur_msg++;
  271. s3c2440_i2c_xfer_data.cur_ptr = 0;
  272. s3c2440_i2c_xfer_data.state = STATE_START;
  273. /* 发出START信号和发出设备地址 */
  274. s3c2440_i2c_start();
  275. break;
  276. }
  277. else
  278. {
  279. /* 是最后一个消息的最后一个数据 */
  280. s3c2440_i2c_stop( 0);
  281. break;
  282. }
  283. break;
  284. }
  286. default: break;
  287. }
  289. /* 清中断 */
  290. s3c2440_i2c_regs->iiccon &= ~(S3C2410_IICCON_IRQPEND);
  292. return IRQ_HANDLED;
  293. }
  296. /*
  297. * I2C初始化
  298. */
  299. static void s3c2440_i2c_init(void)
  300. {
  301. struct clk *clk;
  303. clk = clk_get( NULL, "i2c");
  304. clk_enable(clk);
  306. // 选择引脚功能：GPE15:IICSDA, GPE14:IICSCL
  307. s3c_gpio_cfgpin(S3C2410_GPE( 14), S3C2410_GPE14_IICSCL);
  308. s3c_gpio_cfgpin(S3C2410_GPE( 15), S3C2410_GPE15_IICSDA);
  310. /* bit[7] = 1, 使能ACK
  311. * bit[6] = 0, IICCLK = PCLK/16
  312. * bit[5] = 1, 使能中断
  313. * bit[3:0] = 0xf, Tx clock = IICCLK/16
  314. * PCLK = 50MHz, IICCLK = 3.125MHz, Tx Clock = 0.195MHz
  315. */
  316. s3c2440_i2c_regs->iiccon = ( 1<< 7) | ( 0<< 6) | ( 1<< 5) | ( 0xf); // 0xaf
  318. s3c2440_i2c_regs->iicadd = 0x10; // S3C24xx slave address = [7:1]
  319. s3c2440_i2c_regs->iicstat = 0x10; // I2C串行输出使能(Rx/Tx)
  320. }
  322. static int i2c_bus_s3c2440_init(void)
  323. {
  324. /* 2. 硬件相关的设置 */
  325. s3c2440_i2c_regs = ioremap( 0x54000000, sizeof(struct s3c2440_i2c_regs));
  327. s3c2440_i2c_init();
  329. request_irq(IRQ_IIC, s3c2440_i2c_xfer_irq, 0, "s3c2440-i2c", NULL);
  331. init_waitqueue_head(&s3c2440_i2c_xfer_data.wait);
  333. /* 3. 注册i2c_adapter */
  334. i2c_add_adapter(&s3c2440_i2c_adapter);
  336. return 0;
  337. }
  339. static void i2c_bus_s3c2440_exit(void)
  340. {
  341. i2c_del_adapter(&s3c2440_i2c_adapter);
  342. free_irq(IRQ_IIC, NULL);
  343. iounmap(s3c2440_i2c_regs);
  344. }
  346. module_init(i2c_bus_s3c2440_init);
  347. module_exit(i2c_bus_s3c2440_exit);
  348. MODULE_LICENSE( "GPL");
中年润
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Adapter基础讲解
shiwei0813的博客
03-25 479
这一节我们要讲的UI控件都是跟Adapter(适配器)打交道的，了解并学会使用Adapter很重要， Adapter是用来帮助填充数据的中间桥梁，简单来说就是：将各种数据以合适的形式显示到view上，提供 给用户看！
I2C协议->裸机程序->adapter驱动程序分析
漫不经心
06-19 6920
开发板：mini2440 内核  ：linux2.6.32.2 参考  ：韦东山毕业班I2C视频教程 1、i2c协议简要分析     i2c中线是一种由 PHILIPS 公司开发的串行总线，用于连接微控制器及其外围设备，它具有以下特点。         1、只有两条总线线路：一条串行数据线SDA,一条串行是中线SCL。         2、每个连接到总线的器件都可以使用软件根据
I2C裸机驱动程序设计
weixin_30603633的博客
09-04 140
① I2C（Inter-Integrated Circuit）总线是由飞利浦公司开发的两线式串行总线，用于连接微控制器及其外围设备 ② I2C总线有两根双向信号线 （1）SDA：Serial Data Line（数据线） （2）SCL：Serial CLock Line（时钟线） ③ I2C总线寻址 （1）I2C总线协议规定，从设备采用7位的地址。 　　* D7~D0：...
I2C——裸机编程
weixin_39234635的博客
10-14 517
我所写的这篇博客里的内容尽量会聚焦在i2c裸机编程上，协议的内容也会简单介绍一下。 如下是2440中i2c的block diagram 可以看出，i2c所用的时钟是低速总线外接设备通常用的PCLK，但是PCLK的频率对于I2C的部分从设备来说依然有点高，所以我们需要用这里的4-bit Prescaler来分频，降低PCLK的频率来适配外部的从设备 IICCON 主要作用是使能中断（Tx/Rx I...
Adapter模式
菜菜的程序媛的博客
11-15 459
在现实世界中，如果想让交流电220伏特的电源给直流12伏特的笔记本供电。我们会使用AC适配器。进行电流的转化。在程序中也常常需要这样的适配器。 在程序世界中，经常会有现有的程序无法直接使用，需要做适当的变换之后才能使用。 Adapter模式：用于填补“现有程序”和“所需程序”之间差异的设计模式。 Adapter模式有以下两种： 1、类适配器模式（使用继承的适配器） 2、对象适配器模式（使...
0.96寸OLED显示屏IIC驱动程序（IIC.c/IIC.h/IIC-font.h）+Pctolcd2002
最新发布
05-30
本话题主要涉及0.96寸OLED显示屏的IIC驱动程序，以及如何通过Pctolcd2002工具进行取模操作。这些知识点对于开发基于微控制器的设备，如智能手表、智能家居设备或小型仪表盘等，具有很高的实用价值。 首先，我们要...
bh1750光强检测传感器STM32单片机GPIO模拟iic会接口驱动程序源码.zip
05-18
bh1750光强检测传感器STM32单片机GPIO模拟iic会接口驱动程序源码 main(void) { float datalx; USART1_Config(); delay_init(); iic_init(); bh_data_send(BHPowOn); bh_data_send(BHReset); bh_data_send...
iic总线oled屏幕驱动程序.zip_GNDYCC SCLSDA_OLED 51_iic驱动oled程序_oled屏幕iic
07-14
四引脚（VCC/GND/SCL/SDA）iic总线oled屏幕驱动程序，51系列单片机可用（直接include即可）
基于STM32F103单片机的VL53L0X测距传感器IIC接口驱动程序源代码.zip
05-18
基于STM32F103单片机的VL53L0X测距传感器IIC接口驱动程序源代码，在KEIL UV5开发，只要配置OK即可直接运行。 t main(void) { uint32_t i = 0; /* LED 端口初始化 */ LED_GPIO_Config(); //LED1:红灯控制；LED...
STM32F4 I2C/IIC 驱动程序
10-23
STM32F4系列微控制器是基于ARM Cortex-M4内核的高性能MCU，广泛应用于嵌入式系统设计。...对于开发人员来说，理解I2C协议和STM32F4的硬件特性，以及如何利用提供的驱动程序，将有助于优化项目的性能和可靠性。
bmp280驱动(iic接口)
05-25
bmp280 iic驱动
蓝牙BLE---DA14683的IIC Adapter使用
Jim
12-28 595
DA14683的IIC Adapter使用 Date: 2018.12.28 Create: Jim 关于为什么要使用IIC Adapter，官网文档有说明，更详细的说明可以到Dialog技术支持官网下载DA1468x_I2C_Adapter_Tutorial_v2_0_0这个文档查阅，以下教程也是出于这个文档。 导入工程 首先我们导入工程“pxp_reporter”(其他例程也可以) ...
iTop4412之I2C裸机操作
夜黯竹亭风的博客
01-16 1282
在进行I2C任何操作之前的前提工作： 1.写操作的I2C从机的地址在I2CADD寄存器 2.设置I2CCON寄存器，包括使能中断，确定时钟周期 3.设置I2CSTAT去使能串口输出 参照exynos4412的datasheet写出了exynos4412的I2C的write和read数据的操作void I2C_read(unsigned int slave_addr,unsigned char
iic总线驱动（适配器驱动）详解
highfly591的专栏
02-11 907
linux系统下，不管什么设备（总线驱动、总线设备驱动..）,挂接在总线上都分两种资源：1.驱动设备资源（驱动设备资源注册）2.驱动（针对设备的驱动注册） 所以在实现和学习驱动的时候，就分这两块来进行。 一：我会查找i2c驱动设备资源添加(i2c适配器平台资源) //Mach-mini2440.c (arch\arm\mach-s3c24xx) （1） //平台数据 str
第019课 I2C协议详解及裸机程序分析
韦东山嵌入式专栏
02-28 4183
第001节_I2C协议与EEPROM I2C协议 I2C在硬件上的接法如下(图19-1)所示，主控芯片引出两条线SCL,SDA线，在一条I2C总线上可以接很多I2C设备，我们还会放一个上拉电阻（放一个上拉电阻的原因以后我们再说)。 我们怎么传输数据，我们需要发数据从主设备发送到从设备上去，也需要把数据从从设备传送到主设备上去，数据涉及到双向传输。 举个例子： 体育老师：可以把...
GPIO模拟类I2C总线基础函数实例
keep moving
10-16 1336
我们先了解一下I2C总线基础知识. I2C（Inter－Integrated Circuit）总线是由PHILIPS公司开发的两线式串行总线，用于连接微控制器及其外围设备。是微电子通信控制领域广泛采用的一种总线标准。它是同步通信的一种特殊形式，具有接口线少，控制方式简单，器件封装形式小，通信速率较高等优点。 I2C 总线的概念 　　I2C 总线支持任何IC 生产过程(NMOS CMO
Adapter适配器之基础详解
程序病毒小队的博客
01-15 924
介绍：Adapter是连接后端数据和前端显示的适配器接口，是数据和UI（View）之间一个重要的纽带。在常见的View(ListView,GridView)等地方都需要用到Adapter。如下图直观的表达了Data、Adapter、View三者的关系： Android中所有的Adapter一览： 在我们使用过程中可以根据自己的需求实现接口或者继承类进行一定的扩展。比较常用的有 BaseAd
I2C总线驱动代码
none
06-01 1359
IIC总线驱动代码
Linux I2C子系统【2】-i2c-adapter 创建过程
m0_46535940的博客
08-08 1148
i2c-adapter 驱动分析
IIC驱动详解：硬件原理与platform总线
"IIC驱动程序课件详细讲解了IIC硬件的工作原理以及驱动程序的体系架构，涉及到IIC协议的基本概念、platform总线驱动的原理和相关结构体的解析。" 在嵌入式系统和物联网设备中，IIC（Inter-Integrated Circuit）是一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值