linux i2c

https://blog.csdn.net/chenliang0224/article/details/79069908

1.前言:

 

linux I2C体系结构由三部分组成

①I2C核心:提供I2C总线驱动和设备驱动的注册、注销方法

②I2C总线驱动:主要包括两个数据结构,适配器I2c_adapter(包括algorithm结构体指针)、和algorithm数据结构(最终I2C的通信是由algorithm结构控制发送与接受数据)

③I2C设备驱动:是对I2C硬件体系结构中设备端的实现,两个数据结构,分别是I2c_driver(包括I2C的依附、脱离、探测、移除、关闭、恢复、读写数据。。。)对应一对通信方法、I2c_cilent(包括I2C硬件的芯片地址,设备名称、等,其中该结构体包括适配器I2c_adapter,和I2c_driver指针,这样就可以直接访问了)该结构体对应实在的硬件

 

2.Platform_device i2c 平台设备注册

2.1 i2c IO中断、IO管脚寄存器资源

 

 
  1. static struct resource nuc970_i2c0_resource[] = {

  2. [0] = {

  3. .start = NUC970_PA_I2C0,

  4. .end = NUC970_PA_I2C0 + NUC970_SZ_I2C0 - 1,

  5. .flags = IORESOURCE_MEM,

  6. },

  7. [1] = {

  8. .start = IRQ_I2C0,

  9. .end = IRQ_I2C0,

  10. .flags = IORESOURCE_IRQ,

  11. }

  12. };

2.2 i2c设备平台私有数据

包括I2C总线编号、总线频率

 
  1. static struct nuc970_platform_i2c nuc970_i2c0_data = {

  2. .bus_num = 0, //I2C总线,这里使用的是总线0

  3. .bus_freq = 100000, //I2C总线频率

  4. };

2.3 i2c平台设备注册

 
  1. struct platform_device nuc970_device_i2c0 = {

  2. .name = "nuc970-i2c0",

  3. .id = -1,

  4. .num_resources = ARRAY_SIZE(nuc970_i2c0_resource),

  5. .resource = nuc970_i2c0_resource,

  6. .dev = {

  7. .platform_data = &nuc970_i2c0_data,

  8. }

  9. };

platform_device_register(nuc970_device_i2c0);

platform_device_register(...)将I2C设备注册到platform总线上,为了接下来的平台驱动匹配使用!
 

 

3.Board i2c从设备注册

3.1 i2c从设备结构体

 
  1. struct i2c_board_info {

  2. char type[I2C_NAME_SIZE]; //设备类型名称

  3. unsigned short flags;

  4. unsigned short addr; //I2C从设备地址

  5. void *platform_data;

  6. struct dev_archdata *archdata;

  7. struct device_node *of_node;

  8. struct acpi_dev_node acpi_node;

  9. int irq;

  10. };

 
  1. #define I2C_BOARD_INFO(dev_type, dev_addr) \

  2. .type = dev_type, .addr = (dev_addr)

3.2 i2c从设备信息结构初始化

注册一个从设备为“24c512”,从设备地址为0x50:

 

 
  1. static struct i2c_board_info __initdata nuc970_i2c_clients0[] =

  2. {

  3. {I2C_BOARD_INFO("24c512", 0x50),},

  4. };

3.3 i2c从设备注册到链表

i2c_register_board_info(0, nuc970_i2c_clients0, sizeof(nuc970_i2c_clients0)/sizeof(struct i2c_board_info));
 
  1. i2c_register_board_info(int busnum,

  2. struct i2c_board_info const *info, unsigned len)

  3. {

  4. int status;

  5.  
  6. down_write(&__i2c_board_lock);

  7.  
  8. /* dynamic bus numbers will be assigned after the last static one */

  9. if (busnum >= __i2c_first_dynamic_bus_num)

  10. __i2c_first_dynamic_bus_num = busnum + 1;

  11.  
  12. for (status = 0; len; len--, info++) {

  13. struct i2c_devinfo *devinfo;

  14.  
  15. devinfo = kzalloc(sizeof(*devinfo), GFP_KERNEL);

  16. if (!devinfo) {

  17. pr_debug("i2c-core: can't register boardinfo!\n");

  18. status = -ENOMEM;

  19. break;

  20. }

  21.  
  22. devinfo->busnum = busnum;

  23. devinfo->board_info = *info;

  24. list_add_tail(&devinfo->list, &__i2c_board_list);

  25. }

  26.  
  27. up_write(&__i2c_board_lock);

  28.  
  29. return status;

  30. }

这里主要将I2C从设备信息注册到全局链表__i2c_board_list中
 

4.Platform_driver i2c 平台驱动注册

4.1 i2c设备驱动注册

 
  1. static struct platform_driver nuc970_i2c0_driver = {

  2. .probe = nuc970_i2c0_probe,

  3. .remove = nuc970_i2c0_remove,

  4. .driver = {

  5. .name = "nuc970-i2c0",

  6. .owner = THIS_MODULE,

  7. },

  8. };

  9. module_platform_driver(nuc970_i2c0_driver);

设备驱动和设备通过名称"nuc970-i2c0"匹配相等(具体可以参考之前写的一篇文章:点击打开链接),调用探测函数nuc970_i2c0_probe(...)进行驱动注册。

