深入源代码设计i2c驱动@linux2.6.32.2

原文： http://blog.chinaunix.net/uid-22609852-id-3506488.html

不管怎样，先列出在linux2.6.32.2下最简短的i2c程序，因为在跟踪内核代码的过程中你会关注到它。
一、最简驱动
/* at24c08.c */

#include  <linux/init.h>
#include  <linux/module.h>
#include  <linux/i2c.h>


static  int  at24c08_probe(struct  i2c_client  *client,  const  struct  i2c_device_id  *dev_id)
{
    printk("at24c08_probe\n");
    return    0;
}

static  int  at24c08_remove(struct  i2c_client  *client)
{
    printk("at24c08_remove\n");
    return    0;
}

static  int  at24c08_detect(struct  i2c_client  *client,  int  kind,  struct  i2c_board_info  *bd_info)
{
    strcpy(bd_info->type,    "at24c08");    //这个必须设置 //Point3
    printk("at24c08_detect\n");
    
    return    0;
}

static  const  struct  i2c_device_id  at24c08_id[]  =  {
    {"at24c08",  0},
    {}
};

static  unsigned  short  ignore[]            =  {  I2C_CLIENT_END  };

static  const  unsigned  short  normal_i2c[]  =  {0x50,  I2C_CLIENT_END};

static  const  struct  i2c_client_address_data  addr_data  =  {
    .normal_i2c    =  normal_i2c,
    .probe        =  ignore,
    .ignore        =  ignore,
    //.forces    Point1
};

static  struct  i2c_driver  at24c08_driver=  {
    .probe    =  at24c08_probe,
    .remove    =  at24c08_remove,
    .driver  =  {
        .name  =  "at24c08",
    },
    .id_table    =  at24c08_id,
    .detect    =  at24c08_detect,
    .address_data    =  &addr_data,
    .class      =  I2C_CLASS_HWMON  |  I2C_CLASS_SPD,    //Point2
};

static  int  at24c08_init(void)
{
    i2c_add_driver(&at24c08_driver);
    return  0;
}

static  void  at24c08_exit(void)
{
    i2c_del_driver(&at24c08_driver);
    return  ;
}

module_init(at24c08_init);
module_exit(at24c08_exit);
MODULE_LICENSE("GPL");

二、代码分析
适写驱动之前我们先从i2c-s3c2410.c开始分析

系统启动初始化运行i2c_adap_s3c_init

i2c_adap_s3c_init(i2c-s3c2410.c)
    platform_driver_register  (platform.c)
        drv->driver.bus  =  &platform_bus_type;    //设置驱动总线的类型为平台总线
        driver_register(&drv->driver)  (driver.c)
            bus_add_driver(drv)  (bus.c)
                driver_attach(drv)  (db.c)
                    bus_for_each_dev(drv->bus,  NULL,  drv,  __driver_attach)(bus.c)
                        fn(dev,  data)  (bus.c)
                        <=>__driver_attach  (db.c)
                                    driver_match_device(drv,  dev)    (base.h)//调用驱动所属总线的match函数即：platform_match
                                    driver_probe_device(drv,  dev)  (db.c)
                                        really_probe(dev,  drv)  (db.c)
                                            if  (dev->bus->probe)  {        //不存在
                                                ret  =  dev->bus->probe(dev);
                                                ...
                                            }  else  if  (drv->probe)  {    //或者调用驱动的probe函数即：s3c24xx_i2c_probe
                                                ret  =  drv->probe(dev);
                                                ..
                                            }
接上
drv->probe(dev)(db.c)
    s3c24xx_i2c_probe  (i2c-s3c2410.c)
        i2c_add_numbered_adapter(&i2c->adap)  (i2c-s3c2410.c)
            i2c_register_adapter  (i2c-core.c)
            if  (adap->nr  <  __i2c_first_dynamic_bus_num)    //静态注册i2c_board_info的适合才会设置__i2c_first_dynamic_bus_num，而且adap->nr也没有设置
                i2c_scan_static_board_info(adap);  //不会执行
            i2c_do_add_adapter  (i2c-core.c)
                i2c_detect  (i2c-core.c)
                    if  (!driver->detect  ||  !address_data)  (i2c-core.c)//如果我们写的驱动里没有detect函数或者address_data就直接返回了
                        return  0;    //因为subsys_initcall(i2c_adap_s3c_init) (在i2c-s3c2410.c看到，是在系统启动的适合运行的，此时at24c08.ko还未加载，直接返回)
