linux2.6.28 I2C核心层

/////////////////////////////////////////////////

//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;
    }
}