4.2 i2c probe(...)

 
  1. static int nuc970_i2c0_probe(struct platform_device *pdev)

  2. {

  3. struct nuc970_i2c *i2c;

  4. struct nuc970_platform_i2c *pdata;

  5. struct resource *res;

  6. int ret;

  7.  
  8. pdata = pdev->dev.platform_data; //这里为设备nuc970_i2c0_data[]结构体数据

  9. if (!pdata) {

  10. dev_err(&pdev->dev, "no platform data\n");

  11. return -EINVAL;

  12. }

  13.  
  14. i2c = kzalloc(sizeof(struct nuc970_i2c), GFP_KERNEL); //分配一个i2c控制器

  15. if (!i2c) {

  16. dev_err(&pdev->dev, "no memory for state\n");

  17. return -ENOMEM;

  18. }

  19.  
  20. //用这个更合理些:strlcpy(i2c->adap.name, pdev->dev.name, sizeof(i2c->adap.name));

  21. strlcpy(i2c->adap.name, "nuc970-i2c0", sizeof(i2c->adap.name)); //给i2c适配器命名

  22. i2c->adap.owner = THIS_MODULE;

  23. i2c->adap.algo = &nuc970_i2c0_algorithm; //i2c访问总线的方法,即读、写从设备操作

  24. i2c->adap.retries = 2; //尝试次数

  25. i2c->adap.class = I2C_CLASS_HWMON | I2C_CLASS_SPD;

  26.  
  27. spin_lock_init(&i2c->lock);

  28. init_waitqueue_head(&i2c->wait); //初始化等待队列

  29.  
  30. /* find the clock and enable it */

  31.  
  32. i2c->dev = &pdev->dev;

  33. i2c->clk = clk_get(NULL, "i2c0");

  34. if (IS_ERR(i2c->clk)) {

  35. dev_err(&pdev->dev, "cannot get clock\n");

  36. ret = -ENOENT;

  37. goto err_noclk;

  38. }

  39.  
  40. dev_dbg(&pdev->dev, "clock source %p\n", i2c->clk);

  41.  
  42. clk_prepare(i2c->clk);

  43. clk_enable(i2c->clk);

  44.  
  45. /* map the registers */

  46.  
  47. res = platform_get_resource(pdev, IORESOURCE_MEM, 0); //获取IO寄存器资源

  48. if (res == NULL) {

  49. dev_err(&pdev->dev, "cannot find IO resource\n");

  50. ret = -ENOENT;

  51. goto err_clk;

  52. }

  53.  
  54. i2c->ioarea = request_mem_region(res->start, resource_size(res), //申请内存资源

  55. pdev->name);

  56.  
  57. if (i2c->ioarea == NULL) {

  58. dev_err(&pdev->dev, "cannot request IO\n");

  59. ret = -ENXIO;

  60. goto err_clk;

  61. }

  62.  
  63. i2c->regs = ioremap(res->start, resource_size(res)); //资源映射

  64.  
  65. if (i2c->regs == NULL) {

  66. dev_err(&pdev->dev, "cannot map IO\n");

  67. ret = -ENXIO;

  68. goto err_ioarea;

  69. }

  70.  
  71. dev_dbg(&pdev->dev, "registers %p (%p, %p)\n",

  72. i2c->regs, i2c->ioarea, res);

  73.  
  74. /* setup info block for the i2c core */

  75.  
  76. i2c->adap.algo_data = i2c; //适配器算法数据指针指向i2c控制器

  77. i2c->adap.dev.parent = &pdev->dev;

  78.  
  79. ret = clk_get_rate(i2c->clk)/(pdata->bus_freq * 5) - 1;

  80. writel(ret & 0xffff, i2c->regs + DIVIDER);

  81.  
  82. /* find the IRQ for this unit (note, this relies on the init call to

  83. * ensure no current IRQs pending

  84. */

  85.  
  86. i2c->irq = ret = platform_get_irq(pdev, 0);

  87. if (ret <= 0) {

  88. dev_err(&pdev->dev, "cannot find IRQ\n");

  89. goto err_iomap;

  90. }

  91.  
  92. ret = request_irq(i2c->irq, nuc970_i2c_irq, IRQF_SHARED, //申请i2c中断

  93. dev_name(&pdev->dev), i2c);

  94.  
  95. if (ret != 0) {

  96. dev_err(&pdev->dev, "cannot claim IRQ %d\n", i2c->irq);

  97. goto err_iomap;

  98. }

  99.  
  100. /* Note, previous versions of the driver used i2c_add_adapter()

  101. * to add the bus at any number. We now pass the bus number via

  102. * the platform data, so if unset it will now default to always

  103. * being bus 0.

  104. */

  105.  
  106. i2c->adap.nr = pdata->bus_num; //适配器所属i2c总线编号,这里为0

  107.  
  108. ret = i2c_add_numbered_adapter(&i2c->adap); //增加一个适配器

  109. if (ret < 0) {

  110. dev_err(&pdev->dev, "failed to add bus to i2c core\n");

  111. goto err_irq;

  112. }

  113.  
  114. platform_set_drvdata(pdev, i2c);

  115.  
  116. dev_info(&pdev->dev, "%s: nuc970 I2C adapter\n",

  117. dev_name(&i2c->adap.dev));

  118. return 0;

  119.  
  120. err_irq:

  121. free_irq(i2c->irq, i2c);

  122.  
  123. err_iomap:

  124. iounmap(i2c->regs);

  125.  
  126. err_ioarea:

  127. release_resource(i2c->ioarea);

  128. kfree(i2c->ioarea);

  129.  
  130. err_clk:

  131. clk_disable(i2c->clk);

  132. clk_put(i2c->clk);

  133.  
  134. err_noclk:

  135. kfree(i2c);

  136. return ret;

  137. }

i2c算法操作:

 
  1. static const struct i2c_algorithm nuc970_i2c0_algorithm = {

  2. .master_xfer = nuc970_i2c0_xfer,

  3. .functionality = nuc970_i2c0_func,

  4. };

 
  1. /* declare our i2c functionality */

  2. static u32 nuc970_i2c0_func(struct i2c_adapter *adap)

  3. {

  4. return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_NOSTART |

  5. I2C_FUNC_PROTOCOL_MANGLING;

  6. }

 
  1. static int nuc970_i2c0_xfer(struct i2c_adapter *adap,

  2. struct i2c_msg *msgs, int num)

  3. {

  4. struct nuc970_i2c *i2c = (struct nuc970_i2c *)adap->algo_data; //adap->algo_data指向i2c,见上代码

  5. int retry;

  6. int ret;

  7.  
  8. nuc970_i2c0_enable_irq(i2c); //使能中断

  9.  
  10. for (retry = 0; retry < adap->retries; retry++) { //尝试次数

  11.  
  12. ret = nuc970_i2c0_doxfer(i2c, msgs, num); //传输数据

  13.  
  14. if (ret != -EAGAIN)

  15. return ret;

  16.  
  17. dev_dbg(i2c->dev, "Retrying transmission (%d)\n", retry);

  18.  
  19. udelay(100);

  20. }

  21.  
  22. return -EREMOTEIO;

  23. }

 
  1. static int nuc970_i2c0_doxfer(struct nuc970_i2c *i2c,

  2. struct i2c_msg *msgs, int num)

  3. {

  4. unsigned long iicstat, timeout;

  5. int spins = 20;

  6. int ret;

  7.  
  8. ret = nuc970_i2c0_set_master(i2c);

  9. if (ret != 0) {

  10. dev_err(i2c->dev, "cannot get bus (error %d)\n", ret);

  11. ret = -EAGAIN;

  12. goto out;

  13. }

  14.  
  15. spin_lock_irq(&i2c->lock);

  16.  
  17. i2c->msg = msgs; //消息指针

  18. i2c->msg_num = num; //消息的个数

  19. i2c->msg_ptr = 0;

  20. i2c->msg_idx = 0;

  21. i2c->state = STATE_START; //I2C传输状态设置为启动

  22. nuc970_i2c0_message_start(i2c, msgs); //开始发送消息,当发送一个字节后将触发中断,本函数退出,进入下面的休眠zhuangta

  23. spin_unlock_irq(&i2c->lock);

  24.  
  25. //i2c->msg_num != 0 时wait_event_timeout(...)将等待HZ*5的超时时间

  26. timeout = wait_event_timeout(i2c->wait, i2c->msg_num == 0, HZ * 5);

  27.  
  28.  
  29. if(i2c->arblost) {

  30. printk("arb lost, stop\n");

  31. i2c->arblost = 0;

  32. nuc970_i2c0_stop(i2c, 0);

  33. }

  34.  
  35. ret = i2c->msg_idx;

  36.  
  37. /* having these next two as dev_err() makes life very

  38. * noisy when doing an i2cdetect

  39. */

  40.  
  41. if (timeout == 0)

  42. dev_dbg(i2c->dev, "timeout\n");

  43. else if (ret != num)

  44. dev_dbg(i2c->dev, "incomplete xfer (%d)\n", ret);

  45.  
  46. /* ensure the stop has been through the bus */

  47. dev_dbg(i2c->dev, "waiting for bus idle\n");

  48.  
  49. /* first, try busy waiting briefly */

  50. do {

  51. iicstat = readl(i2c->regs + CSR);

  52. } while ((iicstat & I2CBUSY) && --spins);

  53.  
  54. /* if that timed out sleep */

  55. if (!spins) {

  56. msleep(1);

  57. iicstat = readl(i2c->regs + CSR);

  58. }

  59.  
  60. if (iicstat & I2CBUSY)

  61. dev_warn(i2c->dev, "timeout waiting for bus idle\n");

  62.  
  63. out:

  64. return ret;

  65. }

这里发送一个字节从设备地址,然后进入中断,发送数据,关于中断部分待分析!!!

 
  1. static void nuc970_i2c0_message_start(struct nuc970_i2c *i2c,

  2. struct i2c_msg *msg)

  3. {

  4. unsigned int addr = (msg->addr & 0x7f) << 1; //从设备地址

  5.  
  6. if (msg->flags & I2C_M_RD) //是否是读数据

  7. addr |= 0x1;

  8. writel(addr & 0xff, i2c->regs + TXR); //传输地址

  9. writel(I2C_CMD_START | I2C_CMD_WRITE, i2c->regs + CMDR);

  10. }

4.3 i2c中断函数

申请一个中断:

 
  1. ret = request_irq(i2c->irq, nuc970_i2c_irq, IRQF_SHARED, //申请i2c中断

  2. dev_name(&pdev->dev), i2c);

