i2c驱动在Linux通过一个周的学习后发现i2c总线的驱动框架还是和Linux整体的驱动框架是相同的，思想并不特殊比较复杂的内容如i2c核心的内容都是内核驱动框架实现完成的，今天我们暂时只分析驱动开发需要完成的部分。iic驱动驱动开发主要是完成四个部分的内容，struct i2c_adapter（适配器），struct i2c_algorithm （通讯接口），i2c_driver（设备驱动），struct i2c_client（iic设备），其中适配器和通讯接口的实现一般SOC厂商都会针对自家的i2c控制器IP实现在Linux 内核驱动中，也就是可以参考。即使没有驱动开发人员也可以自己实现主要就是按照框架需求实现主要的接口函数就可以了。所以这里需要先明确一点的就是I2C驱动是分为总线驱动和设备驱动的，设备在I2C架构中由i2c_client描述，用户空间也可以直接使用总线驱动完成和总线上的设备的数据交换只是有些设备的i2c操作时序很复杂，如果在用户空间来操作i2c设备效率和软件分层上也是不符合常用习惯的。所以I2C的拓扑图大就是总线驱动，设备驱动和设备，设备和设备驱动都是挂接在具体的总线上的这是由硬件决定的，有了设备驱动对i2c设备的操作就编程读写普通文件一样容易从而降低了用户控件的程序开发的复杂程度并提高了执行效率。

i2c_adapter 主要是用来抽像的描述i2c控制器的，结合其中algo通讯接口部分一起组成i2c总线驱动，其中适配器具体结构体如下：

struct i2c_adapter {
struct module *owner;
unsigned int class; /* classes to allow probing for */
const struct i2c_algorithm *algo; /* the algorithm to access the bus */
void *algo_data;

/\* data fields that are valid for all devices    \*/  
struct rt\_mutex bus\_lock;

int timeout;            /\* in jiffies \*/  
int retries;  
struct device dev;        /\* the adapter device \*/

int nr;  
char name\[48\];  
struct completion dev\_released;

struct mutex userspace\_clients\_lock;  
struct list\_head userspace\_clients;

struct i2c\_bus\_recovery\_info \*bus\_recovery\_info;  

};

其中的algo 指向适配对应到的具体的硬件的操作接口封装。除此之外其中还有一些属性如retries重试次数，class 保存i2c的一些特有的属性标志。总线驱动的适配器的部分内容比较简单基本就是一些软件部分内容的实现设置；要完成i2c总线驱动部分最主要的还是硬件通讯接口的实现，这一部分是和具体的硬件相关的所以也是驱动开发的重点。i2c总线驱动将硬件操作接口抽象封装如下：

struct i2c_algorithm {
/* If an adapter algorithm can't do I2C-level access, set master_xfer
to NULL. If an adapter algorithm can do SMBus access, set
smbus_xfer. If set to NULL, the SMBus protocol is simulated
using common I2C messages */
/* master_xfer should return the number of messages successfully
processed, or a negative value on error */
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);

/\* To determine what the adapter supports \*/  
u32 (\*functionality) (struct i2c\_adapter \*);  

};

其中master_xfer接口就是i2c主机驱动传输数据的接口，包括收和发。其中smbus_xfer 用于smbus时序发送数据。因为i2c接口和smbus是相同的有些SOC的i2c外设控制器同时支持这两种时序发送数据。最后就是functionality 接口他会返回当前总线支持的通讯协议和特性。三星的实现如下，其中具体的标志的含义可以参考具体说明文档。I2C_FUNC_I2C  指示支持I2C时序，I2C_FUNC_SMBUS_EMUL  应该是支持smbus时序。

/* declare our i2c functionality */
static u32 s3c24xx_i2c_func(struct i2c_adapter *adap)
{
return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL | I2C_FUNC_NOSTART |
I2C_FUNC_PROTOCOL_MANGLING;
}

i2c总线驱动的的定义一步骤如下（前提是已经实现了接口封装中的各个通讯函数）

1. 分配内存。
2. 然后开始配置具体的成员变量。
3. 在绑定具体的接口函数即algo。

最后就是总线驱动的注册接口了由i2c内核实现，完成向内核注册增加一个I2C总线适配器。

增加适配器

int i2c_add_adapter(struct i2c_adapter * adap);

int i2c_add_adapter(struct i2c_adapter *adapter)
{
struct device *dev = &adapter->dev;
int id;
　 //设备树的方式添加设备　　
if (dev->of_node) {
id = of_alias_get_id(dev->of_node, "i2c");
if (id >= 0) {
adapter->nr = id;
return __i2c_add_numbered_adapter(adapter);
}
}
//普通将设备写在板级文件中的方式
mutex_lock(&core_lock);
//分配一个总线ID 这个ID有总线驱动子系统维护
id = idr_alloc(&i2c_adapter_idr, adapter,
__i2c_first_dynamic_bus_num, 0, GFP_KERNEL);
mutex_unlock(&core_lock);
if (id < 0)
return id;

adapter->nr = id;  
//适配器的注册，前提适配器有id  
return i2c\_register\_adapter(adapter);  

}

