Linux中IIC设备驱动再细读

最新推荐文章于 2024-07-22 10:03:56 发布

Huke_abc

最新推荐文章于 2024-07-22 10:03:56 发布

阅读量1.4k

点赞数 1

分类专栏： Linux驱动移植文章标签： IIC设备驱动

本文链接：https://blog.csdn.net/mengzhuicanyang/article/details/54615516

版权

Linux驱动移植专栏收录该内容

13 篇文章 0 订阅

订阅专栏

S3C2440内核IIC设备驱动建立流程：

由内核打印信息，追索驱动流程：

内核注册流程：
由打印信息：
1. 先注册 i2c_driver： i2cdev_driver — \drivers\i2c\i2c-dev.c
前面分析过，内核启动初始化会执行函数：i2c_dev_init
i2c_dev_init(void)
register_chrdev(I2C_MAJOR, “i2c”, &i2cdev_fops); // 注册字符设备，主设备号为：I2C_MAJOR，应用层统一的操作接口为 i2cdev_fops
i2c_dev_class = class_create(THIS_MODULE, “i2c-dev”); // 构建一个class：i2c_dev_class

i2c_add_driver(&i2cdev_driver);
    i2c_register_driver(THIS_MODULE, driver);
        driver_register(&driver->driver);
        list_add_tail(&driver->list,&drivers);   // 这里将 i2cdev_driver 挂接到 drivers 链表上

        // 遍历adapters链表中的adapter，调用函数 i2cdev_attach_adapter(adapter)
        if (driver->attach_adapter) {   // 这里 driver->attach_adapter = i2cdev_attach_adapter
            struct i2c_adapter *adapter;

            // 在系统初始化的时候，adapters链表上，还没有初始化adapter元素，所以找不到adapter
            list_for_each_entry(adapter, &adapters, list) {
                driver->attach_adapter(adapter);  // 初始化的时候，找不到adapter，所以该句不会执行。
            }
        }


static struct i2c_driver i2cdev_driver = {
    .driver = {
        .name   = "dev_driver",
    },
    .id     = I2C_DRIVERID_I2CDEV,
    .attach_adapter = i2cdev_attach_adapter,
    .detach_adapter = i2cdev_detach_adapter,
    .detach_client  = i2cdev_detach_client,
};

注：
    这个代码是linux内核做好的框架，内核启动，就会注册一个i2c字符设备以及类，i2c-driver链表。
    并且为这个i2c字符设备提供了统一的应用层的操作接口函数。

打印信息：
i2c /dev entries driver

i2c_dev_init, i2c_add_driver: i2cdev_driver

然后注册i2c_adapter: s3c24xx_i2c.adap — \drivers\i2c\busses\i2c-s3c2410.c

注：这里就是针对不同的Soc注册i2c adapter，adapter是针对硬件i2c设备来说的。

在S3C2440中，使用平台总线驱动来注册I2C设备的。

2.1 初始化注册i2c平台设备资源：

linux-2.6.22.6\arch\arm\plat-s3c24xx\devs.c
在这个文件中定义了i2c设备资源：
    struct platform_device s3c_device_i2c = {
        .name         = "s3c2410-i2c",
        .id       = -1,
        .num_resources    = ARRAY_SIZE(s3c_i2c_resource),
        .resource     = s3c_i2c_resource,
    };

linux-2.6.22.6\arch\arm\mach-s3c2440\mach-smdk2440.c
在这个文件中注册i2c平台设备：
    static struct platform_device *smdk2440_devices[] __initdata = {
        &s3c_device_usb,
        &s3c_device_lcd,
        &s3c_device_wdt,
        &s3c_device_i2c,  
        &s3c_device_iis,
        &s3c2440_device_sdi,
    };

    // 初始化函数
    static void __init smdk2440_machine_init(void)
        platform_add_devices(smdk2440_devices, ARRAY_SIZE(smdk2440_devices));
            platform_device_register(devs[i]);  // 这里真正注册 s3c_device_i2c 设备

2.2 初始化注册i2c平台驱动：

linux-2.6.22.6\drivers\i2c\busses\i2c-s3c2410.c

// 注册i2c平台驱动：
static int __init i2c_adap_s3c_init(void)
    platform_driver_register(&s3c2440_i2c_driver);

// s3c2440的i2c平台设备驱动结构体：
static struct platform_driver s3c2440_i2c_driver = {
    .probe      = s3c24xx_i2c_probe,
    .remove     = s3c24xx_i2c_remove,
    .resume     = s3c24xx_i2c_resume,
    .driver     = {
        .owner  = THIS_MODULE,
        .name   = "s3c2440-i2c",
    },
};

