首页 > 系统服务 > 详细

Linux I2C驱动分析(二)----I2C板级设备扫描和数据传输

时间：2014-03-18 03:21:02      阅读：640      评论：0      收藏：0      [点我收藏+]

一、板级设备扫描

        针对上一篇博客最后的i2c_scan_static_board_info(adap)函数处，首先先看下在系统启动的时候板级设备的注册。

        针对我现在使用的开发板，对于I2C设备注册程序如下：

点击(此处)折叠或打开

  1. static struct i2c_board_info i2c_devices_info[] = {
  2. #ifdef CONFIG_SND_SOC_ALC5623
  3.         {
  4.                 I2C_BOARD_INFO("alc5623", 0x1a),
  5.                 .platform_data = &alc5623_data,
  6.         },
  7. #endif
  8. #ifdef CONFIG_RTC_DRV_DS3231M
  9.         {
  10.                 I2C_BOARD_INFO("ds3231m", 0x68),
  11.                 .platform_data = NULL,
  12.         },
  13. #endif
  14. #ifdef CONFIG_RTC_DRV_PCF8563
  15.         {
  16.                 I2C_BOARD_INFO("pcf8563", 0x51),
  17.                 .platform_data = NULL,
  18.         },
  19. #endif
  20. };
  21. static int __init gsc3280_i2c_devices_init(void)
  22. {
  23.     i2c_register_board_info(0, i2c_devices_info, ARRAY_SIZE(i2c_devices_info));
  24.     return 0;
  25. }
  26. device_initcall(gsc3280_i2c_devices_init);

        在这里总共有三个I2C设备，名称分别为alc5623、ds3231m和pcf8563。宏I2C_BOARD_INFO的功能就是设置I2C设备的名称和地址，由device_initcall可以看出，gsc3280_i2c_devices_init()函数在系统启动的时候就会被调用，i2c_register_board_info()函数完成板级设备的注册，程序如下：

点击(此处)折叠或打开

  1. DECLARE_RWSEM(__i2c_board_lock);
  2. EXPORT_SYMBOL_GPL(__i2c_board_lock);

  4. LIST_HEAD(__i2c_board_list);
  5. EXPORT_SYMBOL_GPL(__i2c_board_list);

  7. int __i2c_first_dynamic_bus_num;
  8. EXPORT_SYMBOL_GPL(__i2c_first_dynamic_bus_num);

  10. int __init
  11. i2c_register_board_info(int busnum,
  12.     struct i2c_board_info const *info, unsigned len)
  13. {
  14.     int status;
  15.     down_write(&__i2c_board_lock);
  16.     /* dynamic bus numbers will be assigned after the last static one */
  17.     if (busnum >= __i2c_first_dynamic_bus_num)
  18.         __i2c_first_dynamic_bus_num = busnum + 1;
  19.     for (status = 0; len; len--, info++) {
  20.         struct i2c_devinfo    *devinfo;
  21.         devinfo = kzalloc(sizeof(*devinfo), GFP_KERNEL);
  22.         if (!devinfo) {
  23.             pr_debug("i2c-core: can‘t register boardinfo!\n");
  24.             status = -ENOMEM;
  25.             break;
  26.         }
  27.         devinfo->busnum = busnum;
  28.         devinfo->board_info = *info;
  29.         list_add_tail(&devinfo->list, &__i2c_board_list);
  30.     }
  31.     up_write(&__i2c_board_lock);
  32.     return status;
  33. }

        上面的程序位于i2c-boardinfo.c中，i2c_register_board_info()函数的for循环中，首先会申请I2C设备信息结构体，如果申请成功，将I2C总线号和设备信息赋值给设备信息结构体，并且将设备信息结构体的链表插入到__i2c_board_list中，此处尤为重要，在本文的开头中所提的函数i2c_scan_static_board_info(adap);，此函数就是通过__i2c_board_list链表找到上面注册的设备信息，结合gsc3280_i2c_devices_init()函数和i2c_devices_info结构体，此处for循环的len为3，即正常情况下需要创建三个devinfo结构体，for循环结束后，__i2c_board_list链表中也就有了三个I2C设备的链表项，在程序的其他地方如果需要使用这里注册的设备结构信息，只需要遍历链表__i2c_board_list，通过总线号即可找到相应的设备信息。

        接下来就可以看下函数i2c_scan_static_board_info(adap)：