整个执行流程基本分为如下的过程，如果未指定适配器id则先申请ID然后就是调用i2c_register_adapter

static int i2c_register_adapter(struct i2c_adapter *adap)
{
int res = 0;

/\* Can't register until after driver model init \*/  
if (unlikely(WARN\_ON(!i2c\_bus\_type.p))) {  
    res = -EAGAIN;  
    goto out\_list;  
}

/\* Sanity checks \*/  
if (unlikely(adap->name\[0\] == '\\0')) {  
    pr\_err("i2c-core: Attempt to register an adapter with "  
           "no name!\\n");  
    return -EINVAL;  
}  
if (unlikely(!adap->algo)) {  
    pr\_err("i2c-core: Attempt to register adapter '%s' with "  
           "no algo!\\n", adap->name);  
    return -EINVAL;  
}

rt\_mutex\_init(&adap->bus\_lock);  
//这里说明用户空间是可以直接使用总线设备 来操作总线上的设备的  
mutex\_init(&adap->userspace\_clients\_lock);  
INIT\_LIST\_HEAD(&adap->userspace\_clients);  
//默认超时时间为一个系统心跳时间  
/\* Set default timeout to 1 second if not already set \*/  
if (adap->timeout == 0)  
    adap->timeout = HZ;  
//前面申请的Id，所以说ID是必须的  
dev\_set\_name(&adap->dev, "i2c-%d", adap->nr);  
//i2c\_bus\_type  i2c\_adapter\_type 都是内核实现的一些操作的封装  
adap->dev.bus = &i2c\_bus\_type;  
adap->dev.type = &i2c\_adapter\_type;  
//和普通的设备注册相同，有个疑问就是驱动何时注册的？  
res = device\_register(&adap->dev);  
if (res)  
    goto out\_list;

dev\_dbg(&adap->dev, "adapter \[%s\] registered\\n", adap->name);  
//兼容性相关  

#ifdef CONFIG_I2C_COMPAT
res = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,
adap->dev.parent);
if (res)
dev_warn(&adap->dev,
"Failed to create compatibility class link\n");
#endif
//总线恢复相关
/* bus recovery specific initialization */
if (adap->bus_recovery_info) {
struct i2c_bus_recovery_info *bri = adap->bus_recovery_info;

    if (!bri->recover\_bus) {  
        dev\_err(&adap->dev, "No recover\_bus() found, not using recovery\\n");  
        adap->bus\_recovery\_info = NULL;  
        goto exit\_recovery;  
    }

    /\* Generic GPIO recovery \*/  
    if (bri->recover\_bus == i2c\_generic\_gpio\_recovery) {  
        if (!gpio\_is\_valid(bri->scl\_gpio)) {  
            dev\_err(&adap->dev, "Invalid SCL gpio, not using recovery\\n");  
            adap->bus\_recovery\_info = NULL;  
            goto exit\_recovery;  
        }

        if (gpio\_is\_valid(bri->sda\_gpio))  
            bri->get\_sda = get\_sda\_gpio\_value;  
        else  
            bri->get\_sda = NULL;

        bri->get\_scl = get\_scl\_gpio\_value;  
        bri->set\_scl = set\_scl\_gpio\_value;  
    } else if (!bri->set\_scl || !bri->get\_scl) {  
        /\* Generic SCL recovery \*/  
        dev\_err(&adap->dev, "No {get|set}\_gpio() found, not using recovery\\n");  
        adap->bus\_recovery\_info = NULL;  
    }  
}

添加的过程删除了异常处理的部分，执行过程大致就是先初始化适配器中的核心成员包括超时，设备链表，指定总线和设备类型后注册适配器设备。剩下的就是总线恢复的一些内容可以暂时不看。除此之外上面还发现一个问题就是添加总线适配器的过程发现不知道在何时添加的总线适配器驱动。根据前面对Linux设备注册过程的了解这里先看一下设备注册过程的绑定的总线type中的match接口：

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;

/\* Attempt an OF style match \*/  
if (of\_driver\_match\_device(dev, drv))  
    return 1;

/\* Then ACPI style match \*/  
if (acpi\_driver\_match\_device(dev, drv))  
    return 1;

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;  

}

发现他在不使用设备树的情况下是通过驱动的id_table来完成设备和驱动的匹配的。继续找最后找到如下的代码在drivers\i2c\i2c-core.c 中：

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

/* We must initialize early, because some subsystems register i2c drivers
* in subsys_initcall() code, but are linked (and initialized) before i2c.
*/
postcore_initcall(i2c_init);

