S3C2440驱动简析——I2C驱动（4）

    说时迟，那时快，马上进入I2C驱动的最后一个小节了，在这个小节里，我们主要探讨i2c_algorithm 数据结构和i2c-core.c 的一些主要函数及其作用。有鉴于i2c-core.c 代码达2000行，所以本文仅对导出的函数（EXPORT_SYMBOL）进行简单注释，其它函数想必也是为前者服务的啦。好，马上进入正题：

 

i2c_algorithm 结构体

struct i2c_algorithm { int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs, int num); int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr, unsigned short flags, char read_write, u8 command, int size, union i2c_smbus_data *data); u32 (*functionality) (struct i2c_adapter *); };

 

一个 i2c 适配器上的i2c 总线通信方法由其驱动程序提供的i2c_algorithm 数据结构描述，由algo 指针指向。i2c_algorithm 数据结构即为i2c_adapter 数据结构与具体i2c 适配器的总线通信方法的中间层，正是这个中间层使得上层的i2c 框架代码与与具体i2c 适配器的总线通信方法无关，从而实现了i2c 框架的
可移植性和重用性。当安装具体i2c 适配器的驱动程序时由相应驱动程序实现具体的i2c_algorithm 数据结构，其中的函数指针指向操作具体i2c 适配器的代码。

 

master_xfer/smbus_xfer 指针指向i2c 适配器驱动程序模块实现的i2c 通信协议或者smbus 通信协议。在用户进程通过i2c-dev 提供的/dev/i2c/%d 设备节点访问i2c 设备时，最终是通过调用
master_xfer 或者smbus_xfer 指向的方法完成的。

 

 

i2c-core.c

i2c.h 和i2c-core.c 为i2c 框架的主体，提供了核心数据结构的定义、i2c 适配器驱动和设备驱
动的注册、注销管理，i2c 通信方法上层的、与具体适配器无关的代码、检测设备地址的上层代码等；
i2c-dev.c 用于创建i2c 适配器的/dev/i2c/%d 设备节点，提供i2c 设备访问方法等。

 

下面介绍其主要的函数

函数i2c_init

static int __init i2c_init(void) { int retval; retval = bus_register(&i2c_bus_type); if (retval) return retval; #ifdef CONFIG_I2C_COMPAT i2c_adapter_compat_class = class_compat_register("i2c-adapter"); if (!i2c_adapter_compat_class) { retval = -ENOMEM; goto bus_err; } #endif retval = i2c_add_driver(&dummy_driver); if (retval) goto class_err; return 0; class_err: #ifdef CONFIG_I2C_COMPAT class_compat_unregister(i2c_adapter_compat_class); bus_err: #endif bus_unregister(&i2c_bus_type); return retval; }

主要做了以下几件事情：

1.i2c_add_driver(&dummy_driver);
   注册i2c总线

2.class_compat_register("i2c-adapter");

   注册一个可兼容的类

3.i2c_add_driver(&dummy_driver);
   加载驱动

 

函数i2c_exit

static void __exit i2c_exit(void) { i2c_del_driver(&dummy_driver); #ifdef CONFIG_I2C_COMPAT class_compat_unregister(i2c_adapter_compat_class); #endif bus_unregister(&i2c_bus_type); }

这个就不解释了呀~~

 

结构体i2c_bus_type

struct bus_type i2c_bus_type = { .name = "i2c", .match = i2c_device_match, .probe = i2c_device_probe, .remove = i2c_device_remove, .shutdown = i2c_device_shutdown, .suspend = i2c_device_suspend, .resume = i2c_device_resume, };

 

本结构体被导出，其里面包含了6个函数，其作用看名字就能猜到个大概。下面贴出以上6个函数的代码。

static int i2c_device_match(struct device *dev, struct device_driver *drv) { struct i2c_client *client = i2c_verify_client(dev); struct i2c_driver *driver; if (!client) return 0; 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; return 0; } static int i2c_device_probe(struct device *dev) { struct i2c_client *client = i2c_verify_client(dev); struct i2c_driver *driver; int status; if (!client) return 0; driver = to_i2c_driver(dev->driver); if (!driver->probe || !driver->id_table) return -ENODEV; client->driver = driver; 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)); if (status) client->driver = NULL; return status; } static int i2c_device_remove(struct device *dev) { struct i2c_client *client = i2c_verify_client(dev); struct i2c_driver *driver; int status; if (!client || !dev->driver) return 0; driver = to_i2c_driver(dev->driver); if (driver->remove) { dev_dbg(dev, "remove/n"); status = driver->remove(client); } else { dev->driver = NULL; status = 0; } if (status == 0) client->driver = NULL; return status; } static void i2c_device_shutdown(struct device *dev) { struct i2c_client *client = i2c_verify_client(dev); struct i2c_driver *driver; if (!client || !dev->driver) return; driver = to_i2c_driver(dev->driver); if (driver->shutdown) driver->shutdown(client); } static int i2c_device_suspend(struct device *dev, pm_message_t mesg) { struct i2c_client *client = i2c_verify_client(dev); struct i2c_driver *driver; if (!client || !dev->driver) return 0; driver = to_i2c_driver(dev->driver); if (!driver->suspend) return 0; return driver->suspend(client, mesg); } static int i2c_device_resume(struct device *dev) { struct i2c_client *client = i2c_verify_client(dev); struct i2c_driver *driver; if (!client || !dev->driver) return 0; driver = to_i2c_driver(dev->driver); if (!driver->resume) return 0; return driver->resume(client); }

 