至此,i2c-s3c2410.c初始化部分结束

当我们的at24c08.ko被加载后:
at24c08_init    (at24c08.c)
    i2c_add_driver(&at24c08_driver)  (at24c08.c)
        i2c_register_driver  (i2c.h)
            driver->driver.bus  =  &i2c_bus_type;
            driver_register(&driver->driver)
            bus_for_each_dev(&i2c_bus_type,  NULL,  driver,  __attach_adapter)  (bus.c)
                fn(dev,  data)  (bus.c)
                <=>__attach_adapter  (i2c-core.c)
                            i2c_detect  (i2c-core.c)
                                if  (address_data->forces)  {    //forces不存在，见Point1
                                    ...
                                }
                                if  (!(adapter->class  &  driver->class))    //如果class也不匹配就跳出了,adapter->class在s3c24xx_i2c_probe里设置了
                                    goto  exit_free                                                //所以在自己写的驱动程序里也要将driver的class设置相同，见Point2和s3c24xx_i2c_probe
                                if  (!i2c_check_functionality(adapter,  I2C_FUNC_SMBUS_QUICK))  {    //检查i2c_algorithm里的functionality
                                    ...                                                                                                                        //在i2c-s3c2410.c已经设置，继续执行后面
                                }
                                for  (i  =  0;  address_data->probe  !=  I2C_CLIENT_END;  i  +=  2)  {    //ignore
                                    ...
                                }
                                for  (i  =  0;  address_data->normal_i2c  !=  I2C_CLIENT_END;  i  +=  1)  {    //正常入口，除非被忽略
                                    ...
                                    i2c_detect_address(temp_client,  -1,  driver)    (i2c-core.c)
                                        if  (i2c_smbus_xfer(adapter,  addr,  0,  0,  0,I2C_SMBUS_QUICK,  NULL)  <  0)    //检查这个地址是否对，不对就返回
                                            return  0;
                                        driver->detect(temp_client,  kind,  &info)    //Point5
                                        <=>at24c08_detect  (at24c08.c)  //调用到自己写的探测函数
                                        if  (info.type[0]  ==  '\0')  {    //Point3
                                            ...
                                        }  else  {    //要想执行else语句，必须在自定义detect函数里设置info.type字段，即client->name
                                            struct  i2c_client  *client;
                                            client  =  i2c_new_device(adapter,  &info)  (i2c-core.c)
                                                                //用info的信息设置client //Point4
                                                                client->dev.bus  =  &i2c_bus_type
                                                                device_register(&client->dev)  (core.c)
                                                                    device_add  (core.c)
                                                                        bus_probe_device  (bus.c)
                                                                            device_attach  (bus.c)
                                                                                device_attach  (db.c)
                                                                                    bus_for_each_drv(dev->bus,  NULL,  dev,  __device_attach)  (bus.c)
                                                                                        fn(drv,  data)
                                                                                        <=>__device_attach  (db.c)
                                                                                                    driver_match_device    (base.h)
                                                                                                    driver_probe_device  (db.c)
                                                                                                        really_probe  (db.c)
                                                                                                            if  (dev->bus->probe)  {    //dev->bus为i2c_bus_type,则调用i2c_device_probe
                                                                                                                ret  =  dev->bus->probe(dev);
                                                                                                                            driver->probe  (i2c-core.c)
                                                                                                                            <=>at24c08_probe  (at24c08.c)  //自定义的probe函数被调用
                                                                                                                ...
                                                                                                            }  else  if  (drv->probe)  {
                                                                                                                ret  =  drv->probe(dev);
                                                                                                                ...
                                                                                                            }
                                        list_add_tail(&client->detected,  &driver->clients);
                                        }
                                }
                            }
所以加载上面简单的at24c08.ko,运行结果就是：
at24c08_detect
at24c08_probe