#define i2c_add_driver(driver) \
i2c_register_driver(THIS_MODULE, 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;  
INIT\_LIST\_HEAD(&driver->clients);

/\* 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;

/\* Drivers should switch to dev\_pm\_ops instead. \*/  
if (driver->suspend)  
    pr\_warn("i2c-core: driver \[%s\] using legacy suspend method\\n",  
        driver->driver.name);  
if (driver->resume)  
    pr\_warn("i2c-core: driver \[%s\] using legacy resume method\\n",  
        driver->driver.name);

pr\_debug("i2c-core: driver \[%s\] registered\\n", driver->driver.name);  
//如果设备先注册，则这里负责匹配  
/\* Walk the adapters that are already present \*/  
i2c\_for\_each\_dev(driver, \_\_process\_new\_driver);

return 0;  

}
//设备注册过程的一个关键代码

static int __device_attach(struct device_driver *drv, void *data)
{
struct device *dev = data;
/* 如果总线有定义mach函数则 调用总线的mach函数 这个接口由总线提供 */
if (!driver_match_device(drv, dev))
return 0;
/* 前面的匹配未成功 进一步探测*/
return driver_probe_device(drv, dev);
}

上面的代码注册了一个虚拟的I2C设备，他的作用就是产生对应的总线设备如i2c-0，i2c-1等，也就完善了Linux的驱动框架的内容有了设备（I2C适配器）和驱动(dummy_driver)。综合前面的Linux设备注册流程可以知道，适配器设备注册时会先执行总线的match接口（红色部分代码）也就是上面的i2c_device_match

接口，再看底下虚拟驱动的定义可以知道总线的匹配会失败最终执行的就是驱动自己的probe接口这里就是driver_probe_device dummy_probe接口。

static const struct i2c_device_id dummy_id[] = {
{ "dummy", 0 },
{ },
};

static int dummy_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
return 0;
}

static int dummy_remove(struct i2c_client *client)
{
return 0;
}

static struct i2c_driver dummy_driver = {
.driver.name = "dummy",
.probe = dummy_probe,
.remove = dummy_remove,
.id_table = dummy_id,
};

删除适配器

void i2c_del_adapter(struct i2c_adapter * adap)

void i2c_del_adapter(struct i2c_adapter *adap)
{
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;  
}

acpi\_i2c\_remove\_space\_handler(adap);  
/\* Tell drivers about this removal \*/  
mutex\_lock(&core\_lock);  
bus\_for\_each\_drv(&i2c\_bus\_type, NULL, adap,  
               \_\_process\_removed\_adapter);  
mutex\_unlock(&core\_lock);

/\* Remove devices instantiated from sysfs \*/  
mutex\_lock\_nested(&adap->userspace\_clients\_lock,  
          i2c\_adapter\_depth(adap));  
list\_for\_each\_entry\_safe(client, next, &adap->userspace\_clients,  
             detected) {  
    dev\_dbg(&adap->dev, "Removing %s at 0x%x\\n", client->name,  
        client->addr);  
    list\_del(&client->detected);  
    i2c\_unregister\_device(client);  
}  
mutex\_unlock(&adap->userspace\_clients\_lock);

/\* Detach any active clients. This can't fail, thus we do not  
 \* check the returned value. This is a two-pass process, because  
 \* we can't remove the dummy devices during the first pass: they  
 \* could have been instantiated by real devices wishing to clean  
 \* them up properly, so we give them a chance to do that first. \*/  
device\_for\_each\_child(&adap->dev, NULL, \_\_unregister\_client);  
device\_for\_each\_child(&adap->dev, NULL, \_\_unregister\_dummy);

#ifdef CONFIG_I2C_COMPAT
class_compat_remove_link(i2c_adapter_compat_class, &adap->dev,
adap->dev.parent);
#endif

/\* device name is gone after device\_unregister \*/  
dev\_dbg(&adap->dev, "adapter \[%s\] unregistered\\n", adap->name);

/\* wait until all references to the device are gone  
 \*  
 \* FIXME: This is old code and should ideally be replaced by an  
 \* alternative which results in decoupling the lifetime of the struct  
 \* device from the i2c\_adapter, like spi or netdev do. Any solution  
 \* should be throughly tested with DEBUG\_KOBJECT\_RELEASE enabled!  
 \*/  
init\_completion(&adap->dev\_released);  
device\_unregister(&adap->dev);  
wait\_for\_completion(&adap->dev\_released);

/\* free bus id \*/  
mutex\_lock(&core\_lock);  
idr\_remove(&i2c\_adapter\_idr, adap->nr);  
mutex\_unlock(&core\_lock);

/\* Clear the device structure in case this adapter is ever going to be  
   added again \*/  
memset(&adap->dev, 0, sizeof(adap->dev));  

}

基本的执行过程和设备的删除类似，但是增加了驱动的卸载，因为有些驱动是绑定到到要删除的适配器上的，适配器已经删除了自然需要删除相关设备。剩下的两部分就是i2c具体的设备驱动和设备的相关内容了。

