本文共 19391 字，大约阅读时间需要 64 分钟。
i2c设备是非常普遍的一种设备，我们现在开始i2c子系统的分析。 我们先从注册开始： static const struct i2c_device_id IT7260_ts_id[] = { { IT7260_I2C_NAME, 0 }, { } }; static struct i2c_driver IT7260_ts_driver = { .probe = IT7260_ts_probe, .remove = IT7260_ts_remove, #ifdef CONFIG_PM .resume = IT7260_ts_resume, .suspend = IT7260_ts_suspend, #endif .id_table = IT7260_ts_id, .driver = { .name = "IT7260-ts", }, }; i2c_add_driver(&IT7260_ts_driver)我们看这是典型的具体i2c添加驱动实例。 static inline int i2c_add_driver(struct i2c_driver *driver) { return i2c_register_driver(THIS_MODULE, driver); } 转而i2c_register_driver(THIS_MODULE, driver)： int i2c_register_driver(struct module *owner, struct i2c_driver *driver) { int res; /* Can't register until after driver model init */ if (unlikely(WARN_ON(!i2c_bus_type.p))) return -EAGAIN; /* add the driver to the list of i2c drivers in the driver core */ driver->driver.owner = owner; driver->driver.bus = &i2c_bus_type; /* When registration returns, the driver core * will have called probe() for all matching-but-unbound devices. */ res = driver_register(&driver->driver);//这个我们在driver_register中分析过了,它会去匹配总线(这里就是i2c了)上的的所有设备的client,如果找到,则执行bus的probe函数,我们下面去看下bus的probe函数 if (res) return res; pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name); INIT_LIST_HEAD(&driver->clients);//初始化clients列表 /* Walk the adapters that are already present */ mutex_lock(&core_lock); class_for_each_device(&i2c_adapter_class, NULL, driver, __attach_adapter);//对i2c_adapter_class下的每个设备都进行匹配 mutex_unlock(&core_lock); return 0; } 我们看下__attach_adapter： static int __attach_adapter(struct device *dev, void *data) { struct i2c_adapter *adapter = to_i2c_adapter(dev); struct i2c_driver *driver = data; i2c_detect(adapter, driver); /* Legacy drivers scan i2c busses directly */ if (driver->attach_adapter)//没有定义 driver->attach_adapter(adapter); return 0; } 转到i2c_detect(adapter, driver)： static int i2c_detect(struct i2c_adapter *adapter, struct i2c_driver *driver) { const struct i2c_client_address_data *address_data; struct i2c_client *temp_client; int i, err = 0; int adap_id = i2c_adapter_id(adapter);//总线序号 address_data = driver->address_data; if (!driver->detect || !address_data)//我们系统中这两个都为null，故在这里就返回了 return 0; ...... } 可以看出__attach_adapter没有做具体的工作对于i2c。 我们回到i2c_register_driver看driver_register(&driver->driver)，它去匹配设备的client，匹配上后会执行bus的probe函数，我们看下i2c_bus的probe： struct bus_type i2c_bus_type = { .name = "i2c", .dev_attrs = i2c_dev_attrs, .match = i2c_device_match, .uevent = i2c_device_uevent, .probe = i2c_device_probe, .remove = i2c_device_remove, .shutdown = i2c_device_shutdown, .suspend = i2c_device_suspend, .resume = i2c_device_resume, }; 这里我们先看下bus的match函数，因为driver_register这个寻找设备的时候会执行bus的match函数： static int i2c_device_match(struct device *dev, struct device_driver *drv) { struct i2c_client *client = to_i2c_client(dev); struct i2c_driver *driver = to_i2c_driver(drv); /* match on an id table if there is one */ if (driver->id_table) return i2c_match_id(driver->id_table, client) != NULL;//只匹配id的名字和client的名字,跟驱动的名字没有关系,注意这里的client是设备转换过来,而不是设备的本身！！！ return 0; } 转而调用i2c_match_id(); static const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id, const struct i2c_client *client) { while (id->name[0]) { if (strcmp(client->name, id->name) == 0) //匹配设备client名字和id_table中的名字 return id; id++; } return NULL; } 所以i2c总线根据设备client名字和id_table中的名字进行匹配的。如果匹配了，则返回id值。然后会执行bus的probe函数，对应了i2c_device_probe： static int i2c_device_probe(struct device *dev) { struct i2c_client *client = to_i2c_client(dev); struct i2c_driver *driver = to_i2c_driver(dev->driver); int status; if (!driver->probe || !driver->id_table)//i2c driver这两个是必须要定义的 return -ENODEV; client->driver = driver;//赋值给client if (!device_can_wakeup(&client->dev)) device_init_wakeup(&client->dev, client->flags & I2C_CLIENT_WAKE); dev_dbg(dev, "probe\n"); status = driver->probe(client, i2c_match_id(driver->id_table, client));//执行i2c的driver的probe函数，这个就是开头具体驱动中的probe(如IT7260_ts_probe) if (status) client->driver = NULL; return status; } 那这里我们看到了i2c驱动怎么执行的了。 至此，我们只看了i2c driver的注册分析，那i2c device呢？ 我们到平台文件里面可以看到这样的代码： static struct i2c_board_info mxc_i2c0_board_info[] __initdata = { ...... { .type = "IT7260", .addr = 0x46, .irq = IOMUX_TO_IRQ_V3(F101_TP_INT), .platform_data = &it7260_data, }, ...... }; i2c_register_board_info(0, mxc_i2c0_board_info, ARRAY_SIZE(mxc_i2c0_board_info)); 这是具体i2c驱动设备的信息注册，我们看下定义： int __init i2c_register_board_info(int busnum,//这个busnum就是i2c的序号 struct i2c_board_info const *info, unsigned len)//len表示有几个info，也就是有i2c上挂几个外设 { int status; down_write(&__i2c_board_lock);//i2c core的读写锁 /* dynamic bus numbers will be assigned after the last static one */ if (busnum >= __i2c_first_dynamic_bus_num) __i2c_first_dynamic_bus_num = busnum + 1;//比最大的busnum大1 for (status = 0; len; len--, info++) { struct i2c_devinfo *devinfo; devinfo = kzalloc(sizeof(*devinfo), GFP_KERNEL); if (!devinfo) { pr_debug("i2c-core: can't register boardinfo!\n"); status = -ENOMEM; break; } devinfo->busnum = busnum;//该外设所挂的i2c号 devinfo->board_info = *info;//该外设的基本信息(如名字,地址,私有数据等) list_add_tail(&devinfo->list, &__i2c_board_list);//这里__i2c_board_list是一个全局变量,记录着所有i2c外设的信息,然后adapter注册的时候会使用这个列表，所以这个函数要放在adapter注册之前 } up_write(&__i2c_board_lock); return status; } 这个函数主要就是将i2c驱动设备信息整理到__i2c_board_list列表里面。那这个信息列表什么时候用呢？别忘了，我们还有一个没分析，就是cpu自身的i2c控制器。它是怎么注册的呢？怎么跟具体的i2c驱动联系起来的呢？下面我们就看下i2c控制器的驱动。 static struct platform_driver mxci2c_driver = {//我们在tty分析中已经分析过platform注册过程了，它是先匹配id_table中的名字，然后在匹配driver的名字，有一个匹配即可 .driver = { .name = "mxc_i2c", .owner = THIS_MODULE, }, .probe = mxci2c_probe, .remove = mxci2c_remove, .suspend_late = mxci2c_suspend, .resume_early = mxci2c_resume, }; 这就是这个平台的i2c控制器驱动结构定义。 static int __init mxc_i2c_init(void) { /* Register the device driver structure. */ return platform_driver_register(&mxci2c_driver); } 我们看到在init函数里面有对它的注册，platform总线以前就分析过了，相信大家不陌生了。它注册的时候会先按照id_table去找设备，然后按驱动名字去找。这里没id_table，那就按驱动名字去找了，我们可以看到平台设备定义下有这样的定义： struct platform_device mxci2c_devices[] = { { .name = "mxc_i2c", .id = 0, .num_resources = ARRAY_SIZE(mxci2c1_resources), .resource = mxci2c1_resources, }, { .name = "mxc_i2c", .id = 1, .num_resources = ARRAY_SIZE(mxci2c2_resources), .resource = mxci2c2_resources, }, { .name = "mxc_i2c", .id = 2, .num_resources = ARRAY_SIZE(mxci2c3_resources), .resource = mxci2c3_resources, }, }; 同样还有这样的注册设备的代码： mxc_register_device(&mxci2c_devices[0], &mxci2c_data); mxc_register_device(&mxci2c_devices[1], &mxci2c_data); 这样，mxci2c就可以顺利注册了。注册成功后，会调用paltform总线的probe,最终会执行driver的probe。我们看到mxci2c_driver的probe对应为： static int mxci2c_probe(struct platform_device *pdev) { mxc_i2c_device *mxc_i2c; struct mxc_i2c_platform_data *i2c_plat_data = pdev->dev.platform_data;//在dev注册的时候有赋值 struct resource *res; int id = pdev->id; u32 clk_freq; int ret = 0; int i; mxc_i2c = kzalloc(sizeof(mxc_i2c_device), GFP_KERNEL); if (!mxc_i2c) { return -ENOMEM; } res = platform_get_resource(pdev, IORESOURCE_MEM, 0); if (res == NULL) { ret = -ENODEV; goto err1; } mxc_i2c->membase = ioremap(res->start, res->end - res->start + 1); /* * Request the I2C interrupt */ mxc_i2c->irq = platform_get_irq(pdev, 0); if (mxc_i2c->irq < 0) { ret = mxc_i2c->irq; goto err2; } ret = request_irq(mxc_i2c->irq, mxc_i2c_handler, 0, pdev->name, mxc_i2c); if (ret < 0) { goto err2; } init_waitqueue_head(&mxc_i2c->wq); mxc_i2c->low_power = false; gpio_i2c_active(id); mxc_i2c->clk = clk_get(&pdev->dev, "i2c_clk"); clk_freq = clk_get_rate(mxc_i2c->clk); mxc_i2c->clkdiv = -1; if (i2c_plat_data->i2c_clk) { /* Calculate divider and round up any fractional part */ int div = (clk_freq + i2c_plat_data->i2c_clk - 1) / i2c_plat_data->i2c_clk; for (i = 0; i2c_clk_table[i].div != 0; i++) { if (i2c_clk_table[i].div >= div) { mxc_i2c->clkdiv = i2c_clk_table[i].reg_value; break; } } } if (mxc_i2c->clkdiv == -1) { i--; mxc_i2c->clkdiv = 0x1F; /* Use max divider */ } dev_dbg(&pdev->dev, "i2c speed is %d/%d = %d bps, reg val = 0x%02X\n", clk_freq, i2c_clk_table[i].div, clk_freq / i2c_clk_table[i].div, mxc_i2c->clkdiv); /* * Set the adapter information */ strlcpy(mxc_i2c->adap.name, pdev->name, 48);//adapter名字最长是48 mxc_i2c->adap.id = mxc_i2c->adap.nr = id;//总线编号 mxc_i2c->adap.algo = &mxc_i2c_algorithm;//向adapter赋值i2c_algorithm结构,后面传输函数分析会用到 mxc_i2c->adap.timeout = 1; platform_set_drvdata(pdev, mxc_i2c); i2c_set_adapdata(&mxc_i2c->adap, mxc_i2c);//从设备定义那边获得的数据保存起来 if ((ret = i2c_add_numbered_adapter(&mxc_i2c->adap)) < 0) {//为每条i2c注册一个adapter goto err3; } printk(KERN_INFO "MXC I2C driver\n"); return 0; err3: free_irq(mxc_i2c->irq, mxc_i2c); gpio_i2c_inactive(id); err2: iounmap(mxc_i2c->membase); err1: dev_err(&pdev->dev, "failed to probe i2c adapter\n"); kfree(mxc_i2c); return ret; } 在初始化了mxc_i2c结构体后会执行i2c_add_numbered_adapter(&mxc_i2c->adap)： int i2c_add_numbered_adapter(struct i2c_adapter *adap) { int id; int status; if (adap->nr & ~MAX_ID_MASK) return -EINVAL; //idr机制我们这里不去深究,知道意思就行了,也就是将整数ID号和特定指针关联在一起的机制,这样很方便查找，查找到id也就查找到对应的指针了 retry: if (idr_pre_get(&i2c_adapter_idr, GFP_KERNEL) == 0)//为i2c的idr准备空间 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);//根据adap->nr申请id号,将id和adap关联起来 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);//注册adapter return status; } 转到i2c_register_adapter(adap)： static int i2c_register_adapter(struct i2c_adapter *adap) { int res = 0, dummy; /* Can't register until after driver model init */ if (unlikely(WARN_ON(!i2c_bus_type.p))) { res = -EAGAIN; goto out_list; } mutex_init(&adap->bus_lock); /* Set default timeout to 1 second if not already set */ if (adap->timeout == 0)//mxc_i2c中设为1，即1个jiffies adap->timeout = HZ; dev_set_name(&adap->dev, "i2c-%d", adap->nr);//形如i2c-0，i2c-1等 adap->dev.release = &i2c_adapter_dev_release; adap->dev.class = &i2c_adapter_class; res = device_register(&adap->dev);//在device_register中已分析，这里是将adapter注册到/sys/系统中,属于i2c-adapter类，在/sys/class/i2c-adapter/下注册具体的adapter，如i2c-0，i2c-1等，同时键一些属性文件 if (res) goto out_list; dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name); /* create pre-declared device nodes */ if (adap->nr < __i2c_first_dynamic_bus_num)//__i2c_first_dynamic_bus_num总比i2c总数目大1 i2c_scan_static_board_info(adap); /* Notify drivers */ mutex_lock(&core_lock); dummy = bus_for_each_drv(&i2c_bus_type, NULL, adap, i2c_do_add_adapter); //对bus上注册的驱动执行该函数 mutex_unlock(&core_lock); return 0; out_list: mutex_lock(&core_lock); idr_remove(&i2c_adapter_idr, adap->nr); mutex_unlock(&core_lock); return res; } 好，我们看下i2c_scan_static_board_info(adap)： static void i2c_scan_static_board_info(struct i2c_adapter *adapter) { struct i2c_devinfo *devinfo; down_read(&__i2c_board_lock); list_for_each_entry(devinfo, &__i2c_board_list, list) {//__i2c_board_list是所有i2c外设组成的列表,所以这个列表必须在这之前准备好 if (devinfo->busnum == adapter->nr //匹配总线序号 && !i2c_new_device(adapter,//在该总线上添加外设 &devinfo->board_info)) dev_err(&adapter->dev, "Can't create device at 0x%02x\n", devinfo->board_info.addr); } up_read(&__i2c_board_lock); } __i2c_board_list？！想起来了吧，就上面注册的所有i2c驱动设备信息列表。这里将按照设备所属的i2c总线，然后添加到对应的i2c上，我们下面看下i2c_new_device(adapter, &devinfo->board_info)： struct i2c_client * i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info) { struct i2c_client *client; int status; //client是一个很重要的结构，它联系了adapter，driver，dev，在i2c架构中起到纽带作用 client = kzalloc(sizeof *client, GFP_KERNEL); if (!client) return NULL; client->adapter = adap; //赋值给client，驱动会通过client使用adapter之前开始时初始化的变量，包括i2c_algorithm client->dev.platform_data = info->platform_data; if (info->archdata) client->dev.archdata = *info->archdata; client->flags = info->flags; client->addr = info->addr; client->irq = info->irq; strlcpy(client->name, info->type, sizeof(client->name)); //上面主要是对client初始化 /* Check for address business */ status = i2c_check_addr(adap, client->addr);//检查这个地址是否已经有其它外设在使用了 if (status) goto out_err; client->dev.parent = &client->adapter->dev; client->dev.bus = &i2c_bus_type; client->dev.release = i2c_client_dev_release; dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),//可以知道client名字为总线号加地址 client->addr); status = device_register(&client->dev);//注册client的dev到i2c bus下的device列表 if (status) goto out_err; dev_dbg(&adap->dev, "client [%s] registered with bus id %s\n", client->name, dev_name(&client->dev)); return client; out_err: dev_err(&adap->dev, "Failed to register i2c client %s at 0x%02x " "(%d)\n", client->name, client->addr, status); kfree(client); return NULL; } 这样我们的设备和驱动就可以联系起来了。我们下面在看一下i2c_register_adapter中的i2c_do_add_adapter： static int i2c_do_add_adapter(struct device_driver *d, void *data) { struct i2c_driver *driver = to_i2c_driver(d); struct i2c_adapter *adap = data; /* Detect supported devices on that bus, and instantiate them */ i2c_detect(adap, driver); /* Let legacy drivers scan this bus for matching devices */ if (driver->attach_adapter) {//driver没有定义 /* We ignore the return code; if it fails, too bad */ driver->attach_adapter(adap); } return 0; } 跟上面的__attach_adapter一样呢！没什么具体作用的。仔细想想也是有道理的，i2c驱动已经可以通过client访问adapter了，所以驱动再去匹配adapter是多此一举。可能有的驱动通过其它方式注册的，是需要匹配adapter的，这个另当别论吧。 我们下面开始分析i2c的通信，即读写过程。
我们先看读函数，对应i2c core中的i2c_master_recv：
int i2c_master_recv(struct i2c_client *client, char *buf ,int count)
{
struct i2c_adapter *adap=client->adapter;//通过client访问adapter
struct i2c_msg msg;//i2c传输的单位
int ret;
msg.addr = client->addr;
msg.flags = client->flags & I2C_M_TEN;
msg.flags |= I2C_M_RD;//读标记，如果没有就是写
msg.len = count;//数据字节数
msg.buf = buf;//数据保存的地方
ret = i2c_transfer(adap, &msg, 1);//传输1个msg
/* If everything went ok (i.e. 1 msg transmitted), return #bytes
transmitted, else error code. */
return (ret == 1) ? count : ret;
}
在看下写函数，对应i2c core中的i2c_master_send：
int i2c_master_send(struct i2c_client *client,const char *buf ,int count)
{
int ret;
struct i2c_adapter *adap=client->adapter;//通过client访问adapter
struct i2c_msg msg;//这个就是i2c传输的单位
msg.addr = client->addr;
msg.flags = client->flags & I2C_M_TEN;//没有读标记就代表写操作
msg.len = count;//数据字节数
msg.buf = (char *)buf;//要写的buf
ret = i2c_transfer(adap, &msg, 1);//传输1个msg
/* If everything went ok (i.e. 1 msg transmitted), return #bytes
transmitted, else error code. */
return (ret == 1) ? count : ret;
}
我们发现无论读还是写函数最终都使用i2c_transfer()进行传输msg，下面具体分析一下i2c_transfer：
int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
{
unsigned long orig_jiffies;
int ret, try;
/* REVISIT the fault reporting model here is weak:
*
* - When we get an error after receiving N bytes from a slave,
* there is no way to report "N".
*
* - When we get a NAK after transmitting N bytes to a slave,
* there is no way to report "N" ... or to let the master
* continue executing the rest of this combined message, if
* that's the appropriate response.
*
* - When for example "num" is two and we successfully complete
* the first message but get an error part way through the
* second, it's unclear whether that should be reported as
* one (discarding status on the second message) or errno
* (discarding status on the first one).
*/
if (adap->algo->master_xfer) {//显然这个i2c_transfer依赖i2c_algorithm中的master_xfer是否被定义,我们在注册分析中知道它已经被赋值为.master_xfer = mxc_i2c_xfer
#ifdef DEBUG
for (ret = 0; ret < num; ret++) {
dev_dbg(&adap->dev, "master_xfer[%d] %c, addr=0x%02x, "
"len=%d%s\n", ret, (msgs[ret].flags & I2C_M_RD)
? 'R' : 'W', msgs[ret].addr, msgs[ret].len,
(msgs[ret].flags & I2C_M_RECV_LEN) ? "+" : "");
}
#endif
if (in_atomic() || irqs_disabled()) {
ret = mutex_trylock(&adap->bus_lock);
if (!ret)
/* I2C activity is ongoing. */
return -EAGAIN;
} else {
mutex_lock_nested(&adap->bus_lock, adap->level);//给bus上锁了
}
/* Retry automatically on arbitration loss */
orig_jiffies = jiffies;
for (ret = 0, try = 0; try <= adap->retries; try++) {
ret = adap->algo->master_xfer(adap, msgs, num);//最终转换为i2c_algorithm中的master_xfer传输
if (ret != -EAGAIN)
break;
if (time_after(jiffies, orig_jiffies + adap->timeout))//retry间隔时间
break;
}
mutex_unlock(&adap->bus_lock);
return ret;
} else {
dev_dbg(&adap->dev, "I2C level transfers not supported\n");
return -EOPNOTSUPP;
}
}
我们在注册分析中知道adap->algo被赋值为&mxc_i2c_algorithm，而mxc_i2c_algorithm定义为：
static struct i2c_algorithm mxc_i2c_algorithm = {
.master_xfer = mxc_i2c_xfer,//传输函数
.functionality = mxc_i2c_func//功能支持
};
所以adap->algo->master_xfer实际为mxc_i2c_xfer，这个函数即为i2c控制器的传输函数：
static int mxc_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msgs[],
int num)
{
mxc_i2c_device *dev = (mxc_i2c_device *) (i2c_get_adapdata(adap));
int i, ret = 0, addr_comp = 0;
volatile unsigned int sr;
int retry = 5, retry_start = 5;
retry:
if (dev->low_power) {
dev_err(&dev->adap.dev, "I2C Device in low power mode\n");
return -EREMOTEIO;
}
if (num < 1) {
return 0;
}
mxc_i2c_module_en(dev, msgs[0].flags);
sr = readw(dev->membase + MXC_I2SR);//读i2c的状态寄存器
/*
* Check bus state
*/
while ((sr & MXC_I2SR_IBB) && retry--) {//检查i2c总线状态是否处于忙
udelay(5);
sr = readw(dev->membase + MXC_I2SR);
}
if ((sr & MXC_I2SR_IBB) && retry < 0) {
mxc_i2c_module_dis(dev);
dev_err(&dev->adap.dev, "Bus busy\n");
return -EREMOTEIO;
}
//gpio_i2c_active(dev->adap.id);
dev->transfer_done = false;
dev->tx_success = false;
for (i = 0; i < num && ret >= 0; i++) {//num是要传输的msg个数
addr_comp = 0;
/*
* Send the slave address and transfer direction in the
* address cycle
*/
if (i == 0) {
/*
* Send a start or repeat start signal
*/
if (mxc_i2c_start(dev, &msgs[0])){//发送开始信号
if(retry_start-- != 0)
goto retry;
return -EREMOTEIO;
}
/* Wait for the address cycle to complete */
if (mxc_i2c_wait_for_tc(dev, msgs[0].flags)) {//等待地址周期完成
mxc_i2c_stop(dev);
//gpio_i2c_inactive(dev->adap.id);
mxc_i2c_module_dis(dev);
return -EREMOTEIO;
}
addr_comp = 1;
} else {
/*
* Generate repeat start only if required i.e the address
* changed or the transfer direction changed
*/
if ((msgs[i].addr != msgs[i - 1].addr) ||
((msgs[i].flags & I2C_M_RD) !=
(msgs[i - 1].flags & I2C_M_RD))) {//从if条件可以看出是判断地址和读写方向
mxc_i2c_repstart(dev, &msgs[i]);
/* Wait for the address cycle to complete */
if (mxc_i2c_wait_for_tc(dev, msgs[i].flags)) {
mxc_i2c_stop(dev);
//gpio_i2c_inactive(dev->adap.id);
mxc_i2c_module_dis(dev);
return -EREMOTEIO;
}
addr_comp = 1;
}
}
/* Transfer the data */
if (msgs[i].flags & I2C_M_RD) {//根据读写标记决定是读操作还是写操作
/* Read the data */
ret = mxc_i2c_readbytes(dev, &msgs[i], (i + 1 == num),
addr_comp);
if (ret < 0) {
dev_err(&dev->adap.dev, "mxc_i2c_readbytes:"
" fail.\n");
break;
}
} else {
/* Write the data */
ret = mxc_i2c_writebytes(dev, &msgs[i], (i + 1 == num));
if (ret < 0) {
dev_err(&dev->adap.dev, "mxc_i2c_writebytes:"
" fail.\n");
break;
}
}
}
//gpio_i2c_inactive(dev->adap.id);
mxc_i2c_module_dis(dev);
/*
* Decrease by 1 as we do not want Start message to be included in
* the count
*/
return (i < 0 ? ret : i);
}
我们看到控制器的传输函数是按照i2c协议的传输过程。在这里我们要看下mxc_i2c_start(dev, &msgs[0])：
static int mxc_i2c_start(mxc_i2c_device *dev, struct i2c_msg *msg)
{
volatile unsigned int cr, sr;
unsigned int addr_trans;
int retry = 16;
retry:
/*
* Set the slave address and the requested transfer mode
* in the data register
*/
addr_trans = msg->addr << 1;//地址x2，所以设备开始设置地址时要设为写地址的1/2
if (msg->flags & I2C_M_RD) {//如果是读操作，这地址加1
addr_trans |= 0x01;
}
......
}
我们注意一下这里的地址转换，所以设备信息设置的时候注意一下地址大小需要除以2 。
上面就是i2c读写过程:driver->i2c_core->adapter 转载地址：http://nzbsi.baihongyu.com/