三、编写程序
下面我们看看在i2c_new_device里面怎么设置client，我们必须先在自定义detect函数里设置(Point4)
client->dev.platform_data  =  info->platform_data;
client->flags  =  info->flags;
client->addr  =  info->addr;
client->irq  =  info->irq;
strlcpy(client->name,  info->type,  sizeof(client->name));

1.
at24c08_detect里，我们只需要加上
info->addr  =  client->addr;

2.
构建字符设备驱动
在at24c08_probe中添加
    register_chrdev_region(major,  1,  "at24c08");
    cdev_init(&cdev,  &at24c08_fops);
    cdev_add(&cdev,  MKDEV(major,  0),  1);
    class_register(&at24c08_cls);
    device_create(&at24c08_cls,  NULL,  MKDEV(major,  0),  NULL,  "at24c08_dev");
另外加上
#define   major  155

static  struct  class  at24c08_cls  =  {
    .name        =  "at24c08_cls",
};

static  struct  file_operations  at24c08_fops  =  {
    .owner  =  THIS_MODULE,
};

3.完善at24c08_fops
加上读写函数
.read    =  at24c08_read,
.write  =  at24c08_write,
i2c通信是通过i2c_msg传输的,
读：先从用户空间获得地址，用i2c_transfer先传地址，再接收i2c返回的数据交给用户
写：先从用户空间获得地址和写入值，用i2c_transfer传一个msg就可以了。
在这里遇到问题：i2c_tranfer需要adapter参数，并且msg需要目的地址。
这个时候应该记得driver->detect(temp_client,  kind,  &info)  Point5传到自定义的temp_client,
也就是at24c08_detect的第一个参数struct  i2c_client  *client，它里面就有adapter和addr的信息，
那么就在at24c08_detect里加上at24c08_adapter  =  client->adapter;  addr  =  bd_info->addr  =  client->addr;
需先定义
static  struct  i2c_adapter  *at24c08_adapter;
static  unsigned  short  addr;

完整的驱动程序就应该是：
#include  <linux/init.h>
#include  <linux/module.h>
#include  <linux/i2c.h>
#include  <linux/fs.h>
#include  <linux/cdev.h>
#include  <linux/device.h>
#include  <linux/kdev_t.h>
#include  <asm/uaccess.h>

#define   major  155
static  struct  i2c_driver  at24c08_driver;
static  struct  i2c_adapter  *at24c08_adapter;
static  unsigned  short  addr;
static  struct  class  at24c08_cls  =  {
    .name        =  "at24c08_cls",
};

ssize_t  at24c08_read  (struct  file  *filp,  char  __user  *buf,  size_t  sz,  loff_t  *off)
{
    struct  i2c_msg  msg[2];
    unsigned  char  args,  data;

    if  (sz  !=  1)
        return  -EINVAL;
    copy_from_user((void  *)&args,  buf,  1);
    /* 先传读地址 */
    msg[0].addr    =  addr;
    msg[0].buf    =  &args;
    msg[0].len    =  1;
    msg[0].flags    =  0;

    /* 再 读 */
    msg[1].addr    =  addr;
    msg[1].buf    =  &data;
    msg[1].len    =  1;
    msg[1].flags    =  1;        /* 读 */
    if  (2  ==  i2c_transfer(at24c08_adapter,  msg,  2))  {
        /* 读成功 */
        copy_to_user((void  *)buf,  &data,  1);
        return  1;
    }
    else
        return  -EIO;
}

ssize_t  at24c08_write  (struct  file  *filp,  const  char  __user  *buf,  size_t  sz,  loff_t  *off)
{
    struct  i2c_msg  msg;
    unsigned  char  args[2];

    copy_from_user((void  *)&args,  buf,  2);
    
    /* args[0] = addr, args[1] = val */
    msg.addr  =  addr;
    msg.buf    =  args;
    msg.len    =  2;
    msg.flags  =  0;        /* 写 */
    if(1  ==  i2c_transfer(at24c08_adapter,&msg,  1))
        return  2;
    else
        return  -EIO;
    
}