中断回调函数:

 
  1. static irqreturn_t nuc970_i2c_irq(int irqno, void *dev_id)

  2. {

  3. struct nuc970_i2c *i2c = dev_id;

  4. unsigned long status;

  5.  
  6. status = readl(i2c->regs + CSR);

  7. writel(status | IRQFLAG, i2c->regs + CSR);

  8.  
  9. if (status & ARBIT_LOST) {

  10. /* deal with arbitration loss */

  11. dev_err(i2c->dev, "deal with arbitration loss\n");

  12. i2c->arblost = 1;

  13. goto out;

  14. }

  15.  
  16. if (i2c->state == STATE_IDLE) {

  17. dev_dbg(i2c->dev, "IRQ: error i2c->state == IDLE\n");

  18. goto out;

  19. }

  20.  
  21. /* pretty much this leaves us with the fact that we've

  22. * transmitted or received whatever byte we last sent

  23. */

  24.  
  25. i2c_nuc970_irq_nextbyte(i2c, status);

  26.  
  27. out:

  28. return IRQ_HANDLED;

  29. }

进入到字节传输,i2c采用状态机的形式进行消息发送、接收,这个函数很重要:

 
  1. static void i2c_nuc970_irq_nextbyte(struct nuc970_i2c *i2c, unsigned long iicstat)

  2. {

  3. unsigned char byte;

  4.  
  5. switch (i2c->state) {

  6.  
  7. case STATE_IDLE:

  8. dev_err(i2c->dev, "%s: called in STATE_IDLE\n", __func__);

  9. break;

  10.  
  11. case STATE_STOP:

  12. nuc970_i2c0_disable_irq(i2c);

  13. break;

  14.  
  15. case STATE_START:

  16. /* last thing we did was send a start condition on the

  17. * bus, or started a new i2c message

  18. */

  19.  
  20. if (iicstat & SLAVE_ACK &&

  21. !(i2c->msg->flags & I2C_M_IGNORE_NAK)) {

  22. /* ack was not received... */

  23.  
  24. dev_dbg(i2c->dev, "ack was not received\n");

  25. nuc970_i2c0_stop(i2c, -ENXIO);

  26. break;

  27. }

  28.  
  29. if (i2c->msg->flags & I2C_M_RD)

  30. i2c->state = STATE_READ;

  31. else

  32. i2c->state = STATE_WRITE;

  33.  
  34. /* terminate the transfer if there is nothing to do

  35. * as this is used by the i2c probe to find devices.

  36. */

  37.  
  38. if (is_lastmsg(i2c) && i2c->msg->len == 0) {

  39. nuc970_i2c0_stop(i2c, 0);

  40. break;

  41. }

  42.  
  43. if (i2c->state == STATE_READ)

  44. goto prepare_read;

  45.  
  46. /* fall through to the write state, as we will need to

  47. * send a byte as well

  48. */

  49.  
  50. case STATE_WRITE:

  51. /* we are writing data to the device... check for the

  52. * end of the message, and if so, work out what to do

  53. */

  54.  
  55. if (!(i2c->msg->flags & I2C_M_IGNORE_NAK)) {

  56. if (iicstat & SLAVE_ACK) {

  57. dev_dbg(i2c->dev, "WRITE: No Ack\n");

  58.  
  59. nuc970_i2c0_stop(i2c, -ECONNREFUSED);

  60. break;

  61. }

  62. }

  63.  
  64. retry_write:

  65.  
  66. if (!is_msgend(i2c)) {

  67. byte = i2c->msg->buf[i2c->msg_ptr++];

  68. writeb(byte, i2c->regs + TXR);

  69. writel(I2C_CMD_WRITE, i2c->regs + CMDR);

  70.  
  71. } else if (!is_lastmsg(i2c)) { //是否是最后的msg消息,个数由i2c->msg_num决定

  72. /* we need to go to the next i2c message */

  73.  
  74. dev_dbg(i2c->dev, "WRITE: Next Message\n");

  75.  
  76. i2c->msg_ptr = 0; //msg消息清零

  77. i2c->msg_idx++; //msg消息个数索引

  78. i2c->msg++; //切换到下一个待发送的消息

  79.  
  80. /* check to see if we need to do another message */

  81. if (i2c->msg->flags & I2C_M_NOSTART) {

  82.  
  83. if (i2c->msg->flags & I2C_M_RD) {

  84. /* cannot do this, the controller

  85. * forces us to send a new START

  86. * when we change direction

  87. */

  88.  
  89. nuc970_i2c0_stop(i2c, -EINVAL);

  90. }

  91.  
  92. goto retry_write;

  93. } else {

  94. /* send the new start */

  95. nuc970_i2c0_message_start(i2c, i2c->msg); //发送消息

  96. i2c->state = STATE_START;

  97. }

  98.  
  99. } else {

  100. /* send stop */

  101.  
  102. nuc970_i2c0_stop(i2c, 0);

  103. }

  104. break;

  105.  
  106. case STATE_READ:

  107. /* we have a byte of data in the data register, do

  108. * something with it, and then work out whether we are

  109. * going to do any more read/write

  110. */

  111.  
  112. byte = readb(i2c->regs + RXR);

  113. i2c->msg->buf[i2c->msg_ptr++] = byte;

  114.  
  115. prepare_read:

  116. if (is_msglast(i2c)) { //是否是消息的最后一个字节

  117. /* last byte of buffer */

  118.  
  119. if (is_lastmsg(i2c)) //是否是最后的消息

  120. writel(I2C_CMD_READ | I2C_CMD_NACK,

  121. i2c->regs + CMDR);

  122.  
  123. } else if (is_msgend(i2c)) { //消息是否发送完

  124. /* ok, we've read the entire buffer, see if there

  125. * is anything else we need to do

  126. */

  127.  
  128. if (is_lastmsg(i2c)) { //是否是最后的消息

  129. /* last message, send stop and complete */

  130. dev_dbg(i2c->dev, "READ: Send Stop\n");

  131.  
  132. nuc970_i2c0_stop(i2c, 0);

  133. } else {

  134. /* go to the next transfer */

  135. dev_dbg(i2c->dev, "READ: Next Transfer\n");

  136.  
  137. i2c->msg_ptr = 0;

  138. i2c->msg_idx++;

  139. i2c->msg++;

  140.  
  141. writel(I2C_CMD_READ, i2c->regs + CMDR);

  142. }

  143.  
  144. } else {

  145. writel(I2C_CMD_READ, i2c->regs + CMDR);

  146. }

  147.  
  148. break;

  149. }

  150. }

4.4 向I2C核心增加适配器

ret = i2c_add_numbered_adapter(&i2c->adap); //增加一个适配器
 
  1. int i2c_add_numbered_adapter(struct i2c_adapter *adap)

  2. {

  3. if (adap->nr == -1) /* -1 means dynamically assign bus id */

  4. return i2c_add_adapter(adap);

  5.  
  6. return __i2c_add_numbered_adapter(adap);

  7. }

 
  1. static int __i2c_add_numbered_adapter(struct i2c_adapter *adap)

  2. {

  3. int id;

  4.  
  5. mutex_lock(&core_lock);

  6. id = idr_alloc(&i2c_adapter_idr, adap, adap->nr, adap->nr + 1,

  7. GFP_KERNEL);

  8. mutex_unlock(&core_lock);

  9. if (id < 0)

  10. return id == -ENOSPC ? -EBUSY : id;

  11.  
  12. return i2c_register_adapter(adap);

  13. }