不通过具体的设备驱动也是可以访问i2c设备，但是应用层就需要处理i2c设备驱动本应该处理的内容，但是此时用户空间的代码的读写写逻辑的比较复杂需要考虑设备的读写时序的问题了，这样就不符合驱动的分层考虑了。不通过具体设备直接当问i2c总线上的设备需要使用i2c核心定义一个结构体来完成对i2c具体操作的定义那就是struct i2c_msg，因为通过上面的i2c总线驱动的通讯接口部分的int(master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,int num)接口可以看出来i2c的数据传输过程就是以struct i2c_msg为单位的，这个结构在用户空间也是可以使用的，所以用户可以直接通过总线完成和总线上挂接的设备进行数据交互（有条件的）。这里先解释正常情况下的设备操作方式---通过对应的设备驱动来操作设备，而设备驱动实际上最后也是调用的适配器的algo 句柄指向的master_xfer接口来实现数据传输。i2c设备的注册在系统的板级文件中实现通过struct i2c_board_info 结构进行定义然后通过i2c_register_board_info 进行注册需要注意的是设备的添加要遭遇驱动的注册，因为阅读源码发现设备添加时未进行驱动匹配代码如下

int __init
i2c_register_board_info(int busnum,
struct i2c_board_info const *info, unsigned len)
{
int status;

down\_write(&\_\_i2c\_board\_lock);

/\* dynamic bus numbers will be assigned after the last static one \*/  
if (busnum >= \_\_i2c\_first\_dynamic\_bus\_num)  
    \_\_i2c\_first\_dynamic\_bus\_num = busnum + 1;

for (status = 0; len; len--, info++) {  
    struct i2c\_devinfo    \*devinfo;

    devinfo = kzalloc(sizeof(\*devinfo), GFP\_KERNEL);  
    if (!devinfo) {  
        pr\_debug("i2c-core: can't register boardinfo!\\n");  
        status = -ENOMEM;  
        break;  
    }

    devinfo->busnum = busnum;  
    devinfo->board\_info = \*info;  
    list\_add\_tail(&devinfo->list, &\_\_i2c\_board\_list);  
}

up\_write(&\_\_i2c\_board\_lock);

return status;  

}

然后就是struct i2c_board_info和struct i2c_msg的定义了如下：

struct i2c_board_info {
char type[I2C_NAME_SIZE];
unsigned short flags;
unsigned short addr;
void *platform_data;
struct dev_archdata *archdata;
struct device_node *of_node;
struct acpi_dev_node acpi_node;
int irq;
};

这里可以参考后面的struct i2c_client 的结构进行分析。

struct i2c_msg {
__u16 addr; /* slave address */
__u16 flags;
#define I2C_M_TEN 0x0010 /* this is a ten bit chip address */
#define I2C_M_RD 0x0001 /* read data, from slave to master */
#define I2C_M_STOP 0x8000 /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_NOSTART 0x4000 /* if I2C_FUNC_NOSTART */
#define I2C_M_REV_DIR_ADDR 0x2000 /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_IGNORE_NAK 0x1000 /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_NO_RD_ACK 0x0800 /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_RECV_LEN 0x0400 /* length will be first received byte */
__u16 len; /* msg length */
__u8 *buf; /* pointer to msg data */
};

很简单就三个成员，然后再来看i2c设备驱动的部分。

i2c设备驱动就是针对一个特定的设备定义一种操作接口由用户接口通过vfs接口调用从而完成对指定设备的读写操作，读写寄存器或存储空间的内容。他的定义如下

struct i2c_driver {
unsigned int class;

/\* Notifies the driver that a new bus has appeared. You should avoid  
 \* using this, it will be removed in a near future.  
 \*/  
int (\*attach\_adapter)(struct i2c\_adapter \*) \_\_deprecated;

/\* Standard driver model interfaces \*/  
int (\*probe)(struct i2c\_client \*, const struct i2c\_device\_id \*);  
int (\*remove)(struct i2c\_client \*);

/\* driver model interfaces that don't relate to enumeration  \*/  
void (\*shutdown)(struct i2c\_client \*);  
int (\*suspend)(struct i2c\_client \*, pm\_message\_t mesg);  
int (\*resume)(struct i2c\_client \*);

/\* Alert callback, for example for the SMBus alert protocol.  
 \* The format and meaning of the data value depends on the protocol.  
 \* For the SMBus alert protocol, there is a single bit of data passed  
 \* as the alert response's low bit ("event flag").  
 \*/  
void (\*alert)(struct i2c\_client \*, unsigned int data);

/\* a ioctl like command that can be used to perform specific functions  
 \* with the device.  
 \*/  
int (\*command)(struct i2c\_client \*client, unsigned int cmd, void \*arg);

struct device\_driver driver;  
const struct i2c\_device\_id \*id\_table;

/\* Device detection callback for automatic device creation \*/  
int (\*detect)(struct i2c\_client \*, struct i2c\_board\_info \*);  
const unsigned short \*address\_list;  
struct list\_head clients;  

};