点击(此处)折叠或打开

  1. static void i2c_scan_static_board_info(struct i2c_adapter *adapter)
  2. {
  3.     struct i2c_devinfo    *devinfo;
  4.     down_read(&__i2c_board_lock);
  5.     list_for_each_entry(devinfo, &__i2c_board_list, list) {
  6.         if (devinfo->busnum == adapter->nr
  7.                 && !i2c_new_device(adapter,
  8.                         &devinfo->board_info))
  9.             dev_err(&adapter->dev,
  10.                 "Can‘t create device at 0x%02x\n",
  11.                 devinfo->board_info.addr);
  12.     }
  13.     up_read(&__i2c_board_lock);
  14. }

        从上面程序可以看到，语句list_for_each_entry(devinfo, &__i2c_board_list, list) 实现对__i2c_board_list的遍历，if语句的前半部分“devinfo->busnum == adapter->nr”判断是否是需要寻找的结构体，如果是，就调用函数i2c_new_device()创建新的I2C设备，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.     client = kzalloc(sizeof *client, GFP_KERNEL);
  7.     if (!client)
  8.         return NULL;
  9.     client->adapter = adap;
  10.     client->dev.platform_data = info->platform_data;
  11.     if (info->archdata)
  12.         client->dev.archdata = *info->archdata;
  13.     client->flags = info->flags;
  14.     client->addr = info->addr;
  15.     client->irq = info->irq;
  16.     strlcpy(client->name, info->type, sizeof(client->name));
  17.     /* Check for address validity */
  18.     status = i2c_check_client_addr_validity(client);
  19.     if (status) {
  20.         dev_err(&adap->dev, "Invalid %d-bit I2C address 0x%02hx\n",
  21.             client->flags & I2C_CLIENT_TEN ? 10 : 7, client->addr);
  22.         goto out_err_silent;
  23.     }
  24.     /* Check for address business */
  25.     status = i2c_check_addr_busy(adap, client->addr);
  26.     if (status)
  27.         goto out_err;
  28.     client->dev.parent = &client->adapter->dev;
  29.     client->dev.bus = &i2c_bus_type;
  30.     client->dev.type = &i2c_client_type;
  31.     client->dev.of_node = info->of_node;
  32.     dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),
  33.          client->addr);
  34.     status = device_register(&client->dev);
  35.     if (status)
  36.         goto out_err;
  37.     dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n",
  38.         client->name, dev_name(&client->dev));
  39.     return client;
  40. out_err:
  41.     dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x "
  42.         "(%d)\n", client->name, client->addr, status);
  43. out_err_silent:
  44.     kfree(client);
  45.     return NULL;
  46. }
  47. EXPORT_SYMBOL_GPL(i2c_new_device);

        从函数i2c_new_device()中可以看到，此函数创建了i2c_client结构体，对结构体的内容进行了注册，设备信息进行了填充，对于本文所使用的开发板，如果程序执行正常，系统启动成功后，在内存中就有了三个

i2c_client结构体了，分别对应alc5623、ds3231m和pcf8563。

        到此位置，I2C总线驱动，I2C设备的注册和相应结构体的申请就已经完成了，接下来看下常用的I2C数据传输函数，I2C设备驱动主要调用这些数据传输接口完成数据的传输。

二、I2C数据传输

        I2C数据传输分为两种，一种为符合I2C协议的普通数据传输，另外一种为符合SMBUS协议的数据传输，接下来我们首先看下符合I2C协议的普通数据传输。

1、I2C协议的普通数据传输

        I2C协议普通数据传输的接口函数基本为i2c_master_send和i2c_master_recv，查看其函数发现，最后都是调用i2c_transfer函数实现传输的，i2c_transfer函数如下：