idr_alloc(...)可以参考这位大神写的博客:点击打开链接,目的就是给这里的i2c适配器分配一个id号

 
  1. static int i2c_register_adapter(struct i2c_adapter *adap)

  2. {

  3. int res = 0;

  4.  
  5. /* Can't register until after driver model init */

  6. if (unlikely(WARN_ON(!i2c_bus_type.p))) {

  7. res = -EAGAIN;

  8. goto out_list;

  9. }

  10.  
  11. /* Sanity checks */

  12. if (unlikely(adap->name[0] == '\0')) {

  13. pr_err("i2c-core: Attempt to register an adapter with "

  14. "no name!\n");

  15. return -EINVAL;

  16. }

  17. if (unlikely(!adap->algo)) {

  18. pr_err("i2c-core: Attempt to register adapter '%s' with "

  19. "no algo!\n", adap->name);

  20. return -EINVAL;

  21. }

  22.  
  23. rt_mutex_init(&adap->bus_lock);

  24. mutex_init(&adap->userspace_clients_lock);

  25. INIT_LIST_HEAD(&adap->userspace_clients);

  26.  
  27. /* Set default timeout to 1 second if not already set */

  28. if (adap->timeout == 0)

  29. adap->timeout = HZ;

  30.  
  31. dev_set_name(&adap->dev, "i2c-%d", adap->nr); //设置适配器的名称为“i2c-0”

  32. adap->dev.bus = &i2c_bus_type;

  33. adap->dev.type = &i2c_adapter_type;

  34. res = device_register(&adap->dev); //设备注册,下面重点讲解,不然不能够理解本章的核心思想!!!

  35. if (res)

  36. goto out_list;

  37.  
  38. dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);

  39.  
  40. #ifdef CONFIG_I2C_COMPAT

  41. res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,

  42. adap->dev.parent);

  43. if (res)

  44. dev_warn(&adap->dev,

  45. "Failed to create compatibility class link\n");

  46. #endif

  47.  
  48. /* bus recovery specific initialization */

  49. if (adap->bus_recovery_info) {

  50. struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;

  51.  
  52. if (!bri->recover_bus) {

  53. dev_err(&adap->dev, "No recover_bus() found, not using recovery\n");

  54. adap->bus_recovery_info = NULL;

  55. goto exit_recovery;

  56. }

  57.  
  58. /* Generic GPIO recovery */

  59. if (bri->recover_bus == i2c_generic_gpio_recovery) {

  60. if (!gpio_is_valid(bri->scl_gpio)) {

  61. dev_err(&adap->dev, "Invalid SCL gpio, not using recovery\n");

  62. adap->bus_recovery_info = NULL;

  63. goto exit_recovery;

  64. }

  65.  
  66. if (gpio_is_valid(bri->sda_gpio))

  67. bri->get_sda = get_sda_gpio_value;

  68. else

  69. bri->get_sda = NULL;

  70.  
  71. bri->get_scl = get_scl_gpio_value;

  72. bri->set_scl = set_scl_gpio_value;

  73. } else if (!bri->set_scl || !bri->get_scl) {

  74. /* Generic SCL recovery */

  75. dev_err(&adap->dev, "No {get|set}_gpio() found, not using recovery\n");

  76. adap->bus_recovery_info = NULL;

  77. }

  78. }

  79.  
  80. exit_recovery:

  81. /* create pre-declared device nodes */

  82. if (adap->nr < __i2c_first_dynamic_bus_num) //

  83. i2c_scan_static_board_info(adap);

  84.  
  85. /* Notify drivers */

  86. mutex_lock(&core_lock);

  87. bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);

  88. mutex_unlock(&core_lock);

  89.  
  90. return 0;

  91.  
  92. out_list:

  93. mutex_lock(&core_lock);

  94. idr_remove(&i2c_adapter_idr, adap->nr);

  95. mutex_unlock(&core_lock);

  96. return res;

  97. }

设备注册流程如下:

a.  设备注册:device_register(&adap->dev)

 
  1. int device_register(struct device *dev)

  2. {

  3. device_initialize(dev);

  4. return device_add(dev);

  5. }

device_initialize(...)设备初始化,包括设备集合、设备对象,即在/sys/系统下的目录及文件

 

b. 设备增加:device_add(...)

c. 设备添加到总线:bus_add_device(...)

 
  1. int bus_add_device(struct device *dev)

  2. {

  3. struct bus_type *bus = bus_get(dev->bus);

  4. int error = 0;

  5.  
  6. if (bus) {

  7. pr_debug("bus: '%s': add device %s\n", bus->name, dev_name(dev));

  8. error = device_add_attrs(bus, dev);

  9. if (error)

  10. goto out_put;

  11. error = sysfs_create_link(&bus->p->devices_kset->kobj,

  12. &dev->kobj, dev_name(dev));

  13. if (error)

  14. goto out_id;

  15. error = sysfs_create_link(&dev->kobj,

  16. &dev->bus->p->subsys.kobj, "subsystem");

  17. if (error)

  18. goto out_subsys;

  19. //将本次设备的的链表dev->p->knode_bus添加到bus->p->klist_devices链表中,

  20. //这里很重要,设备驱动在注册的时候就是通过该链表与对应的设备进行匹配

  21. klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices);

  22. }

  23. return 0;

  24.  
  25. out_subsys:

  26. sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev));

  27. out_id:

  28. device_remove_attrs(bus, dev);

  29. out_put:

  30. bus_put(dev->bus);

  31. return error;

  32. }

这里将设备dev添加到i2c Bus总线的内核链表中bus->p->klist_devices,必须理解,下面在注册at24c512设备时会通过该链表进行匹配!!!

__i2c_first_dynamic_bus_num变量由上面i2c_register_board_info(...)函数注册时赋值,这里__i2c_first_dynamic_bus_num=1,adap->nr=0,条件成立,接下来扫描i2c的board_info信息板级文件信息:

 
  1. static void i2c_scan_static_board_info(struct i2c_adapter *adapter)

  2. {

  3. struct i2c_devinfo *devinfo;

  4.  
  5. down_read(&__i2c_board_lock);

  6. /*

  7. 检索在arch/arm/mach-nuc970/dev.c 中i2c_register_board_info() 注册的板级文件,

  8. 比对本次传入参数adapter适配器的I2C总线编号是否一致,一根总

  9. 线下可以挂接很多设备,当总线号相等时,这里会注册多个板

  10. 级文件中的设备.

  11. */

  12. list_for_each_entry(devinfo, &__i2c_board_list, list) {

  13. if (devinfo->busnum == adapter->nr

  14. && !i2c_new_device(adapter,

  15. &devinfo->board_info))

  16. dev_err(&adapter->dev,

  17. "Can't create device at 0x%02x\n",

  18. devinfo->board_info.addr);

  19. //printk("###kernel: i2c_scan_static_board_info(): devinfo->busnum=%d, adapter->nr=%d, devinfo->board_info.type=%s.\n", \

  20. // devinfo->busnum, adapter->nr, devinfo->board_info.type);

  21. }

  22. up_read(&__i2c_board_lock);

  23. }

 

通过全局链表__i2c_board_list中的总线编号与本次注册的适配器进行比对,匹配成功调用i2c_new_device(...)注册一个新的设备。

 
  1. struct i2c_client *

  2. i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)

  3. {

  4. struct i2c_client *client;

  5. int status;

  6.  
  7. client = kzalloc(sizeof *client, GFP_KERNEL);

  8. if (!client)

  9. return NULL;

  10.  
  11. client->adapter = adap;

  12.  
  13. client->dev.platform_data = info->platform_data;

  14.  
  15. if (info->archdata)

  16. client->dev.archdata = *info->archdata;

  17.  
  18. client->flags = info->flags;

  19. client->addr = info->addr;

  20. client->irq = info->irq;

  21.  
  22. strlcpy(client->name, info->type, sizeof(client->name));

  23.  
  24. /* Check for address validity */

  25. status = i2c_check_client_addr_validity(client); //校验当前从设备地址是否有效

  26. if (status) {

  27. dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",

  28. client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);

  29. goto out_err_silent;

  30. }

  31.  
  32. /* Check for address business */

  33. status = i2c_check_addr_busy(adap, client->addr); //校验当前从设备地址是否已经注册

  34. if (status)

  35. goto out_err;

  36.  
  37. client->dev.parent = &client->adapter->dev;

  38. client->dev.bus = &i2c_bus_type;

  39. client->dev.type = &i2c_client_type;

  40. client->dev.of_node = info->of_node;

  41. ACPI_HANDLE_SET(&client->dev, info->acpi_node.handle);

  42.  
  43. /* For 10-bit clients, add an arbitrary offset to avoid collisions */

  44. dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),

  45. client->addr | ((client->flags & I2C_CLIENT_TEN)

  46. ? 0xa000 : 0));

  47. status = device_register(&client->dev); //将当前的客户端设备注册到设备树中

  48. if (status)

  49. goto out_err;

  50.  
  51. dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",

  52. client->name, dev_name(&client->dev));

  53.  
  54. return client;

  55.  
  56. out_err:

  57. dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "

  58. "(%d)\n", client->name, client->addr, status);

  59. out_err_silent:

  60. kfree(client);

  61. return NULL;

  62. }