函数i2c_add_adapter

int i2c_add_adapter(struct i2c_adapter *adapter) { int id, res = 0; 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 */ res = idr_get_new_above(&i2c_adapter_idr, adapter, __i2c_first_dynamic_bus_num, &id); mutex_unlock(&core_lock); if (res < 0) { if (res == -EAGAIN) goto retry; return res; } adapter->nr = id; return i2c_register_adapter(adapter); }

函数主要作用是添加一个适配器

1.idr_get_new_above(&i2c_adapter_idr, adapter,
                               __i2c_first_dynamic_bus_num, &id);

   确认是否还能分配得到适配器id，该操作不能被打断。

2.i2c_register_adapter(adapter);
   注册一个适配器

 

函数i2c_del_adapter

int i2c_del_adapter(struct i2c_adapter *adap) { int res = 0; struct i2c_adapter *found; struct i2c_client *client, *next; /* First make sure that this adapter was ever added */ mutex_lock(&core_lock); found = idr_find(&i2c_adapter_idr, adap->nr); mutex_unlock(&core_lock); if (found != adap) { pr_debug("i2c-core: attempting to delete unregistered " "adapter [%s]/n", adap->name); return -EINVAL; } /* Tell drivers about this removal */ mutex_lock(&core_lock); res = bus_for_each_drv(&i2c_bus_type, NULL, adap, i2c_do_del_adapter); mutex_unlock(&core_lock); if (res) return res; /* Remove devices instantiated from sysfs */ list_for_each_entry_safe(client, next, &userspace_devices, detected) { if (client->adapter == adap) { dev_dbg(&adap->dev, "Removing %s at 0x%x/n", client->name, client->addr); list_del(&client->detected); i2c_unregister_device(client); } } /* Detach any active clients. This can't fail, thus we do not checking the returned value. */ res = device_for_each_child(&adap->dev, NULL, __unregister_client); #ifdef CONFIG_I2C_COMPAT class_compat_remove_link(i2c_adapter_compat_class, &adap->dev, adap->dev.parent); #endif /* clean up the sysfs representation */ init_completion(&adap->dev_released); device_unregister(&adap->dev); /* wait for sysfs to drop all references */ wait_for_completion(&adap->dev_released); /* free bus id */ mutex_lock(&core_lock); idr_remove(&i2c_adapter_idr, adap->nr); mutex_unlock(&core_lock); dev_dbg(&adap->dev, "adapter [%s] unregistered/n", adap->name); /* Clear the device structure in case this adapter is ever going to be added again */ memset(&adap->dev, 0, sizeof(adap->dev)); return 0; }

对应于i2c_add_adapter，此函数删除一个适配器。

 

函数 i2c_register_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); if (res) return res; pr_debug("i2c-core: driver [%s] registered/n", driver->driver.name); INIT_LIST_HEAD(&driver->clients); /* Walk the adapters that are already present */ mutex_lock(&core_lock); bus_for_each_dev(&i2c_bus_type, NULL, driver, __attach_adapter); mutex_unlock(&core_lock); return 0; }

