I2C驱动的框架实现分析

前面讲了一下I2C的基本概念以及一个怎么去运用它的一个流程，但是没有做具体的分析，这篇博客转自http://m.blog.csdn.net/Guet_Kite/article/details/77870905，写得很明了，于是忍不住就转载啦。

首先这张图片很好的说明了我们内核的I2C驱动的一个框架，现在从上到下看起，先看我们的平台文件：mach-smdk2440.c，这里内核为3.0.54版本。

static struct platform_device *smdk2440_devices[] __initdata = {
     &s3c_device_ohci,
     &s3c_device_lcd,
     &s3c_device_wdt,
     &s3c_device_i2c0,
     &s3c_device_iis,
     &s3c_device_dm9000,
     &s3c_device_adc,
     &s3c_device_ts,
     &uda1340_codec,
     &s3c24xx_uda134x,
     &samsung_asoc_dma,
     &s3c_device_timer,
     &smdk2440_beeper_device,
     &s3c_device_rtc,
     &s3c_device_usbgadget,
     &s3c_device_sdi,
 };

static void __init smdk2440_map_io(void)
 {
     s3c24xx_init_io(smdk2440_iodesc, ARRAY_SIZE(smdk2440_iodesc));
     s3c24xx_init_clocks(12000000);
     s3c24xx_init_uarts(smdk2440_uartcfgs, ARRAY_SIZE(smdk2440_uartcfgs));
     usb_s3c2440_init();
 }

static void __init smdk2440_machine_init(void)
 {
     s3c24xx_fb_set_platdata(&smdk2440_fb_info);
     s3c_i2c0_set_platdata(NULL);
     s3c24xx_ts_set_platdata(&smdk2440_ts_cfg);
     gpio_request(S3C2410_GPB(0),"beeper");
     s3c_gpio_setpull(S3C2410_GPB(0), S3C_GPIO_PULL_NONE);
     s3c_gpio_cfgpin(S3C2410_GPB(0), S3C2410_GPB0_TOUT0);
     i2c_register_board_info(0, smdk2440_i2c_devs, ARRAY_SIZE(smdk2440_i2c_devs));
     platform_add_devices(smdk2440_devices, ARRAY_SIZE(smdk2440_devices));
     smdk_machine_init();
     s3c24xx_udc_set_platdata(&s3c_udc_cfg);
 }

在smdk2440_map_io函数里面，调用了s3c24xx_init_io函数：

void __init s3c24xx_init_io(struct map_desc *mach_desc, int size)
 {
     unsigned long idcode = 0x0;

     /* initialise the io descriptors we need for initialisation */
     iotable_init(mach_desc, size);
     iotable_init(s3c_iodesc, ARRAY_SIZE(s3c_iodesc));

     if (cpu_architecture() >= CPU_ARCH_ARMv5) {
         idcode = s3c24xx_read_idcode_v5();
     } else {
         idcode = s3c24xx_read_idcode_v4();
     }

     arm_pm_restart = s3c24xx_pm_restart;

     s3c_init_cpu(idcode, cpu_ids, ARRAY_SIZE(cpu_ids));
 }   

其中s3c_init_cpu的第二个参数cpu_ids在：

static struct cpu_table cpu_ids[] __initdata = {
      {
          .idcode     = 0x32440000,
          .idmask     = 0xffffffff,
          .map_io     = s3c2440_map_io,
          .init_clocks    = s3c244x_init_clocks,
          .init_uarts = s3c244x_init_uarts,
          .init       = s3c2440_init,
          .name       = name_s3c2440
      },
         ................
}

因为我们的板子是2440的，因此就截取了这个字段。然后继续追踪s3c_init_cpu函数：

void __init s3c_init_cpu(unsigned long idcode,
               struct cpu_table *cputab, unsigned int cputab_size)
  {       
      cpu = s3c_lookup_cpu(idcode, cputab, cputab_size);

      if (cpu == NULL) {
          printk(KERN_ERR "Unknown CPU type 0x%08lx\n", idcode);
          panic("Unknown S3C24XX CPU");
      }

      printk("CPU %s (id 0x%08lx)\n", cpu->name, idcode);

      if (cpu->map_io == NULL || cpu->init == NULL) {
          printk(KERN_ERR "CPU %s support not enabled\n", cpu->name);
          panic("Unsupported Samsung CPU");
      }

      cpu->map_io();
  }       

可以看见最后一行调用了map_io函数，就是前面的s3c2440_map_io函数。这里在刚才的cpu_table结构体中说明的。