看起来是不是和设备驱动很相似，确实这也是linux内核驱动框架的抽象意义。如果熟悉前面的platform_driver的初始化和添加流程这里也是类似的。基本上也是用户完成一些接口的实现然后绑定到指定的驱动成员上最后调用驱动注册接口。如下这是我自己实现的At24cxx系列eeprom的i2c设备驱动。

static struct i2c_driver eerom_driver = {
.driver = {
.name = "at24xx",
},
.id_table = at24c0xx_idtable,
.probe = at24c0xx_probe,
.remove = at24c0xx_remove,
};

int __init eeprom_i2c_driver_init(void)
{
int retval;

retval=i2c\_add\_driver(&eerom\_driver);  
if(retval)  
{  
    printk(KERN\_INFO "eeprom\_i2c\_driver\_init fail\\n");  
}  
return 0;  

}

重点是驱动和设备的匹配操作这里和platform驱动和设备的match还是有一定的的差别的，通过i2c_add_driver 添加设备驱动到i2c总线，所有的i2c适配器都在同一个总线，由设备信息确定设备在哪一个适配器上。当驱动注册后会执行总线的match函数具体如下

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;

/\* Attempt an OF style match \*/  
if (of\_driver\_match\_device(dev, drv))  
    return 1;

/\* Then ACPI style match \*/  
if (acpi\_driver\_match\_device(dev, drv))  
    return 1;

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;  

}

通过代码可以发现匹配规则除了类似platform总线的设备树和acpi模式外只支持id_table的方式匹配设备。match完成匹配后就会执行i2c总线的探测函数探测驱动和设备。总线的probe函数最后还是会调用driver的probe接口完成设备的探测。

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;

if (!device\_can\_wakeup(&client->dev))  
    device\_init\_wakeup(&client->dev,  
                client->flags & I2C\_CLIENT\_WAKE);  
dev\_dbg(dev, "probe\\n");

acpi\_dev\_pm\_attach(&client->dev, true);  
status = driver->probe(client, i2c\_match\_id(driver->id\_table, client));  
if (status)  
    acpi\_dev\_pm\_detach(&client->dev, true);

return status;  

}

具体的probe接口就可以定义软件接口进行一系列的接口配置将用户的vfs接口映射到i2c总线的读写。下面拿我自己实现的一个eeprom的读写驱动接口实例来分析。主要看probe接口

#define BUFF_SIZE 64
#define EEPROM_PAGE_SIZE 8
#define LEN_GET(index,len) \
(((index+EEPROM_PAGE_SIZE)<(len))?(EEPROM_PAGE_SIZE):(len-index))

enum type
{
at24c01x,
at24c02x,
at24c04x,
at24c08x,
at24c16x,
};

enum mem_size
{
AT24C01=(1<<10),
AT24C02=(2<<10),
AT24C04=(4<<10),
AT24C08=(8<<10),
AT24C16=(16<<10),
};

struct eeprom_chip {
struct miscdevice devmisc;
struct i2c_client *client;
struct iic_ops *ops;
struct device *dev;
struct mutex eeprom_mutex;
char buf[BUFF_SIZE];
enum mem_size memsize;
uint8_t is_open;
kernel_ulong_t eeprom_type;

};

struct iic_ops{
int (*send)(struct eeprom_chip *, size_t,short);
int (*recv)(struct eeprom_chip *, size_t,short);
};

static struct i2c_device_id at24c0xx_idtable[] = {

    { "24c04x", at24c04x},

    { "24c08x",at24c08x},

    { "24c16x",at24c16x},

    { }

};

static struct i2c_driver eerom_driver = {

    .driver = {

        .name   = "at24xx",

    },

    .id_table   = at24c0xx_idtable,

    .probe      = at24c0xx_probe,

    .remove     = at24c0xx_remove,

};

probe接口的实现主要是通过增加中间层使用了杂项设备驱动，将vfs的读写接口传递到i2c总线上的读写接口从而实现读写eeprom就如同读写一个普通文件一样简单，从而简化了用户空间的调用逻辑。