注册一个设备

1.driver_register(&driver->driver);
   开始先注册一个设备

2.bus_for_each_dev(&i2c_bus_type, NULL, driver, __attach_adapter);
   调用相对应的__attach_adapter 函数，并传递参数driver 给它。完成设备绑定适配器的动作。至于__attach_adapter 的代码粘贴如下

   static int __attach_adapter(struct device *dev, void *data) { struct i2c_adapter *adapter; struct i2c_driver *driver = data; if (dev->type != &i2c_adapter_type) return 0; adapter = to_i2c_adapter(dev); i2c_detect(adapter, driver); /* Legacy drivers scan i2c busses directly */ if (driver->attach_adapter) driver->attach_adapter(adapter); return 0; }

  

函数i2c_del_driver

void i2c_del_driver(struct i2c_driver *driver) { mutex_lock(&core_lock); bus_for_each_dev(&i2c_bus_type, NULL, driver, __detach_adapter); mutex_unlock(&core_lock); driver_unregister(&driver->driver); pr_debug("i2c-core: driver [%s] unregistered/n", driver->driver.name); }

相对应i2c_register_driver，本函数执行卸载设备的动作。

1.bus_for_each_dev(&i2c_bus_type, NULL, driver, __detach_adapter);
   调用__detach_adapter 函数，并传递函数driver 给它，完成分离设备和适配器的功能。

2.driver_unregister(&driver->driver);
   卸载设备。

   __detach_adapter 代码如下

   static int __detach_adapter(struct device *dev, void *data) { struct i2c_adapter *adapter; struct i2c_driver *driver = data; struct i2c_client *client, *_n; if (dev->type != &i2c_adapter_type) return 0; adapter = to_i2c_adapter(dev); /* Remove the devices we created ourselves as the result of hardware * probing (using a driver's detect method) */ list_for_each_entry_safe(client, _n, &driver->clients, detected) { dev_dbg(&adapter->dev, "Removing %s at 0x%x/n", client->name, client->addr); list_del(&client->detected); i2c_unregister_device(client); } if (driver->detach_adapter) { if (driver->detach_adapter(adapter)) dev_err(&adapter->dev, "detach_adapter failed for driver [%s]/n", driver->driver.name); } return 0; }

 

最后来看3个重要的i2c总线操作函数

函数 i2c_transfer

unsigned long orig_jiffies; int ret, try; if (adap->algo->master_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); } /* 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); if (ret != -EAGAIN) break; if (time_after(jiffies, orig_jiffies + adap->timeout)) break; } mutex_unlock(&adap->bus_lock); return ret; } else { dev_dbg(&adap->dev, "I2C level transfers not supported/n"); return -EOPNOTSUPP; } }

该函数几乎与 i2c_master_recv 和i2c_master_send (接下来马上叙述)函数一模一样，都是在持有i2c_adapter 的lock 信号量的情况下利用i2c 适配器的algo 所指的i2c_algorithm 数据结构的master_xfer 方法执行实际的i2c 操作。

整个函数最重要的，当数for 循环里面的内容，而for 循环里面的内容，最最重要的，肯定就是

ret = adap->algo->master_xfer(adap, msgs, num);  经过前文提及的内容，master_xfer用于产生I2C访问周期需要的信号，以I2C消息为单位。

 

函数 i2c_master_send

int i2c_master_send(struct i2c_client *client,const char *buf ,int count) { int ret; struct i2c_adapter *adap=client->adapter; struct i2c_msg msg; msg.addr = client->addr; msg.flags = client->flags & I2C_M_TEN; msg.len = count; msg.buf = (char *)buf; ret = i2c_transfer(adap, &msg, 1); /* If everything went ok (i.e. 1 msg transmitted), return #bytes transmitted, else error code. */ return (ret == 1) ? count : ret; }