i2c_new_device(...)的目的是通过“适配器参数+板级文件信息=创建一个I2C从设备客户端”,成功就返回该信息:


在回到i2c_register_adapter(...)

 
  1. /* Notify drivers */

  2. mutex_lock(&core_lock);

  3. bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);

  4. mutex_unlock(&core_lock);

i2c_bus_type总线类型定义:

 
  1. struct bus_type i2c_bus_type = {

  2. .name = "i2c",

  3. .match = i2c_device_match, //设备匹配

  4. .probe = i2c_device_probe, //设备匹配之后调用的探测函数

  5. .remove = i2c_device_remove,

  6. .shutdown = i2c_device_shutdown,

  7. .pm = &i2c_device_pm_ops,

  8. };

5.at24c512设备驱动注册

5.1 at24c512驱动注册

at24系列产品型号,包括产品名称、存储空间、地址bit位数:

 
  1. static const struct i2c_device_id at24_ids[] = {

  2. /* needs 8 addresses as A0-A2 are ignored */

  3. { "24c00", AT24_DEVICE_MAGIC(128 / 8, AT24_FLAG_TAKE8ADDR) },

  4. /* old variants can't be handled with this generic entry! */

  5. { "24c01", AT24_DEVICE_MAGIC(1024 / 8, 0) },

  6. { "24c02", AT24_DEVICE_MAGIC(2048 / 8, 0) },

  7. /* spd is a 24c02 in memory DIMMs */

  8. { "spd", AT24_DEVICE_MAGIC(2048 / 8,

  9. AT24_FLAG_READONLY | AT24_FLAG_IRUGO) },

  10. { "24c04", AT24_DEVICE_MAGIC(4096 / 8, 0) },

  11. /* 24rf08 quirk is handled at i2c-core */

  12. { "24c08", AT24_DEVICE_MAGIC(8192 / 8, 0) },

  13. { "24c16", AT24_DEVICE_MAGIC(16384 / 8, 0) },

  14. { "24c32", AT24_DEVICE_MAGIC(32768 / 8, AT24_FLAG_ADDR16) },

  15. { "24c64", AT24_DEVICE_MAGIC(65536 / 8, AT24_FLAG_ADDR16) },

  16. { "24c128", AT24_DEVICE_MAGIC(131072 / 8, AT24_FLAG_ADDR16) },

  17. { "24c256", AT24_DEVICE_MAGIC(262144 / 8, AT24_FLAG_ADDR16) },

  18. { "24c512", AT24_DEVICE_MAGIC(524288 / 8, AT24_FLAG_ADDR16) },

  19. { "24c1024", AT24_DEVICE_MAGIC(1048576 / 8, AT24_FLAG_ADDR16) },

  20. { "at24", 0 },

  21. { /* END OF LIST */ }

  22. };

at24_driver驱动:

 
  1. static struct i2c_driver at24_driver = {

  2. .driver = {

  3. .name = "at24",

  4. .owner = THIS_MODULE,

  5. },

  6. .probe = at24_probe,

  7. .remove = at24_remove,

  8. .id_table = at24_ids,

  9. };

 
  1. static int __init at24_init(void)

  2. {

  3. if (!io_limit) {

  4. pr_err("at24: io_limit must not be 0!\n");

  5. return -EINVAL;

  6. }

  7.  
  8. io_limit = rounddown_pow_of_two(io_limit);

  9. return i2c_add_driver(&at24_driver);

  10. }

  11. module_init(at24_init);

 
  1. #define __define_initcall(level,fn) \

  2. static initcall_t __initcall_##fn __used \

  3. __attribute__((__section__(".initcall" level ".init"))) = fn

  4.  
  5. #define device_initcall(fn) __define_initcall(fn, 6)

  6.  
  7. #define __initcall(fn) device_initcall(fn)

  8.  
  9. #define module_init(x) __initcall(x);

module_init(...)宏路径:linux-3.10.x-20171019\include\linux\init.h

 

 
  1. #define i2c_add_driver(driver) \

  2. i2c_register_driver(THIS_MODULE, driver)

向i2c核心注册驱动i2c_register_driver(...)

 
  1. int i2c_register_driver(struct module *owner, struct i2c_driver *driver)

  2. {

  3. int res;

  4.  
  5. /* Can't register until after driver model init */

  6. if (unlikely(WARN_ON(!i2c_bus_type.p)))

  7. return -EAGAIN;

  8.  
  9. /* add the driver to the list of i2c drivers in the driver core */

  10. driver->driver.owner = owner;

  11. driver->driver.bus = &i2c_bus_type; //绑定驱动的总线为i2c_bus_type

  12.  
  13. /* When registration returns, the driver core

  14. * will have called probe() for all matching-but-unbound devices.

  15. */

  16. res = driver_register(&driver->driver); //驱动注册

  17. if (res)

  18. return res;

  19.  
  20. /* Drivers should switch to dev_pm_ops instead. */

  21. if (driver->suspend)

  22. pr_warn("i2c-core: driver [%s] using legacy suspend method\n",

  23. driver->driver.name);

  24. if (driver->resume)

  25. pr_warn("i2c-core: driver [%s] using legacy resume method\n",

  26. driver->driver.name);

  27.  
  28. pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);

  29.  
  30. INIT_LIST_HEAD(&driver->clients);

  31. /* Walk the adapters that are already present */

  32. i2c_for_each_dev(driver, __process_new_driver); //遍历i2c_bus_type结构体的链表,判定当前设备是否有匹配的,详见下面

  33.  
  34. return 0;

  35. }

i2c_for_each_dev(....)函数:

 

 
  1. int i2c_for_each_dev(void *data, int (*fn)(struct device *, void *))

  2. {

  3. int res;

  4.  
  5. mutex_lock(&core_lock);

  6. res = bus_for_each_dev(&i2c_bus_type, NULL, data, fn);

  7. mutex_unlock(&core_lock);

  8.  
  9. return res;

  10. }

 
  1. int bus_for_each_dev(struct bus_type *bus, struct device *start,

  2. void *data, int (*fn)(struct device *, void *))

  3. {

  4. struct klist_iter i;

  5. struct device *dev;

  6. int error = 0;

  7.  
  8. if (!bus || !bus->p)

  9. return -EINVAL;

  10.  
  11. klist_iter_init_node(&bus->p->klist_devices, &i,//设备通过bus_add_device(...)添加时,最终会将设备加入到bus->p->klist_devices设备链表中

  12. (start ? &start->p->knode_bus : NULL));

  13. while ((dev = next_device(&i)) && !error)

  14. error = fn(dev, data);

  15. klist_iter_exit(&i);

  16. return error;

  17. }

在bus_for_each_dev(...)函数中,可以看到遍历bus->p->klist_devices链表,而该链表在前面提到过,就是设备加入到的链表,这里通过获取链表的设备(i2c_bus_type)与data(本次注册的at24c512设备),通过fn(...)函数指针__process_new_driver(...)进行调用,具体如下:

 