static int at24c0xx_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc;
struct eeprom_chip *eeprom;
struct device *dev = &client->dev;
/* check function*/
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
return -ENODEV;
eeprom = devm_kzalloc(&client->dev,sizeof(struct eeprom_chip), GFP_KERNEL);
if (eeprom == NULL) {
printk(KERN_INFO "failed to create our eeprom_data\n");
return -ENOMEM;
}
eeprom->eeprom_type = id->driver_data;
eeprom->dev=get_device(dev);
eeprom->client = client;
eeprom->ops = &iic_ops;
eeprom->devmisc.fops = &eeprom_ops;
eeprom->devmisc.minor = 223;
eeprom->devmisc.name=client->name;
eeprom->devmisc.parent = eeprom->dev;
eeprom->memsize = get_eeprom_memsize(eeprom->eeprom_type);
// printk(KERN_INFO "I2C:at24c0x:%d byte\n",eeprom->memsize);
mutex_init(&eeprom->eeprom_mutex);
rc = misc_register(&eeprom->devmisc);
if (rc) {
printk(KERN_INFO "%s client created misc_register Fail\n",client->name);
}
i2c_set_clientdata(client, eeprom);
/* rest of the initialisation goes here. */
// printk(KERN_INFO "%s client created\n",client->name);

return 0;  

}

全部驱动代码，设备就是Linux3-16-57版本内核的三星的smdkv210的板级文件添加的修改了一下兼容属性，从而使当前驱动可以匹配上。