把需要发送的数据以及其信息保存到msg 结构体，通过i2c_transfer 函数发送。

 

函数 i2c_master_recv

int i2c_master_recv(struct i2c_client *client, char *buf ,int count) { struct i2c_adapter *adap=client->adapter; struct i2c_msg msg; 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); /* If everything went ok (i.e. 1 msg transmitted), return #bytes transmitted, else error code. */ return (ret == 1) ? count : ret; }

跟发送函数i2c_master_send 对应的一个接收函数，具体不作解释啦。

 

由于篇幅问题，故不能肆意展开全部代码，但我还是在这里罗列一下关于smbus协议需要注意的函数：

s32 i2c_smbus_read_byte(struct i2c_client *client)；

s32 i2c_smbus_write_byte(struct i2c_client *client, u8 value)；

s32 i2c_smbus_read_byte_data(struct i2c_client *client, u8 command)；

s32 i2c_smbus_write_byte_data(struct i2c_client *client, u8 command, u8 value)；

s32 i2c_smbus_read_word_data(struct i2c_client *client, u8 command)；

s32 i2c_smbus_write_word_data(struct i2c_client *client, u8 command, u16 value)；

s32 i2c_smbus_read_block_data(struct i2c_client *client, u8 command,
                                              u8 *values)；

s32 i2c_smbus_write_block_data(struct i2c_client *client, u8 command,
                                              u8 length, const u8 *values)；

static s32 i2c_smbus_xfer_emulated(struct i2c_adapter * adapter, u16 addr,
                                                   unsigned short flags,
                                                   char read_write, u8 command, int size,
                                                   union i2c_smbus_data * data)；

以上一系列的函数，都是在i2c_smbus_xfer 函数的基础上建立起来的，只要理解了基石，其上的函数就不足为惧了。最后的最后，看一下这个藏在代码最后的基石吧！

 

函数 i2c_smbus_xfer

s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr, unsigned short flags, char read_write, u8 command, int protocol, union i2c_smbus_data *data) { unsigned long orig_jiffies; int try; s32 res; flags &= I2C_M_TEN | I2C_CLIENT_PEC; if (adapter->algo->smbus_xfer) { mutex_lock(&adapter->bus_lock); /* Retry automatically on arbitration loss */ orig_jiffies = jiffies; for (res = 0, try = 0; try <= adapter->retries; try++) { res = adapter->algo->smbus_xfer(adapter, addr, flags, read_write, command, protocol, data); if (res != -EAGAIN) break; if (time_after(jiffies, orig_jiffies + adapter->timeout)) break; } mutex_unlock(&adapter->bus_lock); } else res = i2c_smbus_xfer_emulated(adapter,addr,flags,read_write, command, protocol, data); return res; }

该函数通过适配器驱动提供的总线访问方法（i2c_algorithm 的smbus_xfer 方法）尝试访问处于addr 地址上的设备。其实函数里面最核心的一句是：

res = adapter->algo->smbus_xfer(adapter, addr, flags,
                                                read_write, command,
                                                protocol, data);

哈哈，这岂不妙哉，到最后我们还是回到结构体i2c_algorithm 的smbus_xfef 成员函数（见本文起始部分）。真是众里寻他千百度，蓦然回首，此函数却在灯火阑珊处。

 

 

经过这一个i2c系列4个小节的学习，自己对代码的分析，特别是驱动代码的分析有了一定的提高，起码在心理上不会感到畏惧。希望各位初学的朋友能够跟我一起坚持下去，踏踏实实地走好每一步！

 

 

本系列博文链接：

I2C驱动（1）http://blog.csdn.net/jarvis_xian/archive/2011/05/27/6449939.aspx
I2C驱动（2）http://blog.csdn.net/jarvis_xian/archive/2011/05/27/6451168.aspx
I2C驱动（3）http://blog.csdn.net/jarvis_xian/archive/2011/05/28/6452431.aspx
I2C驱动（4）http://blog.csdn.net/jarvis_xian/archive/2011/05/30/6455697.aspx