该函数的第二个参数如下:

 

 
  1. static int __process_new_driver(struct device *dev, void *data)

  2. {

  3. if (dev->type != &i2c_adapter_type) //

  4. return 0;

  5. return i2c_do_add_adapter(data, to_i2c_adapter(dev));

  6. }

 
  1. static int i2c_do_add_adapter(struct i2c_driver *driver,

  2. struct i2c_adapter *adap)

  3. {

  4. /* Detect supported devices on that bus, and instantiate them */

  5. i2c_detect(adap, driver);

  6.  
  7. /* Let legacy drivers scan this bus for matching devices */

  8. if (driver->attach_adapter) {

  9. dev_warn(&adap->dev, "%s: attach_adapter method is deprecated\n",

  10. driver->driver.name);

  11. dev_warn(&adap->dev, "Please use another way to instantiate "

  12. "your i2c_client\n");

  13. /* We ignore the return code; if it fails, too bad */

  14. driver->attach_adapter(adap);

  15. }

  16. return 0;

  17. }

i2c探测:

 
  1. static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver)

  2. {

  3. const unsigned short *address_list;

  4. struct i2c_client *temp_client;

  5. int i, err = 0;

  6. int adap_id = i2c_adapter_id(adapter);

  7.  
  8. address_list = driver->address_list;

  9. if (!driver->detect || !address_list)

  10. return 0;

  11.  
  12. /* Stop here if the classes do not match */

  13. if (!(adapter->class & driver->class))

  14. return 0;

  15.  
  16. /* Set up a temporary client to help detect callback */

  17. temp_client = kzalloc(sizeof(struct i2c_client), GFP_KERNEL);

  18. if (!temp_client)

  19. return -ENOMEM;

  20. temp_client->adapter = adapter;

  21.  
  22. for (i = 0; address_list[i] != I2C_CLIENT_END; i += 1) {

  23. dev_dbg(&adapter->dev, "found normal entry for adapter %d, "

  24. "addr 0x%02x\n", adap_id, address_list[i]);

  25. temp_client->addr = address_list[i];

  26. err = i2c_detect_address(temp_client, driver); //探测地址是否在i2c总线上

  27. if (unlikely(err))

  28. break;

  29. }

  30.  
  31. kfree(temp_client);

  32. return err;

  33. }

 
  1. static int i2c_detect_address(struct i2c_client *temp_client,

  2. struct i2c_driver *driver)

  3. {

  4. struct i2c_board_info info;

  5. struct i2c_adapter *adapter = temp_client->adapter;

  6. int addr = temp_client->addr;

  7. int err;

  8.  
  9. /* Make sure the address is valid */

  10. err = i2c_check_addr_validity(addr);

  11. if (err) {

  12. dev_warn(&adapter->dev, "Invalid probe address 0x%02x\n",

  13. addr);

  14. return err;

  15. }

  16.  
  17. /* Skip if already in use */

  18. if (i2c_check_addr_busy(adapter, addr))

  19. return 0;

  20.  
  21. /* Make sure there is something at this address */

  22. if (!i2c_default_probe(adapter, addr)) //地址匹配,见下面分析!!!

  23. return 0;

  24.  
  25. /* Finally call the custom detection function */

  26. memset(&info, 0, sizeof(struct i2c_board_info));

  27. info.addr = addr;

  28. err = driver->detect(temp_client, &info);

  29. if (err) {

  30. /* -ENODEV is returned if the detection fails. We catch it

  31. here as this isn't an error. */

  32. return err == -ENODEV ? 0 : err;

  33. }

  34.  
  35. /* Consistency check */

  36. if (info.type[0] == '\0') {

  37. dev_err(&adapter->dev, "%s detection function provided "

  38. "no name for 0x%x\n", driver->driver.name,

  39. addr);

  40. } else {

  41. struct i2c_client *client;

  42.  
  43. /* Detection succeeded, instantiate the device */

  44. dev_dbg(&adapter->dev, "Creating %s at 0x%02x\n",

  45. info.type, info.addr);

  46. client = i2c_new_device(adapter, &info);

  47. if (client)

  48. list_add_tail(&client->detected, &driver->clients);

  49. else

  50. dev_err(&adapter->dev, "Failed creating %s at 0x%02x\n",

  51. info.type, info.addr);

  52. }

  53. return 0;

  54. }

 
  1. static int i2c_default_probe(struct i2c_adapter *adap, unsigned short addr)

  2. {

  3. int err;

  4. union i2c_smbus_data dummy;

  5.  
  6. #ifdef CONFIG_X86

  7. if (addr == 0x73 && (adap->class & I2C_CLASS_HWMON)

  8. && i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE_DATA))

  9. err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0,

  10. I2C_SMBUS_BYTE_DATA, &dummy);

  11. else

  12. #endif

  13. if (!((addr & ~0x07) == 0x30 || (addr & ~0x0f) == 0x50)

  14. && i2c_check_functionality(adap, I2C_FUNC_SMBUS_QUICK)) //校验SMBUS是否是快速的

  15. err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_WRITE, 0,

  16. I2C_SMBUS_QUICK, NULL);

  17. else if (i2c_check_functionality(adap, I2C_FUNC_SMBUS_READ_BYTE)) //校验SMBUS是否支持读

  18. err = i2c_smbus_xfer(adap, addr, 0, I2C_SMBUS_READ, 0, //

  19. I2C_SMBUS_BYTE, &dummy);

  20. else {

  21. dev_warn(&adap->dev, "No suitable probing method supported\n");

  22. err = -EOPNOTSUPP;

  23. }

  24.  
  25. return err >= 0;

  26. }

其中i2c_check_functionality(...)函数用来校验i2c的功能,最红调用adap->algo->functionality(...)函数指针,该函数是上面nuc970_i2c0_algorithm结构体定义的:

 
  1. static inline int i2c_check_functionality(struct i2c_adapter *adap, u32 func)

  2. {

  3. return (func & i2c_get_functionality(adap)) == func;

  4. }

 
  1. static inline u32 i2c_get_functionality(struct i2c_adapter *adap)

  2. {

  3. return adap->algo->functionality(adap);

  4. }

这里重点分析i2c_smbus_xfer(...):

 
  1. s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags,

  2. char read_write, u8 command, int protocol,

  3. union i2c_smbus_data *data)

  4. {

  5. unsigned long orig_jiffies;

  6. int try;

  7. s32 res;

  8.  
  9. flags &= I2C_M_TEN | I2C_CLIENT_PEC | I2C_CLIENT_SCCB;

  10.  
  11. if (adapter->algo->smbus_xfer) { //判断适配器是否支持 smbus_xfer,通过前面的介绍,这里是不支持的!

  12. i2c_lock_adapter(adapter);

  13.  
  14. /* Retry automatically on arbitration loss */

  15. orig_jiffies = jiffies;

  16. for (res = 0, try = 0; try <= adapter->retries; try++) {

  17. res = adapter->algo->smbus_xfer(adapter, addr, flags,

  18. read_write, command,

  19. protocol, data);

  20. if (res != -EAGAIN)

  21. break;

  22. if (time_after(jiffies,

  23. orig_jiffies + adapter->timeout))

  24. break;

  25. }

  26. i2c_unlock_adapter(adapter);

  27.  
  28. if (res != -EOPNOTSUPP || !adapter->algo->master_xfer)

  29. return res;

  30. /*

  31. * Fall back to i2c_smbus_xfer_emulated if the adapter doesn't

  32. * implement native support for the SMBus operation.

  33. */

  34. }

  35.  
  36. return i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,

  37. command, protocol, data);

  38. }