static  struct  file_operations  at24c08_fops  =  {
    .owner  =  THIS_MODULE,
    .read    =  at24c08_read,
    .write  =  at24c08_write,
};

static  struct  cdev  cdev;
static  int  at24c08_probe(struct  i2c_client  *client,  const  struct  i2c_device_id  *dev_id)
{
    register_chrdev_region(major,  1,  "at24c08");
    cdev_init(&cdev,  &at24c08_fops);
    cdev_add(&cdev,  MKDEV(major,  0),  1);
    class_register(&at24c08_cls);
    device_create(&at24c08_cls,  NULL,  MKDEV(major,  0),  NULL,  "at24c08_dev");
    return    0;
}

static  int  at24c08_remove(struct  i2c_client  *client)
{
    device_destroy(&at24c08_cls,  MKDEV(major,  0));
    class_destroy(&at24c08_cls);
    cdev_del(&cdev);
    unregister_chrdev_region(MKDEV(major,  0),  1);
    
    return    0;
}

static  int  at24c08_detect(struct  i2c_client  *client,  int  kind,  struct  i2c_board_info  *bd_info)
{
    strcpy(bd_info->type,    "at24c08");
    addr  =  bd_info->addr  =  client->addr;
    at24c08_adapter  =  client->adapter;
    return    0;
}

static  const  struct  i2c_device_id  at24c08_id[]  =  {
    {"at24c08",  0},
    {}
};

static  unsigned  short  ignore[]            =  {  I2C_CLIENT_END  };

static  const  unsigned  short  normal_i2c[]  =  {0x50,  I2C_CLIENT_END};

static  const  struct  i2c_client_address_data  addr_data  =  {
    .normal_i2c    =  normal_i2c,
    .probe        =  ignore,
    .ignore        =  ignore,
};
static  struct  i2c_driver  at24c08_driver=  {
    .probe    =  at24c08_probe,
    .remove    =  at24c08_remove,
    .driver  =  {
        .name  =  "at24c08",
    },
    .id_table    =  at24c08_id,
    .detect    =  at24c08_detect,
    .address_data    =  &addr_data,
    .class      =  I2C_CLASS_HWMON  |  I2C_CLASS_SPD,
};

static  int  at24c08_init(void)
{
    i2c_add_driver(&at24c08_driver);
    return  0;
}

static  void  at24c08_exit(void)
{
    i2c_del_driver(&at24c08_driver);
    return  ;
}

module_init(at24c08_init);
module_exit(at24c08_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("100ask.net Young");

应用程序：
#include  <stdio.h>
#include  <fcntl.h>
#include  <stdlib.h>

#define   USAGE  printf("./testapp r addr\n./testapp w addr data\n")

int  main(int  argc,  char  *argv[])
{
    int  fd;
    unsigned  char  dat[2];
    
    if  ((argc!=3)  &&  (argc!=4))  {
        USAGE;
        return  -1;
    }
    fd  =  open("/dev/at24c08_dev",  O_RDWR);
    if  (-1  ==  fd)  {
        
        printf("failed to open device.\n");
        return  -1;
    }
    if  (!strcmp(argv[1],  "r"))  {  /* 读 */
        dat[0]  =  strtoul(argv[2],  NULL,  10);
        dat[1]  =  dat[0];
        read(fd,  dat,1);
        printf("read addr%d: %c, %d, 0x%2x\n",  dat[1],  dat[0],  dat[0],  dat[0]);
    }else  if(!strcmp(argv[1],  "w"))  {  /* 写 */  
    
        dat[0]  =  strtoul(argv[2],  NULL,  10);
        dat[1]  =  strtoul(argv[3],  NULL,  10);
        write(fd,  dat,  2);
        
    }else  {
    
        USAGE;
        return  -1;
        
    }
    return  0;
}

就是有一个比较奇怪的问题，如果直接随便读一个地址A，读到的值是传送的地址A。如果先将数值B写入C地址，再读C地址就是得到B数值了。
当我卸载模块、重启机器之后再来试验，再读C地址，是正确的得到B数值，所以驱动和用户程序没问题。

2012-05-05 22:16 发表于百度空间，今搬至CU。