void __init s3c2440_map_io(void)
  {       
      s3c244x_map_io(); 

      s3c24xx_gpiocfg_default.set_pull = s3c_gpio_setpull_1up;
      s3c24xx_gpiocfg_default.get_pull = s3c_gpio_getpull_1up;
  }  

自然进入s3c24x_map_io函数：

void __init s3c244x_map_io(void)
  {   
      /* register our io-tables */

      iotable_init(s3c244x_iodesc, ARRAY_SIZE(s3c244x_iodesc));

      /* rename any peripherals used differing from the s3c2410 */

      s3c_device_sdi.name  = "s3c2440-sdi";
      s3c_device_i2c0.name  = "s3c2440-i2c";
      s3c_nand_setname("s3c2440-nand");
      s3c_device_ts.name = "s3c2440-ts";
      s3c_device_usbgadget.name = "s3c2440-usbgadget";
  }   

最终在这里将s3c_device_i2c0结构体的名字改为了s3c2440-i2c，然后回到我们的平台文件mach-smdk2440.c文件中，进入smdk2440_machine_init函数，这里通过s3c_i2c0_set_platdata函数，设置default_i2c_data结构体的bus_num为0，以及设置i2c的IO口，npd->cfg_gpio = s3c_i2c0_cfg_gpio，接着就调用paltform_add_devices(smdk2440_devices, ARRAY_SIZE(smdk2440_devices))，在platform平台下进行设备注册，设备名字为“s3c2440-i2c”

void __init s3c_i2c0_set_platdata(struct s3c2410_platform_i2c *pd)
  {
      struct s3c2410_platform_i2c *npd;

      if (!pd) 
          pd = &default_i2c_data0;

      npd = kmemdup(pd, sizeof(struct s3c2410_platform_i2c), GFP_KERNEL);
      if (!npd)
          printk(KERN_ERR "%s: no memory for platform data\n", __func__);
      else if (!npd->cfg_gpio) 
          npd->cfg_gpio = s3c_i2c0_cfg_gpio;

      s3c_device_i2c0.dev.platform_data = npd;
  }   

到这里，平台设备已经注册完毕，接下来就是驱动咯：i2c-s3c2410.c

static struct platform_device_id s3c24xx_driver_ids[] = {
     {
         .name       = "s3c2410-i2c",
         .driver_data    = TYPE_S3C2410,
     }, {
         .name       = "s3c2440-i2c",
         .driver_data    = TYPE_S3C2440,
     }, { },
 };
 MODULE_DEVICE_TABLE(platform, s3c24xx_driver_ids);

 static struct platform_driver s3c24xx_i2c_driver = {
     .probe      = s3c24xx_i2c_probe,
     .remove     = s3c24xx_i2c_remove,
    .id_table   = s3c24xx_driver_ids,
     .driver     = {
         .owner  = THIS_MODULE,
         .name   = "s3c-i2c",
         .pm = S3C24XX_DEV_PM_OPS,
     },
 };

static int __init i2c_adap_s3c_init(void)
 {
     return platform_driver_register(&s3c24xx_i2c_driver);
 }

然后可以看见我们的名字“s3c2440-i2c”，和上面的设备匹配成功，调用probe函数：

static int s3c24xx_i2c_probe(struct platform_device *pdev)
{
    ....................
    strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));
      i2c->adap.owner   = THIS_MODULE;
      i2c->adap.algo    = &s3c24xx_i2c_algorithm;
      i2c->adap.retries = 2;
      i2c->adap.class   = I2C_CLASS_HWMON | I2C_CLASS_SPD;
      i2c->tx_setup     = 50;
      .................
      ret = i2c_add_numbered_adapter(&i2c->adap);
}

因为代码太长，这里给出部分重要信息代码。

i2c->adap.algo = &s3c24xx_i2c_algorithm;

其中：

static const struct i2c_algorithm s3c24xx_i2c_algorithm = {
      .master_xfer        = s3c24xx_i2c_xfer,
      .functionality      = s3c24xx_i2c_func,
  };

正如开始的图，i2c_adapter和i2c_algorithm都是操作i2c_bus的结构体，前者定义一个i2c模块，后者顶一个操作模块的方法，或者前者对应于物理上的一个适配器，而后者对应一套通信方法。

i2c_algorithm是i2c的底层实现函数，已封装，.master_xfer用于I2C总线传输，传送给它的i2c_msg数组中每个I2C消息，.functionality用于返回algorithm所支持的通信协议，如I2C_FUNC_I2C、I2C_FUNC_10BIT_ADDR、I2C_FUNC_SMBUS_READ_BYTE、I2C_FUNC_SMBUS_WRITE等。

ret=i2c_add_numbered_adapter(&i2c->ddap);