而这里要问：那么 i2c_adapter 在哪里设置的呢？
回答：
    当初始化i2c平台驱动程序时，就会去找与平台驱动同名的平台设备，如果找到匹配的设备，则会调用
    平台驱动中定义的probe函数。
    在这个probe函数中，将会获取该SoC的i2c设备的相关资源(也就是前面定义的i2c平台设备资源)，并且构造一个 
    i2c_adapter 结构体，设置填充，最后调用函数i2c_add_adapter(该i2c_adapter结构体)，向系统注册。

    // 平台设备驱动：注册driver的时候，当找到匹配的设备时，调用driver里面的probe函数
    s3c24xx_i2c_probe(struct platform_device *pdev)
        struct s3c24xx_i2c *i2c = &s3c24xx_i2c;
        i2c->adap.algo_data = i2c;
        i2c->adap.dev.parent = &pdev->dev;
        s3c24xx_i2c_init(i2c);                            // 初始化IIC控制器
        i2c_add_adapter(&i2c->adap);
            i2c_register_adapter(adapter);
                list_add_tail(&adap->list, &adapters);   // 将该adapter挂接到adapters链表上

                // 遍历drivers链表中的i2c_driver，调用函数：driver->attach_adapter
                list_for_each(item,&drivers) {
                    driver = list_entry(item, struct i2c_driver, list);
                    if (driver->attach_adapter)
                        /* We ignore the return code; if it fails, too bad */
                        driver->attach_adapter(adap);  // 这里由于前面内核启动的时候，初始化了一个 i2cdev_driver 结构体
                                                       // 所以这里将执行： i2cdev_attach_adapter(adap)

                            i2cdev_attach_adapter(注册的adapter结构体)
                                // 在类 i2c_dev_class 下面注册一个device： i2c_dev->dev，
                                // 在应用层的文件为： /dev/i2c-0，/dev/i2c-1，... /dev/i2c-n
                                // 这个类： i2c_dev_class 也是在内核启动的时候注册的
                                i2c_dev->dev = device_create(i2c_dev_class, &adap->dev,
                                                 MKDEV(I2C_MAJOR, adap->nr),
                                                 "i2c-%d", adap->nr);
                }

    // 结构体：i2c_adapter，这里用结构体 struct s3c24xx_i2c 做了一层封装：
    static struct s3c24xx_i2c s3c24xx_i2c = {
        .lock       = __SPIN_LOCK_UNLOCKED(s3c24xx_i2c.lock),
        .wait       = __WAIT_QUEUE_HEAD_INITIALIZER(s3c24xx_i2c.wait),
        .tx_setup   = 50,

        // 这里才是真正的 i2c_adapter
        .adap       = {
            .name           = "s3c2410-i2c",
            .owner          = THIS_MODULE,
            .algo           = &s3c24xx_i2c_algorithm,   // 这里定义了i2c设备通过I2C接口如何发送，接收数据，
                                                        // 至于数据啥意思，它不管。
            .retries        = 2,
            .class          = I2C_CLASS_HWMON,
        },
    };

打印信息：

cnt: 1, i2c_adapter name: s3c2410-i2c

进一步解释：
当注册 i2c_adapter: s3c24xx_i2c.adap 的时候，就会遍历drivers链表，把drivers链表中的 i2c_driver
一个一个取出来，然后调用 i2c_driver.attach_adapter(adapt)函数。

因为前面只注册了一个 i2c_driver结构体： i2cdev_driver，所以就将调用函数：
i2cdev_driver.attach_adapter(adapter) = i2cdev_attach_adapter(s3c24xx_i2c.adap)

i2cdev_attach_adapter(s3c24xx_i2c.adap)
device_create(i2c_dev_class, &adap->dev, MKDEV(I2C_MAJOR, adap->nr), “i2c-%d”, adap->nr);
这个函数前面已经分析了，将会创建设备文件：”/dev/i2c-0”
所以当内核启动后，可以查看是否建立的设备文件:

ls /dev/i2c* -l

crw-rw—- 1 0 0 89, 0 Jan 1 00:00 /dev/i2c-0
可以看到，主设备号为89，次设备号为0，建立了设备文件: “/dev/i2c-0”

内核打印信息：
cnt: 1, i2cdev_attach_adapter,adap.name:s3c2410-i2c
cnt: 1, i2c_register_driver, i2c_driver->name: dev_driver