点击(此处)折叠或打开

  1. int i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
  2. {
  3.     int ret;
  4.     if (adap->algo->master_xfer) {
  5. #ifdef DEBUG
  6.         for (ret = 0; ret < num; ret++) {
  7.             dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
  8.                 "len=%d%s/n", ret, (msgs[ret].flags & I2C_M_RD)
  9.                 ? ‘R‘ : ‘W‘, msgs[ret].addr, msgs[ret].len,
  10.                 (msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
  11.         }
  12. #endif
  13.         if (in_atomic() || irqs_disabled()) {
  14.             ret = mutex_trylock(&adap->bus_lock);
  15.             if (!ret)
  16.                 /* I2C activity is ongoing. */
  17.                 return -EAGAIN;
  18.         } else {
  19.             mutex_lock_nested(&adap->bus_lock, adap->level);
  20.         }
  21.         ret = adap->algo->master_xfer(adap,msgs,num);
  22.         mutex_unlock(&adap->bus_lock);
  23.         return ret;
  24.     } else {
  25.         dev_dbg(&adap->dev, "I2C level transfers not supported/n");
  26.         return -ENOSYS;
  27.     }
  28. }

        因为在这里的同步用的是mutex。首先判断是否允许睡眠，如果不允许，尝试获锁，如果获锁失败，则返回。这样的操作是避免进入睡眠，我们在后面也可以看到，实际的传输工作交给了adap->algo->master_xfer()完成，也就是我们在（一）中注册的algorithm中的i2c_gsc_func函数。

2、SMBUS协议I2C数据传输

        SMBUS协议的具体内容可以参考网络，在I2C驱动中，符合SMBUS协议传输的函数很多，包括i2c_smbus_read_byte、i2c_smbus_write_byte、i2c_smbus_read_byte_data、i2c_smbus_write_byte_data、i2c_smbus_read_word_data和i2c_smbus_write_word_data等，阅读这些函数发现，程序里面都是根据SMBUS协议和函数功能，完成对函数i2c_smbus_xfer形参的赋值，最后调用此函数来实现传输。接下来看下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.     flags &= I2C_M_TEN | I2C_CLIENT_PEC;
  9.     if (adapter->algo->smbus_xfer) {
  10.         i2c_lock_adapter(adapter);
  11.         /* Retry automatically on arbitration loss */
  12.         orig_jiffies = jiffies;
  13.         for (res = 0, try = 0; try <= adapter->retries; try++) {
  14.             res = adapter->algo->smbus_xfer(adapter, addr, flags,
  15.                             read_write, command,
  16.                             protocol, data);
  17.             if (res != -EAGAIN)
  18.                 break;
  19.             if (time_after(jiffies,
  20.                  orig_jiffies + adapter->timeout))
  21.                 break;
  22.         }
  23.         i2c_unlock_adapter(adapter);
  24.     } else
  25.         res = i2c_smbus_xfer_emulated(adapter, addr, flags, read_write,
  26.                      command, protocol, data);
  27.     return res;
  28. }

          如果adapter有smbus_xfer()函数，则直接调用它发送数据。否则也就是在adapter不支持smbus协议的情况下，调用i2c_smbus_xfer_emulated()继续处理。根据（一）中的总线驱动是不支持smbus协议的。继续看函数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.     //写操作只会进行一次交互，而读操作，有时会有两次操作.
  11.     //因为有时候读操作要先写command，再从总线上读数据
  12.     //在这里为了代码的简洁，使用了两个缓存区，将两种情况统一起来.
  13.     unsigned char msgbuf0[I2C_SMBUS_BLOCK_MAX+3];
  14.     unsigned char msgbuf1[I2C_SMBUS_BLOCK_MAX+2];
  15.     //一般来说，读操作要交互两次，例外的情况我们在下面会接着分析
  16.     int num = read_write == I2C_SMBUS_READ?2:1;
  17.     //与设备交互的数据，一般在msg[0]存放写入设备的信息，在msb[1]里存放接收到的
  18.     //信息，不过也有例外的
  19.     //msg[2]的初始化，默认发送缓存区占一个字节，无接收缓存
  20.     struct i2c_msg msg[2] = { { addr, flags, 1, msgbuf0 },
  21.                               { addr, flags | I2C_M_RD, 0, msgbuf1 }
  22.                             };
  23.     int i;
  24.     u8 partial_pec = 0;
  25.     //将要发送的信息copy到发送缓存区的第一字节
  26.     msgbuf0[0] = command;
  27.     switch(size) {
  28.         //quick类型，它并不传输有效数据,只是将地址写到总线上,等待应答即可
  29.         //所以将发送缓存区长度置为0。再根据读/写操作，调整msg[0]的标志位
  30.         //这类传输只需要一次总线交互
  31.     case I2C_SMBUS_QUICK:
  32.         msg[0].len = 0;
  33.         /* Special case: The read/write field is used as data */
  34.         msg[0].flags = flags | (read_write==I2C_SMBUS_READ)?I2C_M_RD:0;
  35.         num = 1;
  36.         break;
  37.     case I2C_SMBUS_BYTE:
  38.         //BYTE类型指一次写和读只有一个字节.这种情况下,读和写都只会交互一次
  39.         //这种类型的读有例外,它读取出来的数据不是放在msg[1]中的,而是存放在msg[0]
  40.         if (read_write == I2C_SMBUS_READ) {
  41.             /* Special case: only a */
  42.             msg[0].flags = I2C_M_RD | flags;
  43.             num = 1;
  44.         }
  45.         break;
  46.     case I2C_SMBUS_BYTE_DATA:
  47.         //Byte_Data是指命令+数据的传输形式，在这种情况下，写只需要一次交互，读却要两次
  48.         //第一次将command写到总线上，第二次要转换方向，要将设备地址和read标志写入总线.
  49.         //应回答之后再进行read操作
  50.         //写操作占两字节,分别是command+data，读操作的有效数据只有一个字节
  51.         //交互次数用初始化值就可以了
  52.         if (read_write == I2C_SMBUS_READ)
  53.             msg[1].len = 1;
  54.         else {
  55.             msg[0].len = 2;
  56.             msgbuf0[1] = data->byte;
  57.         }
  58.         break;
  59.     case I2C_SMBUS_WORD_DATA:
  60.         //Word_Data是指命令+双字节的形式.这种情况跟Byte_Data的情况类似
  61.         //两者相比只是交互的数据大小不同
  62.         if (read_write == I2C_SMBUS_READ)
  63.             msg[1].len = 2;
  64.         else {
  65.             msg[0].len=3;
  66.             msgbuf0[1] = data->word & 0xff;
  67.             msgbuf0[2] = data->word >> 8;
  68.         }
  69.         break;
  70.     case I2C_SMBUS_PROC_CALL:
  71.         //Proc_Call的方式与write 的Word_Data相似,只不过写完Word_Data之后,要等待它的应答
  72.         //应该它需要交互两次，一次写一次读
  73.         num = 2; /* Special case */
  74.         read_write = I2C_SMBUS_READ;
  75.         msg[0].len = 3;
  76.         msg[1].len = 2;
  77.         msgbuf0[1] = data->word & 0xff;
  78.         msgbuf0[2] = data->word >> 8;
  79.         break;
  80.     case I2C_SMBUS_BLOCK_DATA:
  81.         //Block_Data:指command+N段数据的情况.
  82.         //如果是读操作，它首先要写command到总线，然后再读N段数据，要写的command已经
  83.         //放在msg[0]了，现在只需要将msg[1]的标志置I2C_M_RECV_LEN位，msg[1]有效长度为1字节，因为
  84.         //adapter驱动会处理好的，现在还不知道要传多少段数据.
  85.         //对于写的情况:msg[1]照例不需要.将要写的数据全部都放到msb[0]中.相应的也要更新
  86.         //msg[0]中的缓存区长度
  87.         if (read_write == I2C_SMBUS_READ) {
  88.             msg[1].flags |= I2C_M_RECV_LEN;
  89.             msg[1].len = 1; /* block length will be added by
  90.                       the underlying bus driver */
  91.         } else {
  92.             //data->block[0]表示后面有多少段数据.总长度要加2是因为command+count+N段数据
  93.             msg[0].len = data->block[0] + 2;
  94.             if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 2) {
  95.                 dev_err(&adapter->dev, "smbus_access called with "
  96.                       "invalid block write size (%d)/n",
  97.                       data->block[0]);
  98.                 return -1;
  99.             }
  100.             for (i = 1; i < msg[0].len; i++)
  101.                 msgbuf0 = data->block[i-1];
  102.         }
  103.         break;
  104.     case I2C_SMBUS_BLOCK_PROC_CALL:
  105.         //Proc_Call:表示写完Block_Data之后,要等它的应答消息它和Block_Data相比,只是多了一部份应答而已
  106.         num = 2; /* Another special case */
  107.         read_write = I2C_SMBUS_READ;
  108.         if (data->block[0] > I2C_SMBUS_BLOCK_MAX) {
  109.             dev_err(&adapter->dev, "%s called with invalid "
  110.                 "block proc call size (%d)/n", __func__,
  111.                 data->block[0]);
  112.             return -1;
  113.         }
  114.         msg[0].len = data->block[0] + 2;
  115.         for (i = 1; i < msg[0].len; i++)
  116.             msgbuf0 = data->block[i-1];
  117.         msg[1].flags |= I2C_M_RECV_LEN;
  118.         msg[1].len = 1; /* block length will be added by
  119.                   the underlying bus driver */
  120.         break;
  121.     case I2C_SMBUS_I2C_BLOCK_DATA:
  122.         //I2c Block_Data与Block_Data相似,只不过read的时候,数据长度是预先定义好了的.另外
  123.         //与Block_Data相比,中间不需要传输Count字段.(Count表示数据段数目)
  124.         if (read_write == I2C_SMBUS_READ) {
  125.             msg[1].len = data->block[0];
  126.         } else {
  127.             msg[0].len = data->block[0] + 1;
  128.             if (msg[0].len > I2C_SMBUS_BLOCK_MAX + 1) {
  129.                 dev_err(&adapter->dev, "i2c_smbus_xfer_emulated called with "
  130.                       "invalid block write size (%d)/n",
  131.                       data->block[0]);
  132.                 return -1;
  133.             }
  134.             for (i = 1; i <= data->block[0]; i++)
  135.                 msgbuf0 = data->block;
  136.         }
  137.         break;
  138.     default:
  139.         dev_err(&adapter->dev, "smbus_access called with invalid size (%d)/n",
  140.               size);
  141.         return -1;
  142.     }
  143.     //如果启用了PEC.Quick和I2c Block_Data是不支持PEC的
  144.     i = ((flags & I2C_CLIENT_PEC) && size != I2C_SMBUS_QUICK
  145.                       && size != I2C_SMBUS_I2C_BLOCK_DATA);
  146.     if (i) {
  147.         /* Compute PEC if first message is a write */
  148.         //如果第一个操作是写操作
  149.         if (!(msg[0].flags & I2C_M_RD)) {
  150.             //如果只是写操作
  151.             if (num == 1) /* Write only */
  152.                 //如果只有写操作,写缓存区要扩充一个字节,用来存放计算出来的PEC
  153.                 i2c_smbus_add_pec(&msg[0]);
  154.             else /* Write followed by read */
  155.                 //如果后面还有读操作,先计算前面写部份的PEC(注意这种情况下不需要
  156.                 //扩充写缓存区,因为不需要发送PEC.只会接收到PEC)
  157.                 partial_pec = i2c_smbus_msg_pec(0, &msg[0]);
  158.         }
  159.         /* Ask for PEC if last message is a read */
  160.         //如果最后一次是读消息.还要接收到来自slave的PEC.所以接收缓存区要扩充一个字节
  161.         if (msg[num-1].flags & I2C_M_RD)
  162.             msg[num-1].len++;
  163.     }
  164.     if (i2c_transfer(adapter, msg, num) < 0)
  165.         return -1;
  166.     /* Check PEC if last message is a read */
  167.     //操作完了之后,如果最后一个操作是PEC的读操作.检验后面的PEC是否正确
  168.     if (i && (msg[num-1].flags & I2C_M_RD)) {
  169.         if (i2c_smbus_check_pec(partial_pec, &msg[num-1]) < 0)
  170.             return -1;
  171.     }
  172.     //操作完了,现在可以将数据放到data部份返回了.
  173.     if (read_write == I2C_SMBUS_READ)
  174.         switch(size) {
  175.             case I2C_SMBUS_BYTE:
  176.                 data->byte = msgbuf0[0];
  177.                 break;
  178.             case I2C_SMBUS_BYTE_DATA:
  179.                 data->byte = msgbuf1[0];
  180.                 break;
  181.             case I2C_SMBUS_WORD_DATA:
  182.             case I2C_SMBUS_PROC_CALL:
  183.                 data->word = msgbuf1[0] | (msgbuf1[1] << 8);
  184.                 break;
  185.             case I2C_SMBUS_I2C_BLOCK_DATA:
  186.                 for (i = 0; i < data->block[0]; i++)
  187.                     data->block[i+1] = msgbuf1;
  188.                 break;
  189.             case I2C_SMBUS_BLOCK_DATA:
  190.             case I2C_SMBUS_BLOCK_PROC_CALL:
  191.                 for (i = 0; i < msgbuf1[0] + 1; i++)
  192.                     data->block = msgbuf1;
  193.                 break;
  194.         }
  195.     return 0;
  196. }
        此处也是调用i2c_transfer函数实现数据的最终传输的，在上面已经讲述了此函数。

Linux I2C驱动分析(二)----I2C板级设备扫描和数据传输,布布扣,bubuko.com

Linux I2C驱动分析(二)----I2C板级设备扫描和数据传输

原文：http://blog.csdn.net/apple_guet/article/details/21379501
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
分享档案
更多>
2021年09月23日 (328)
2021年09月24日 (313)
2021年09月17日 (191)
2021年09月15日 (369)
2021年09月16日 (411)
2021年09月13日 (439)
2021年09月11日 (398)
2021年09月12日 (393)
2021年09月10日 (160)
2021年09月08日 (222)
最新文章
更多>
教程昨日排行
更多>
友情链接
汇智网   PHP教程   插件网  
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣，分享程序人生！