int i2c_add_numbered_adapter(struct i2c_adapter *adap)
  {       
     int id;
      int status;

      if (adap->nr & ~MAX_ID_MASK)
          return -EINVAL;

  retry:
      if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)
          return -ENOMEM;

      mutex_lock(&core_lock);
      /* "above" here means "above or equal to", sigh;
       * we need the "equal to" result to force the result
       */
      status = idr_get_new_above(&i2c_adapter_idr, adap, adap->nr, &id);
      if (status == 0 && id != adap->nr) {
          status = -EBUSY;
          idr_remove(&i2c_adapter_idr, id);
      }
      mutex_unlock(&core_lock);
      if (status == -EAGAIN)
          goto retry;

      if (status == 0)
          status = i2c_register_adapter(adap);
      return status;
  }

可以看见最后调用i2c_register_adapter(adap)函数，在i2c_bus总线上进行注册，名字为dev_set_name(&adap->dev, “i2c-%d”, adap->nr); 再说下i2c_adapter与i2c_client的关系：

i2c_client依附于i2c_adapter，由于一个适配器上可以连接多个I2C设备，所以一个i2c_adapter也可以被多个i2c_client依附，i2c_adapter中包含依附于它的i2c_client的链表。

i2c的框架就到这里，下面以我们的eeprom为例看下i2c的实现：

static struct i2c_driver at24_driver = {
     .driver = {
         .name = "at24",
         .owner = THIS_MODULE,
     },
     .probe = at24_probe,
     .remove = __devexit_p(at24_remove),
    .id_table = at24_ids,
 };

 static int __init at24_init(void)
 {
     if (!io_limit) {
         pr_err("at24: io_limit must not be 0!\n")
         return -EINVAL;
     }

     io_limit = rounddown_pow_of_two(io_limit);
     return i2c_add_driver(&at24_driver);
 }

这里调用i2c_add_driver函数在i2c_bus总线下注册，然后看下他的读写函数，

static ssize_t at24_eeprom_read(struct at24_data *at24, char *buf,
         unsigned offset, size_t count)
 {
     struct i2c_msg msg[2];
     u8 msgbuf[2];
     struct i2c_client *client;
     unsigned long timeout, read_time;
     int status, i;

     memset(msg, 0, sizeof(msg));
     client = at24_translate_offset(at24, &offset);

     if (count > io_limit)
         count = io_limit;

     switch (at24->use_smbus) {
     case I2C_SMBUS_I2C_BLOCK_DATA:
        /* Smaller eeproms can work given some SMBus extension calls */
         if (count > I2C_SMBUS_BLOCK_MAX)
             count = I2C_SMBUS_BLOCK_MAX;
         break;
     case I2C_SMBUS_WORD_DATA:
         count = 2;
         break;
     case I2C_SMBUS_BYTE_DATA:
         count = 1;
         break
     default:
     i = 0;
         if (at24->chip.flags & AT24_FLAG_ADDR16)
             msgbuf[i++] = offset >> 8;
         msgbuf[i++] = offset;

         msg[0].addr = client->addr;
         msg[0].buf = msgbuf;
         msg[0].len = i;

         msg[1].addr = client->addr;
         msg[1].flags = I2C_M_RD;
         msg[1].buf = buf;
         msg[1].len = count
     }
     timeout = jiffies + msecs_to_jiffies(write_timeout);
     do {
         read_time = jiffies;
         switch (at24->use_smbus) {  
            case I2C_SMBUS_I2C_BLOCK_DATA:
             status = i2c_smbus_read_i2c_block_data(client, offset,
                     count, buf);
             break;
         case I2C_SMBUS_WORD_DATA:
             status = i2c_smbus_read_word_data(client, offset);
             if (status >= 0) {
                 buf[0] = status & 0xff;
                buf[1] = status >> 8;
                 status = count;
             }
             break;
         case I2C_SMBUS_BYTE_DATA:
             status = i2c_smbus_read_byte_data(client, offset);
             if (status >= 0) {
                 buf[0] = status;
                 status = count;
             }
            break;
         default:
         status = i2c_transfer(client->adapter, msg, 2);
             if (status == 2)
                 status = count;
         }
         dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n",
                 count, offset, status, jiffies);

         if (status == count)
             return count;

         /* REVISIT: at HZ=100, this is sloooow */
         msleep(1);
     } while (time_before(read_time, timeout));

     return -ETIMEDOUT;
 }

这里面调用i2c_transfer函数，里面以i2c_msg为单位通信：代码就不搬上来了这里就是ret=adap->algo->master_xfer(adap, msgs, num); 这个就是前面的.master_xfer函数，实现i2c总线传输函数。