问题：上面只是生成了一个/dev/i2c-0设备文件，那真正的IIC从设备如何注册驱动呢？
回答：
可以参考例子程序：linux-2.6.22.6\drivers\i2c\chips\ds1374.c
static int __init ds1374_init(void)
i2c_add_driver(&ds1374_driver)
i2c_register_driver(THIS_MODULE, driver);
driver->driver.owner = owner;
driver->driver.bus = &i2c_bus_type;
driver_register(&driver->driver);

            // 将注册的 i2c_driver 挂接到drivers链表上
            list_add_tail(&driver->list,&drivers);

            // 遍历adapters链表下的 adapter 结构体，调用新注册的 i2c_driver 下面的attach_adapter函数
            if (driver->attach_adapter) {
                struct i2c_adapter *adapter;

                list_for_each_entry(adapter, &adapters, list) {
                    driver->attach_adapter(adapter);  // 这里函数 attach_adapter = ds1374_attach
                                                      // adapter 就是之前初始化注册的 s3c24xx_i2c.adap
                    // 相当于执行函数：
                    ds1374_attach(s3c24xx_i2c.adap)
                        i2c_probe(s3c24xx_i2c.adap, &addr_data, ds1374_probe);
                        // 在这里才真正的和底层设备扯上关系了
                            i2c_probe_address(s3c24xx_i2c.adap, 从设备的IIC地址, -1, 传递进来的函数 ds1374_probe );
                                i2c_smbus_xfer(adapter, addr, 0, 0, 0, I2C_SMBUS_QUICK, NULL)
                                    // 1. 探测是否真正存在该地址的IIC从设备
                                    i2c_smbus_xfer_emulated(adapter,addr,flags,read_write,command,size,data);

                                    // 2. 如果存在该IIC从设备，则调用真正的IIC从设备probe函数，
                                    //    这个函数是传递进来的： ds1374_probe
                                    found_proc(adapter, addr, kind);    
                                    ds1374_probe(struct i2c_adapter *adap, int addr, int kind)  
                                        // 2.1 建立一个i2c_client结构体，这个就表示一个外部的IIC从设备
                                        //  可以看到这个client结构体才是真正的操作源头。
                                        struct i2c_client *client;
                                        client->addr = addr;
                                        client->adapter = adap;
                                        client->driver = &ds1374_driver;    
                                        i2c_attach_client(client);
                                            // 2.2 将这个i2c_client结构体，挂接到该 i2c_adapter 的clients链表下面
                                            list_add_tail(&client->list,&adapter->clients);
                                            client->dev.bus = &i2c_bus_type;
                                            device_register(&client->dev);
                }
            }

static struct i2c_driver ds1374_driver = {
    .driver = {
        .name   = DS1374_DRV_NAME,
    },
    .id = I2C_DRIVERID_DS1374,
    .attach_adapter = ds1374_attach,
    .detach_client = ds1374_detach,
};

总结：
当注册 i2c_driver 到内核时，
（1）会从adapters链表下取出一个个adapter，
（2）然后调用新注册i2c_driver结构体总定义的 attach_adapter 函数，
（3）在这个 attach_adapter 函数中，会调用内核定义的统一的接口函数： i2c_probe
i2c_probe函数原型：
int i2c_probe(struct i2c_adapter *adapter, struct i2c_client_address_data *address_data,
int (found_proc) (struct i2c_adapter , int, int))

（4）在i2c_probe函数中，做两件事：
    a. 探测该IIC从设备是否真的存在，这是有内核定义的框架来自动probe的;
    b. 传递给 i2c_probe 函数的参数中带有一个真正的 IIC从设备的probe函数，在这一步得到调用
        在这个真正的IIC从设备probe函数中，将建立一个I2c_client结构体，这个结构体就是IIC从设备
        和外界进行IIC通信的载体（各种不同的操作：比如读写IIC从设备）。

总结如何编写i2c驱动
5.1 构造一个i2c_driver结构体
该结构体包括函数：
attach_adapter
detach_client
5.2 注册i2c_driver结构体
当向内核注册i2c_driver，将会调用该结构体下面的attach_adapter函数

5.3 所以当内核注册i2c_driver，会先探测IIC设备时候存在，如果存在，则调用attach_adapter函数来probe设备，
来建立某种联系：
5.3.1 在attach_adapter函数中，调用统一的函数接口：i2c_probe(adapter, 设备地址, “设备真正的probe函数”);
5.3.2 在”设备真正的probe函数”中，构造一个：struct i2c_client结构体：
该结构体一端连着”adapter”，一端连着”i2c_driver”，并保存IIC设备地址；最后调用函数 i2c_attach_client
将该client注册到内核的 i2c_bus_type 上。
5.3.3 运行到这里，表示已经找到IIC设备，并且已经利用client建立了某种联系，就可以创建与IIC设备对应的字符
设备文件，这个创建过程和前面讲的建立字符设备驱动一样。以后IIC设备文件的读写等操作，都是借助于client
这个桥梁。
注：
5.3.3 这一步在有的driver里面并没有做。注意在源代码中查看。