1 #include
2 #include
3 #include
4 #include
5 #include
6 #include
7 #include
8 #include
9 #include
10 #include
11 #include
12 #include
13 #include
14 #include
15 #include
16 #include
17 #include
18 #include
19 #include
20 #include
21 #include
22
23 #define BUFF_SIZE 64
24 #define EEPROM_PAGE_SIZE 8
25 #define LEN_GET(index,len) \
26 (((index+EEPROM_PAGE_SIZE)<(len))?(EEPROM_PAGE_SIZE):(len-index)) 27 28 enum type 29 { 30 at24c01x, 31 at24c02x, 32 at24c04x, 33 at24c08x, 34 at24c16x, 35 }; 36 37 enum mem_size 38 { 39 AT24C01=(1<<10), 40 AT24C02=(2<<10), 41 AT24C04=(4<<10), 42 AT24C08=(8<<10), 43 AT24C16=(16<<10), 44 }; 45 46 struct eeprom_chip { 47 struct miscdevice devmisc; 48 struct i2c_client *client; 49 struct iic_ops *ops; 50 struct device *dev; 51 struct mutex eeprom_mutex; 52 char buf[BUFF_SIZE]; 53 enum mem_size memsize; 54 uint8_t is_open; 55 kernel_ulong_t eeprom_type; 56 57 }; 58 59 struct iic_ops{ 60 int (*send)(struct eeprom_chip *, size_t,short); 61 int (*recv)(struct eeprom_chip *, size_t,short); 62 }; 63 64 static enum mem_size get_eeprom_memsize(enum type type) 65 { 66 enum mem_size mem_size; 67 switch(type) 68 { 69 case at24c01x: 70 mem_size = AT24C01; 71 break; 72 case at24c02x: 73 mem_size = AT24C02; 74 break; 75 case at24c04x: 76 mem_size = AT24C04; 77 break; 78 case at24c08x: 79 mem_size = AT24C08; 80 break; 81 case at24c16x: 82 mem_size = AT24C16; 83 break; 84 default: 85 mem_size = AT24C01; 86 break; 87 } 88 return mem_size; 89 } 90 91 static short get_device_addr(struct eeprom_chip *chip,short pos) 92 { 93 short addr_dataaddr; 94 struct i2c_client *client = chip->client;
95 addr_dataaddr =client->addr;
96
97 if(chip->eeprom_type <= at24c04x) 98 { 99 addr_dataaddr =addr_dataaddr|(pos&0x100); 100 }else if (chip->eeprom_type == at24c08x){
101 addr_dataaddr =addr_dataaddr|(pos&0x300);
102 }else if (chip->eeprom_type == at24c16x){
103 addr_dataaddr =addr_dataaddr|(pos&0x700);
104 }
105 return addr_dataaddr;
106 }
107 static int i2c_eeprom_write(struct eeprom_chip *chip, size_t len,short pos)
108 {
109 char w_buf[10];
110 int status,i=0,ret=0;
111 short page_cnt,write_index=0;
112 short align_pos = ((pos+EEPROM_PAGE_SIZE-1)/8)*8;
113 struct i2c_client *client = chip->client;
114 struct i2c_msg msg={
115 .flags = I2C_M_NOSTART,
116 .buf = w_buf,
117 };
118 if(align_pos == pos){
119 page_cnt = ((len+EEPROM_PAGE_SIZE-1)/8);
120 }else{
121 page_cnt = 1+((len-(align_pos-pos)+EEPROM_PAGE_SIZE-1)/8);
122 }
123 for(i=0;ibuf[write_index],msg.len);
133 write_index += msg.len-1;
134 // w_buf[msg.len] = '\0';
135 // printk(KERN_INFO "%02x\n",w_buf[0]);
136 // printk(KERN_INFO "%s\n",&w_buf[1]);
137 status = i2c_transfer(client->adapter,&msg,1);
138 if(status)
139 {
140 ret+=msg.len-1;
141 }
142 mdelay(1);
143 }
144 memset(chip->buf,0,BUFF_SIZE);
145 return ret;
146 }
147
148 static int i2c_eeprom_read(struct eeprom_chip *chip, size_t count,short pos)
149 {
150 int rc;
151 u8 data_addr = 0xFF&pos;
152 struct i2c_client *client = chip->client;
153
154 struct i2c_msg msg[]={
155 [0]={
156 .addr = get_device_addr(chip,pos),
157 .flags = client->flags & I2C_M_TEN,
158 .len = 1,
159 .buf = &data_addr,
160 },
161 [1]={
162 .addr = get_device_addr(chip,pos),
163 .flags = I2C_M_RD,
164 .len = count,
165 .buf = chip->buf,
166 },
167 };
168 rc= i2c_transfer(client->adapter,msg,2);
169 if(rc==2)
170 return count;
171 return 0;
172 }
173
174 static int eeprom_open(struct inode *inode,struct file *filp)
175 {
176 struct miscdevice *misc = filp->private_data;
177 struct eeprom_chip* chip = container_of(misc, struct eeprom_chip,
178 devmisc);
179 // printk(KERN_INFO "eeprom_open\n");
180 if(chip->is_open){
181 // printk(KERN_INFO "eeprom_open busy\n");
182 return -EBUSY;
183 }
184 filp->private_data = chip;
185 chip->is_open = 1;
186 return 0;
187 }
188
189 static ssize_t eeprom_read(struct file* filp,char* __user buf,size_t cnt,loff_t *offt)
190 {
191 int ret,count;
192 loff_t new_pos = *offt +cnt;
193 struct eeprom_chip* chip = filp->private_data;
194 // printk(KERN_INFO "eeprom_read\n");
195 if(new_pos>chip->memsize)
196 {
197 // printk(KERN_INFO "eeprom_open mem\n");
198 return -ENOMEM;
199 }
200 if(cnt > BUFF_SIZE)
201 {
202 // printk(KERN_INFO "eeprom_open mem\n");
203 return -ENOMEM;
204 }
205 // printk(KERN_INFO "position is %ld\n",(size_t)*offt);
206 mutex_lock(&chip->eeprom_mutex);
207 count=chip->ops->recv(chip,cnt, *offt);
208 // printk(KERN_INFO "chip->ops->recv return %d\n",count);
209 ret = copy_to_user((void*)buf,(void*)chip->buf,count);
210 if(ret){
211 return -EIO;
212 }
213 mutex_unlock(&chip->eeprom_mutex);
214 *offt += count;
215 return count;
216 }
217
218 static ssize_t eeprom_write(struct file* filp,const char*__user buf,size_t cnt ,loff_t *offt)
219 {
220 int ret;
221 loff_t new_pos = *offt +cnt;
222 struct eeprom_chip* chip = filp->private_data;
223 // printk(KERN_INFO "eeprom_write\n");
224 if(new_pos>chip->memsize)
225 {
226 // printk(KERN_INFO "eeprom_open mem\n");
227 return -ENOMEM;
228 }
229 if(cnt>BUFF_SIZE)
230 {
231 // printk(KERN_INFO "eeprom_open mem\n");
232 return -ENOMEM;
233 }
234 // printk(KERN_INFO "position is %ld\n",(size_t)*offt);
235 ret=copy_from_user((void*)chip->buf,(void*)buf,cnt);
236 if(ret){
237 return -EIO;
238 }
239 mutex_lock(&chip->eeprom_mutex);
240 ret=chip->ops->send(chip,cnt,*offt);
241 // printk(KERN_INFO "chip->ops-> send %d\n",ret);
242 mutex_unlock(&chip->eeprom_mutex);
243 *offt += ret;
244 return ret;
245 }
246
247 static loff_t eeprom_llseek(struct file *filp,loff_t vel,int orig )
248 {
249
250 struct eeprom_chip* chip = filp->private_data;
251 mutex_lock(&chip->eeprom_mutex);
252 switch (orig)
253 {
254 //cur
255 case 1:
256 if( (filp->f_pos + vel) < 0 || (filp->f_pos + vel)>chip->memsize)
257 return -ESPIPE;
258 filp->f_pos += vel;
259 /* code */
260 break;
261 //end
262 case 2:
263 if(vel > 0||(vel+filp->f_pos)<0) 264 return -ESPIPE; 265 filp->f_pos += vel;
266 /* code */
267 break;
268 //set
269 default:
270 if(vel>chip->memsize || vel<0) 271 return -ESPIPE; 272 filp->f_pos = vel;
273 break;
274 }
275 mutex_unlock(&chip->eeprom_mutex);
276 return 0;
277 }
278
279 static int eeprom_close(struct inode *inode,struct file *filp)
280 {
281
282 struct eeprom_chip* chip = filp->private_data;
283 filp->private_data = NULL;
284 // printk(KERN_INFO "eeprom_close\n");
285 chip->is_open = 0;
286
287 return 0;
288 }
289
290 struct file_operations eeprom_ops={
291 .owner = THIS_MODULE,
292 .open = eeprom_open,
293 .write = eeprom_write,
294 .read = eeprom_read,
295 .llseek = eeprom_llseek,
296 .release = eeprom_close ,
297 };
298
299 struct iic_ops iic_ops={
300 .recv = i2c_eeprom_read,
301 .send = i2c_eeprom_write,
302 };
303 static struct i2c_device_id at24c0xx_idtable[] = {
304 { "24c04x", at24c04x},
305 { "24c08x",at24c08x},
306 { "24c16x",at24c16x},
307 { }
308 };
309
310 static int at24c0xx_probe(struct i2c_client *client,
311 const struct i2c_device_id *id)
312 {
313 int rc;
314 struct eeprom_chip *eeprom;
315 struct device *dev = &client->dev;
316 /* check function*/
317 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C))
318 return -ENODEV;
319 eeprom = devm_kzalloc(&client->dev,sizeof(struct eeprom_chip), GFP_KERNEL);
320 if (eeprom == NULL) {
321 printk(KERN_INFO "failed to create our eeprom_data\n");
322 return -ENOMEM;
323 }
324 eeprom->eeprom_type = id->driver_data;
325 eeprom->dev=get_device(dev);
326 eeprom->client = client;
327 eeprom->ops = &iic_ops;
328 eeprom->devmisc.fops = &eeprom_ops;
329 eeprom->devmisc.minor = 223;
330 eeprom->devmisc.name=client->name;
331 eeprom->devmisc.parent = eeprom->dev;
332 eeprom->memsize = get_eeprom_memsize(eeprom->eeprom_type);
333 // printk(KERN_INFO "I2C:at24c0x:%d byte\n",eeprom->memsize);
334 mutex_init(&eeprom->eeprom_mutex);
335 rc = misc_register(&eeprom->devmisc);
336 if (rc) {
337 printk(KERN_INFO "%s client created misc_register Fail\n",client->name);
338 }
339 i2c_set_clientdata(client, eeprom);
340 /* rest of the initialisation goes here. */
341 // printk(KERN_INFO "%s client created\n",client->name);
342
343 return 0;
344 }
345
346 static int at24c0xx_remove(struct i2c_client *client)
347 {
348 struct eeprom_chip *eeprom = i2c_get_clientdata(client);
349 struct device *dev = &client->dev;
350 misc_deregister(&eeprom->devmisc);
351 put_device(dev);
352 return 0;
353 }
354
355 static struct i2c_driver eerom_driver = {
356 .driver = {
357 .name = "at24xx",
358 },
359 .id_table = at24c0xx_idtable,
360 .probe = at24c0xx_probe,
361 .remove = at24c0xx_remove,
362 /* if device autodetection is needed: */
363 // .class = I2C_CLASS_SOMETHING,
364 // .detect = at24_detect,
365 // .address_list = normal_i2c,
366 };
367
368 int __init eeprom_i2c_driver_init(void)
369 {
370 int retval;
371
372 retval=i2c_add_driver(&eerom_driver);
373 if(retval)
374 {
375 printk(KERN_INFO "eeprom_i2c_driver_init fail\n");
376 }
377 // printk(KERN_INFO "i2c_add_driver eerom_driver\n");
378 return 0;
379 }
380
381 void __exit eeprom_i2c_driver_exit(void)
382 {
383 i2c_del_driver(&eerom_driver);
384 }
385
386 module_init(eeprom_i2c_driver_init);
387 module_exit(eeprom_i2c_driver_exit);
388
389 MODULE_LICENSE("GPL");
390 MODULE_DESCRIPTION("This is an general driver of atmel eeprom 24xx");
391 MODULE_VERSION("0.1");
392 MODULE_AUTHOR("smile");

i2c-at24c0x_driver.c

设备添加部分

static struct i2c_board_info smdkv210_i2c_devs0[] __initdata = {
{ I2C_BOARD_INFO("24c08x", 0x50), }, /* Samsung S524AD0XD1 */
{ I2C_BOARD_INFO("wm8580", 0x1b), },
};

通过这一段的学习发现Linux驱动基本都是多元部分的组合实现，学习过程是一个拼积木的过程各个部分的小知识点的不断累计最后才能看明白内核中别人实现好的一个驱动，所以后面准备回头在去看看基础的部分，如内核内部的并发控制，同步异步IO的实现，阻塞和非阻塞、中断等一些基本但是非常通用的知识点内容从而巩固整体驱动开发知识体系的完善，加深Linux驱动框架的理解，从而在驱动开发上更加自由灵活也对应用的开发提供内核实现机制的深入理解基础。

2020-07-26 10:24:18