由于adapter->algo->smbus_xfer条件不成立,所以这里会调用i2c_smbus_xfer_emulated(...):

 
  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. /* So we need to generate a series of msgs. In the case of writing, we

  7. need to use only one message; when reading, we need two. We initialize

  8. most things with sane defaults, to keep the code below somewhat

  9. simpler. */

  10. unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];

  11. unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];

  12. int num = read_write == I2C_SMBUS_READ ? 2 : 1;

  13. int i;

  14. u8 partial_pec = 0;

  15. int status;

  16. struct i2c_msg msg[2] = {

  17. {

  18. .addr = addr,

  19. .flags = flags,

  20. .len = 1,

  21. .buf = msgbuf0,

  22. }, {

  23. .addr = addr,

  24. .flags = flags | I2C_M_RD,

  25. .len = 0,

  26. .buf = msgbuf1,

  27. },

  28. };

  29.  
  30. msgbuf0[0] = command;

  31. switch (size) {

  32. case I2C_SMBUS_QUICK:

  33. msg[0].len = 0;

  34. /* Special case: The read/write field is used as data */

  35. msg[0].flags = flags | (read_write == I2C_SMBUS_READ ?

  36. I2C_M_RD : 0);

  37. num = 1;

  38. break;

  39. case I2C_SMBUS_BYTE:

  40. if (read_write == I2C_SMBUS_READ) {

  41. /* Special case: only a read! */

  42. msg[0].flags = I2C_M_RD | flags;

  43. num = 1;

  44. }

  45. break;

  46. case I2C_SMBUS_BYTE_DATA:

  47. if (read_write == I2C_SMBUS_READ)

  48. msg[1].len = 1;

  49. else {

  50. msg[0].len = 2;

  51. msgbuf0[1] = data->byte;

  52. }

  53. break;

  54. case I2C_SMBUS_WORD_DATA:

  55. if (read_write == I2C_SMBUS_READ)

  56. msg[1].len = 2;

  57. else {

  58. msg[0].len = 3;

  59. msgbuf0[1] = data->word & 0xff;

  60. msgbuf0[2] = data->word >> 8;

  61. }

  62. break;

  63. case I2C_SMBUS_PROC_CALL:

  64. num = 2; /* Special case */

  65. read_write = I2C_SMBUS_READ;

  66. msg[0].len = 3;

  67. msg[1].len = 2;

  68. msgbuf0[1] = data->word & 0xff;

  69. msgbuf0[2] = data->word >> 8;

  70. break;

  71. case I2C_SMBUS_BLOCK_DATA:

  72. if (read_write == I2C_SMBUS_READ) {

  73. msg[1].flags |= I2C_M_RECV_LEN;

  74. msg[1].len = 1; /* block length will be added by

  75. the underlying bus driver */

  76. } else {

  77. msg[0].len = data->block[0] + 2;

  78. if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {

  79. dev_err(&adapter->dev,

  80. "Invalid block write size %d\n",

  81. data->block[0]);

  82. return -EINVAL;

  83. }

  84. for (i = 1; i < msg[0].len; i++)

  85. msgbuf0[i] = data->block[i-1];

  86. }

  87. break;

  88. case I2C_SMBUS_BLOCK_PROC_CALL:

  89. num = 2; /* Another special case */

  90. read_write = I2C_SMBUS_READ;

  91. if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {

  92. dev_err(&adapter->dev,

  93. "Invalid block write size %d\n",

  94. data->block[0]);

  95. return -EINVAL;

  96. }

  97. msg[0].len = data->block[0] + 2;

  98. for (i = 1; i < msg[0].len; i++)

  99. msgbuf0[i] = data->block[i-1];

  100. msg[1].flags |= I2C_M_RECV_LEN;

  101. msg[1].len = 1; /* block length will be added by

  102. the underlying bus driver */

  103. break;

  104. case I2C_SMBUS_I2C_BLOCK_DATA:

  105. if (read_write == I2C_SMBUS_READ) {

  106. msg[1].len = data->block[0];

  107. } else {

  108. msg[0].len = data->block[0] + 1;

  109. if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {

  110. dev_err(&adapter->dev,

  111. "Invalid block write size %d\n",

  112. data->block[0]);

  113. return -EINVAL;

  114. }

  115. for (i = 1; i <= data->block[0]; i++)

  116. msgbuf0[i] = data->block[i];

  117. }

  118. break;

  119. default:

  120. dev_err(&adapter->dev, "Unsupported transaction %d\n", size);

  121. return -EOPNOTSUPP;

  122. }

  123.  
  124. i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK

  125. && size != I2C_SMBUS_I2C_BLOCK_DATA);

  126. if (i) {

  127. /* Compute PEC if first message is a write */

  128. if (!(msg[0].flags & I2C_M_RD)) {

  129. if (num == 1) /* Write only */

  130. i2c_smbus_add_pec(&msg[0]);

  131. else /* Write followed by read */

  132. partial_pec = i2c_smbus_msg_pec(0, &msg[0]);

  133. }

  134. /* Ask for PEC if last message is a read */

  135. if (msg[num-1].flags & I2C_M_RD)

  136. msg[num-1].len++;

  137. }

  138.  
  139. status = i2c_transfer(adapter, msg, num);

  140. if (status < 0)

  141. return status;

  142.  
  143. /* Check PEC if last message is a read */

  144. if (i && (msg[num-1].flags & I2C_M_RD)) {

  145. status = i2c_smbus_check_pec(partial_pec, &msg[num-1]);

  146. if (status < 0)

  147. return status;

  148. }

  149.  
  150. if (read_write == I2C_SMBUS_READ)

  151. switch (size) {

  152. case I2C_SMBUS_BYTE:

  153. data->byte = msgbuf0[0];

  154. break;

  155. case I2C_SMBUS_BYTE_DATA:

  156. data->byte = msgbuf1[0];

  157. break;

  158. case I2C_SMBUS_WORD_DATA:

  159. case I2C_SMBUS_PROC_CALL:

  160. data->word = msgbuf1[0] | (msgbuf1[1] << 8);

  161. break;

  162. case I2C_SMBUS_I2C_BLOCK_DATA:

  163. for (i = 0; i < data->block[0]; i++)

  164. data->block[i+1] = msgbuf1[i];

  165. break;

  166. case I2C_SMBUS_BLOCK_DATA:

  167. case I2C_SMBUS_BLOCK_PROC_CALL:

  168. for (i = 0; i < msgbuf1[0] + 1; i++)

  169. data->block[i] = msgbuf1[i];

  170. break;

  171. }

  172. return 0;

  173. }

i2c i2c_transfer(...)传输函数:

 
  1. int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)

  2. {

  3. int ret;

  4.  
  5. /* REVISIT the fault reporting model here is weak:

  6. *

  7. * - When we get an error after receiving N bytes from a slave,

  8. * there is no way to report "N".

  9. *

  10. * - When we get a NAK after transmitting N bytes to a slave,

  11. * there is no way to report "N" ... or to let the master

  12. * continue executing the rest of this combined message, if

  13. * that's the appropriate response.

  14. *

  15. * - When for example "num" is two and we successfully complete

  16. * the first message but get an error part way through the

  17. * second, it's unclear whether that should be reported as

  18. * one (discarding status on the second message) or errno

  19. * (discarding status on the first one).

  20. */

  21.  
  22. if (adap->algo->master_xfer) { //通过前面分析,该条件成立

  23. #ifdef DEBUG

  24. for (ret = 0; ret < num; ret++) {

  25. dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "

  26. "len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)

  27. ? 'R' : 'W', msgs[ret].addr, msgs[ret].len,

  28. (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");

  29. }

  30. #endif

  31.  
  32. if (in_atomic() || irqs_disabled()) {

  33. ret = i2c_trylock_adapter(adap);

  34. if (!ret)

  35. /* I2C activity is ongoing. */

  36. return -EAGAIN;

  37. } else {

  38. i2c_lock_adapter(adap);

  39. }

  40.  
  41. ret = __i2c_transfer(adap, msgs, num);

  42. i2c_unlock_adapter(adap);

  43.  
  44. return ret;

  45. } else {

  46. dev_dbg(&adap->dev, "I2C level transfers not supported\n");

  47. return -EOPNOTSUPP;

  48. }

  49. }

 
  1. int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)

  2. {

  3. unsigned long orig_jiffies;

  4. int ret, try;

  5.  
  6. /* Retry automatically on arbitration loss */

  7. orig_jiffies = jiffies;

  8. for (ret = 0, try = 0; try <= adap->retries; try++) {

  9. ret = adap->algo->master_xfer(adap, msgs, num); //

  10. if (ret != -EAGAIN)

  11. break;

  12. if (time_after(jiffies, orig_jiffies + adap->timeout))

  13. break;

  14. }

  15.  
  16. return ret;

  17. }

