我对linux理解之i2c
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
我们先从注册开始：
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