/////////////////////////////////////////////////
//postcore_initcall优先级比module_init高
postcore_initcall(i2c_init);
static int __init i2c_init(void)
{
retval = bus_register(&i2c_bus_type);
retval = class_register(&i2c_adapter_class);
retval = i2c_add_driver(&
dummy_driver);
}
/////////////////////////////////////////////////
static struct i2c_driver
dummy_driver = {
.driver.name = "dummy",
.probe = dummy_probe,
.remove = dummy_remove,
.id_table = dummy_id,
};
/////////////////////////////////////////////////
static struct device_attribute i2c_adapter_attrs[] = {
__ATTR(name, S_IRUGO, show_adapter_name, NULL),
{ },
};
static struct class
i2c_adapter_class = {
.owner = THIS_MODULE,
.name = "i2c-adapter",
.dev_attrs = i2c_adapter_attrs,
};
/////////////////////////////////////////////////
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,
};
总线提供了match和probe方法：match方法的用来进行client device（ 是i2c_client 吧）和client driver的配对。
在向总线i2c_bus_type注册设备或者驱动时 （i2c_add_driver函数或（i2c_register_driver）函数）会调用此方法
/////////////////////////////////////////////////
static int
i2c_device_match(struct device *dev, struct device_driver *drv)
{
//可以看出匹配的对象是struct i2c_client和 struct i2c_driver实例
//也就是struct i2c_client被看成device了？
struct i2c_client *client = to_i2c_client(dev);
struct i2c_driver *driver = to_i2c_driver(drv);
/* make legacy i2c drivers bypass driver model probing entirely;
* such drivers scan each i2c adapter/bus themselves.
*/
if (!is_newstyle_driver(driver))
return 0;
/* match on an id table if there is one */
//匹配
//可知
//static struct i2c_driver at24_driver
// .id_table =
at24_ids,这个ID表是用来匹配的，和i2c client的名字进行匹配
if (driver->id_table)
return i2c_match_id(driver->id_table, client) != NULL;
return 0;
}
/////////////////////////////////////////////////
i2c_bus_type的probe方法是通过传递进来的drv找到
包含此drv的i2c_driver驱动，然后再去调用i2c_driver的probe方法，此处就是at24_probe。为什么要这
样呢？因为driver_register后，注册的是i2c_driver->drv，而drv中的probe未初始化，我们需要调用的是
i2c-driver的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)
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;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
/**
* i2c_add_numbered_adapter - declare i2c adapter, use static bus number
* @adap: the adapter to register (with adap->nr initialized)
* Context: can sleep
*
* This routine is used to declare an I2C adapter when its bus number
* matters. For example, use it for I2C adapters from system-on-chip CPUs,
* or otherwise built in to the system's mainboard, and where i2c_board_info
* is used to properly configure I2C devices.
*
* If no devices have pre-been declared for this bus, then be sure to
* register the adapter before any dynamically allocated ones. Otherwise
* the required bus ID may not be available.
*
* When this returns zero, the specified adapter became available for
* clients using the bus number provided in adap->nr. Also, the table
* of I2C devices pre-declared using i2c_register_board_info() is scanned,
* and the appropriate driver model device nodes are created. Otherwise, a
* negative errno value is returned.
*/
//这个函数在i2c核心层
//<>
在匹配完成后调用s3c24xx_i2c_probe函数调用i2c_add_numbered_adapter
//执行完i2c_add_numbered_adapter函数后，内核的i2c总线上已有adapter device和client device
//只和client匹配，不和adapter匹配，adapter和client已经关联?。
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)
//注册adapter设备
status =
i2c_register_adapter(adap);
return status;
}
/////////////////////////////////////////////////////////////////////////////////////
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)))
return -EAGAIN;
mutex_init(&adap->bus_lock);
mutex_init(&adap->clist_lock);
INIT_LIST_HEAD(&adap->clients);
mutex_lock(&core_lock);
/* Add the adapter to the driver core.
* If the parent pointer is not set up,
* we add this adapter to the host bus.
*/
if (adap->dev.parent == NULL) {
adap->dev.parent = &platform_bus;
pr_debug("I2C adapter driver [%s] forgot to specify "
"physical device\n", adap->name);
}
// /sys/bus/i2c/devices/i2c-0
// /sys/bus/i2c/devices/i2c-1
//i2c-0 就是adapter device
sprintf(adap->dev.bus_id, "i2c-%d", adap->nr);
adap->dev.release = &i2c_adapter_dev_release;
// 看看 driver->driver.bus = &i2c_bus_type;
//struct i2c_adapter ------>绑定
i2c_adapter_class
//struct i2c_client（i2c_device）------>绑定i2c_bus_type
//struct i2c_driver (at24.c at24_driver) ------>绑定i2c_bus_type
adap->dev.class = &
i2c_adapter_class;
//将名为i2c-0的adapter设备注册
res =
device_register(&adap->dev);
/* create pre-declared device nodes for new-style drivers */
if (adap->nr < __i2c_first_dynamic_bus_num)
i2c_scan_static_board_info(adap);
/* Notify drivers */
//识别一下，看看有没有
///尝试和i2c总线上所有的dev进行一次匹配，只要获取的dev为adapter时，就可执行后续操作
//bus_for_each_drv()是对BUS上所有的Driver都进行__device_attach()操作；
//同样的，bus_for_each_dev()是对BUS上所有的Device都进行__driver_attach()操作
dummy =
bus_for_each_drv(&i2c_bus_type, NULL, adap,
i2c_do_add_adapter);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////
首先从__i2c_board_list链表上获取一个devinfo信息结构体，此结构体由前面的
smdk6410_machine_init函数调用
i2c_register_board_info()添加到i2c设备链表上的。结构体中包含板上的i2c
at24c02设备相关信息。然后在此函数中调用i2c_new_device()以从链表上获取的devinfo作为参
数，i2c_new_device函数根据devinfo中的设备相关信息来创建client，内核中使用client来代表at24c02设备。
static void
i2c_scan_static_board_info(struct i2c_adapter *adapter)
{
struct i2c_devinfo *devinfo;
mutex_lock(&__i2c_board_lock);
//遍历
__i2c_board_list链表
//
//static struct i2c_board_info i2c_devs0[]
//smdk6410_machine_init()--->
// i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));
// i2c_register_board_info(1, i2c_devs1, ARRAY_SIZE(i2c_devs1));
//此处的0和1是+1后就是devinfo->busnum,也就是adapter->nr，应该就是代表第几组寄存器组吧？
//i2c_register_board_info(int busnum, struct i2c_board_info const *info, unsigned len)
list_for_each_entry(devinfo, &
__i2c_board_list, list) {
//
// s3c24xx_i2c_probe函数 i2c->adap.nr = pdata->bus_num;
//如果adapter的号码和节点中的号码相同，才会调用
i2c_new_device创建i2c clien
if (devinfo->busnum == adapter->nr
&& !
i2c_new_device(adapter,
&devinfo->board_info))
printk(KERN_ERR "i2c-core: can't create i2c%d-%04x\n",
i2c_adapter_id(adapter),
devinfo->board_info.addr);
}
mutex_unlock(&__i2c_board_lock);
}
/////////////////////////////////////////////////////////////////////////////////////
/**
* i2c_new_device - instantiate an i2c device for use with a new style driver
* @adap: the adapter managing the device
* @info: describes one I2C device; bus_num is ignored
* Context: can sleep
*
* Create a device to work with a new style i2c driver, where binding is
* handled through driver model probe()/remove() methods. This call is not
* appropriate for use by mainboad initialization logic, which usually runs
* during an arch_initcall() long before any i2c_adapter could exist.
*
* This returns the new i2c client, which may be saved for later use with
* i2c_unregister_device(); or NULL to indicate an error.
*/
struct i2c_client *
i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)
{
struct i2c_client *client;
int status;
client = kzalloc(sizeof *client, GFP_KERNEL);
if (!client)
return NULL;
//client 和adap是相互关联到一起的。
client->adapter = adap;
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;
// i2c_board_info中的名字给了client
//
//static struct i2c_board_info i2c_devs0[] __initdata = {
// { I2C_BOARD_INFO("24c08", 0x50), }, //0x50为IIC芯片设备地址
//"24c08"这个名字就是用来创建i2c_client来和里static struct i2c_driver at24_driver进行匹配的。
strlcpy(client->name, info->type, sizeof(client->name));
/* a new style driver may be bound to this device when we
* return from this function, or any later moment (e.g. maybe
* hotplugging will load the driver module). and the device
* refcount model is the standard driver model one.
*/
status =
i2c_attach_client(client);
if (status < 0) {
kfree(client);
client = NULL;
}
return client;
}
/////////////////////////////////////////////////////////////////////////////////////
int
i2c_attach_client(struct i2c_client *client)
{
struct i2c_adapter *adapter = client->adapter;
int res;
/* Check for address business */
res = i2c_check_addr(adapter, client->addr);
if (res)
return res;
client->dev.parent = &client->adapter->dev;
//struct i2c_adapter ------>绑定i2c_adapter_class
//struct i2c_client（i2c_device）------>绑定i2c_bus_type
//struct i2c_driver (at24.c at24_driver) ------>绑定i2c_bus_type
//client被注册到i2c_bus_type总线
//static struct i2c_driver
dummy_driver 这个也是注册到i2c_bus_type总线
client->dev.bus = &i2c_bus_type;
if (client->driver)
client->dev.driver = &client->driver->driver;
if (client->driver && !is_newstyle_driver(client->driver)) {
client->dev.release = i2c_client_release;
client->dev.uevent_suppress = 1;
} else
client->dev.release = i2c_client_dev_release;
///sys/bus/i2c/devices # ls
// 0-001b 0-0050 i2c-0 i2c-1 i2c-2
// /sys/bus/i2c/devices/0-001b
// /sys/bus/i2c/devices/0-0050
//0-001b就是client device
snprintf(&client->dev.bus_id[0], sizeof(client->dev.bus_id),
"%d-%04x", i2c_adapter_id(adapter), client->addr);
//注册client的父类到内核
//int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
// driver->driver.bus = &i2c_bus_type;
// res = driver_register(&driver->driver);
//这么像，应该能猜到client->dev就是device->dev
res =
device_register(&client->dev);
if (res)
goto out_err;
mutex_lock(&adapter->clist_lock);
list_add_tail(&client->list, &adapter->clients);
mutex_unlock(&adapter->clist_lock);
dev_dbg(&adapter->dev, "client [%s] registered with bus id %s\n",
client->name, client->dev.bus_id);
if (adapter->client_register) {
if (adapter->client_register(client)) {
dev_dbg(&adapter->dev, "client_register "
"failed for client [%s] at 0x%02x\n",
client->name, client->addr);
}
}
return 0;
out_err:
dev_err(&adapter->dev, "Failed to attach i2c client %s at 0x%02x "
"(%d)\n", client->name, client->addr, res);
return res;
}
///////////////////////////////////////////////////////////////////////////////////////////////
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) {
/* We ignore the return code; if it fails, too bad */
//调用
//static struct i2c_driver
i2cdev_driver = {
// .attach_adapter =
i2cdev_attach_adapter,
//此处调用
i2cdev_attach_adapter函数
driver->attach_adapter(adap);
}
return 0;
}
///////////////////////////////////////////////////////////////////////////////////////////////
//和
i2c_do_add_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;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static inline int i2c_add_driver(struct i2c_driver *driver)
{
return i2c_register_driver(THIS_MODULE, driver);
}
////////////////////////////////////////////
/*
* An i2c_driver is used with one or more i2c_client (device) nodes to access
* i2c slave chips, on a bus instance associated with some i2c_adapter. There
* are two models for binding the driver to its device: "new style" drivers
* follow the standard Linux driver model and just respond to probe() calls
* issued if the driver core sees they match(); "legacy" drivers create device
* nodes themselves.
*/
//对比
//static int
i2c_register_adapter(struct i2c_adapter *adap)
//这两个函数里面是何其形似，所以
i2c_register_adapter相当于 i2c_register_device,和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;
/* new style driver methods can't mix with legacy ones */
if (is_newstyle_driver(driver)) {
if (driver->attach_adapter || driver->detach_adapter
|| driver->detach_client) {
printk(KERN_WARNING
"i2c-core: driver [%s] is confused\n",
driver->driver.name);
return -EINVAL;
}
}
/* add the driver to the list of i2c drivers in the driver core */
driver->driver.owner = owner;
//
//int i2c_attach_client(struct i2c_client *client)
// client->dev.bus = &i2c_bus_type;
//client被注册到i2c_bus_type总线
//static struct i2c_driver
dummy_driver 这个也是注册到i2c_bus_type总线
//struct i2c_adapter ------>绑定i2c_adapter_class
//struct i2c_client（i2c_device）------>绑定i2c_bus_type
//struct i2c_driver ------>绑定i2c_bus_type
driver->driver.bus = &i2c_bus_type;
//见
//int i2c_attach_client(struct i2c_client *client)
//---> client->dev.parent = &client->adapter->dev;
// client->dev.bus = &i2c_bus_type;
// res = device_register(&client->dev);
//这么像，是不是必须client是device.呵呵
/* for new style drivers, 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;
mutex_lock(&core_lock);
pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);
INIT_LIST_HEAD(&driver->clients);
/* Walk the adapters that are already present */
//
i2c_register_adapter里也有一个 bus_for_each_drv
class_for_each_device(&i2c_adapter_class, NULL, driver,
__attach_adapter);
mutex_unlock(&core_lock);
return 0;
}
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
/**
* i2c_transfer - execute a single or combined I2C message
* @adap: Handle to I2C bus
* @msgs: One or more messages to execute before STOP is issued to
* terminate the operation; each message begins with a START.
* @num: Number of messages to be executed.
*
* Returns negative errno, else the number of messages executed.
*
* Note that there is no requirement that each message be sent to
* the same slave address, although that is the most common model.
*/
at24_eeprom_read调用i2c_transfer
int
i2c_transfer(struct i2c_adapter * adap, struct i2c_msg *msgs, int num)
{
int ret;
/* 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) {
#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);
}
//发送数据
//
//static const struct i2c_algorithm
s3c24xx_i2c_algorithm = {
// .master_xfer = s3c24xx_i2c_xfer,
//此处调用 s3c24xx_i2c_xfer函数
ret =
adap->algo->master_xfer(adap,msgs,num);
mutex_unlock(&adap->bus_lock);
return ret;
} else {
dev_dbg(&adap->dev, "I2C level transfers not supported\n");
return -EOPNOTSUPP;
}
}