到这里看到adap->algo->master_xfer(adap, msgs, num)函数指针为适配器结构体nuc970_i2c0_algorithm中成员nuc970_i2c0_xfer,关于该函数内部的实现细节,见前面的分析,至此就分析完了i2c 设备“at24c512”的注册、数据传输!

 

 

6.at24_probe(...)

 
  1. static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id)

  2. {

  3. struct at24_platform_data chip;

  4. bool writable;

  5. int use_smbus = 0;

  6. struct at24_data *at24;

  7. int err;

  8. unsigned i, num_addresses;

  9. kernel_ulong_t magic;

  10.  
  11. if (client->dev.platform_data) {

  12. chip = *(struct at24_platform_data *)client->dev.platform_data;

  13. } else {

  14. if (!id->driver_data) {

  15. err = -ENODEV;

  16. goto err_out;

  17. }

  18. magic = id->driver_data;

  19. chip.byte_len = BIT(magic & AT24_BITMASK(AT24_SIZE_BYTELEN));

  20. magic >>= AT24_SIZE_BYTELEN;

  21. chip.flags = magic & AT24_BITMASK(AT24_SIZE_FLAGS);

  22. /*

  23. * This is slow, but we can't know all eeproms, so we better

  24. * play safe. Specifying custom eeprom-types via platform_data

  25. * is recommended anyhow.

  26. */

  27. chip.page_size = 1;

  28.  
  29. /* update chipdata if OF is present */

  30. at24_get_ofdata(client, &chip);

  31.  
  32. chip.setup = NULL;

  33. chip.context = NULL;

  34. }

  35.  
  36. if (!is_power_of_2(chip.byte_len))

  37. dev_warn(&client->dev,

  38. "byte_len looks suspicious (no power of 2)!\n");

  39. if (!chip.page_size) {

  40. dev_err(&client->dev, "page_size must not be 0!\n");

  41. err = -EINVAL;

  42. goto err_out;

  43. }

  44. if (!is_power_of_2(chip.page_size))

  45. dev_warn(&client->dev,

  46. "page_size looks suspicious (no power of 2)!\n");

  47.  
  48. /* Use I2C operations unless we're stuck with SMBus extensions. */

  49. if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {

  50. if (chip.flags & AT24_FLAG_ADDR16) {

  51. err = -EPFNOSUPPORT;

  52. goto err_out;

  53. }

  54. if (i2c_check_functionality(client->adapter,

  55. I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {

  56. use_smbus = I2C_SMBUS_I2C_BLOCK_DATA;

  57. } else if (i2c_check_functionality(client->adapter,

  58. I2C_FUNC_SMBUS_READ_WORD_DATA)) {

  59. use_smbus = I2C_SMBUS_WORD_DATA;

  60. } else if (i2c_check_functionality(client->adapter,

  61. I2C_FUNC_SMBUS_READ_BYTE_DATA)) {

  62. use_smbus = I2C_SMBUS_BYTE_DATA;

  63. } else {

  64. err = -EPFNOSUPPORT;

  65. goto err_out;

  66. }

  67. }

  68.  
  69. if (chip.flags & AT24_FLAG_TAKE8ADDR)

  70. num_addresses = 8;

  71. else

  72. num_addresses = DIV_ROUND_UP(chip.byte_len,

  73. (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256);

  74.  
  75. at24 = kzalloc(sizeof(struct at24_data) +

  76. num_addresses * sizeof(struct i2c_client *), GFP_KERNEL);

  77. if (!at24) {

  78. err = -ENOMEM;

  79. goto err_out;

  80. }

  81.  
  82. mutex_init(&at24->lock);

  83. at24->use_smbus = use_smbus;

  84. at24->chip = chip;

  85. at24->num_addresses = num_addresses;

  86.  
  87. /*

  88. * Export the EEPROM bytes through sysfs, since that's convenient.

  89. * By default, only root should see the data (maybe passwords etc)

  90. */

  91. sysfs_bin_attr_init(&at24->bin);

  92. at24->bin.attr.name = "eeprom";

  93. at24->bin.attr.mode = chip.flags & AT24_FLAG_IRUGO ? S_IRUGO : S_IRUSR;

  94. at24->bin.read = at24_bin_read;

  95. at24->bin.size = chip.byte_len;

  96.  
  97. at24->macc.read = at24_macc_read;

  98.  
  99. writable = !(chip.flags & AT24_FLAG_READONLY);

  100. if (writable) {

  101. if (!use_smbus || i2c_check_functionality(client->adapter,

  102. I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) {

  103.  
  104. unsigned write_max = chip.page_size;

  105.  
  106. at24->macc.write = at24_macc_write;

  107.  
  108. at24->bin.write = at24_bin_write;

  109. at24->bin.attr.mode |= S_IWUSR;

  110.  
  111. if (write_max > io_limit)

  112. write_max = io_limit;

  113. if (use_smbus && write_max > I2C_SMBUS_BLOCK_MAX)

  114. write_max = I2C_SMBUS_BLOCK_MAX;

  115. at24->write_max = write_max;

  116.  
  117. /* buffer (data + address at the beginning) */

  118. at24->writebuf = kmalloc(write_max + 2, GFP_KERNEL);

  119. if (!at24->writebuf) {

  120. err = -ENOMEM;

  121. goto err_struct;

  122. }

  123. } else {

  124. dev_warn(&client->dev,

  125. "cannot write due to controller restrictions.");

  126. }

  127. }

  128.  
  129. at24->client[0] = client;

  130.  
  131. /* use dummy devices for multiple-address chips */

  132. for (i = 1; i < num_addresses; i++) {

  133. at24->client[i] = i2c_new_dummy(client->adapter,

  134. client->addr + i);

  135. if (!at24->client[i]) {

  136. dev_err(&client->dev, "address 0x%02x unavailable\n",

  137. client->addr + i);

  138. err = -EADDRINUSE;

  139. goto err_clients;

  140. }

  141. }

  142.  
  143. err = sysfs_create_bin_file(&client->dev.kobj, &at24->bin);

  144. if (err)

  145. goto err_clients;

  146.  
  147. i2c_set_clientdata(client, at24);

  148.  
  149. dev_info(&client->dev, "%zu byte %s EEPROM, %s, %u bytes/write\n",

  150. at24->bin.size, client->name,

  151. writable ? "writable" : "read-only", at24->write_max);

  152. if (use_smbus == I2C_SMBUS_WORD_DATA ||

  153. use_smbus == I2C_SMBUS_BYTE_DATA) {

  154. dev_notice(&client->dev, "Falling back to %s reads, "

  155. "performance will suffer\n", use_smbus ==

  156. I2C_SMBUS_WORD_DATA ? "word" : "byte");

  157. }

  158.  
  159. /* export data to kernel code */

  160. if (chip.setup)

  161. chip.setup(&at24->macc, chip.context);

  162.  
  163. return 0;

  164.  
  165. err_clients:

  166. for (i = 1; i < num_addresses; i++)

  167. if (at24->client[i])

  168. i2c_unregister_device(at24->client[i]);

  169.  
  170. kfree(at24->writebuf);

  171. err_struct:

  172. kfree(at24);

  173. err_out:

  174. dev_dbg(&client->dev, "probe error %d\n", err);

  175. return err;

  176. }

 

7.总结

 

①. i2c platfrom_device设备注册;

 

②. i2c板级文件"at24c512"加入到全局链表__i2c_board_list中;

 

③. i2c platform_driver设备驱动注册、总线适配器创建,并且将该设备加入到结构体内核链表bus->p->klist_devices中;

 

④. i2c 设备"at24c512"注册,通过i2c_for_each_dev(...)遍历内核链表bus->p->klist_devices,根据设备名“at24c513”进行匹配,条件成立将进行从设备地址探测,成功将在/dev下创建对应的设备(我原来在调试i2c-rtc驱动时,由于硬件电路        SCLK\SDA出现问题,导致探测失败,结果是没有在/dev下创建设备rtc0设备,所以这也是检验硬件电路的一种方式!)

你可能感兴趣的:(NUC977,Linux)