I2C驱动学习笔记
一、I2C基本知识
i2c总线是philips公司推出的一种串行总线。是具备多主机系统所需的，包括总线裁决和高低带器件同步功能的高性能串行总线。
i2c总线有两根双向信号线，一根是数据线SDA，另一根是时钟线SCL，两线都是开漏输出，要接上拉电阻（典型10K）。
3种数据传输模式：标准模式（100Kb/s）,快速模式（400Kb/s）,高速模式（3.4Mb/s）
每一个器件都有自己的地址。
工作模式：主发送，主接收，从发送，从接收。
数据格式：SDA线上的数据在SCL的高电平期间必须保持稳定，所心只SDA线上的数据只能在SCL线的低电平时改变。开始信号：SCL为高电平时，SDA线由高电平变为低电平。停止信号：SCL为高电平时，SDA线由低电平变为高电平。I2C总线中数据和地址都以字节为单位传送的，发送器每发送一个字节后，在时钟的第9个时钟脉冲期间释放总线，由从接收器发送一个ACK（SDA拉低）来确认数据传送成功。主机发送STOP来停止通信。主接收器接收到最后一个字节后发送NACK(SDA线为高电平)，以确认接收完成。接着发送stop以停止通信。I2C分7位和10位两种寻址方式。通信时，发送的第一个字节是器件地址，无论是哪种寻址，第一个字节的最后一位为0，表示传送的是地址。10位寻址的前5位为11110。传送完地址后，从机会发送ack信号，然后主机再发送字节地址，从机发送ack信号。如果此时要写数据，则直接传送数据，如果为读数据，则要重新发送一次启动信号，和器件地址，但第一个字节变为1，之后再接到ack信号后，开始传送数据。也就是说读数据时，传送了两次设备地址。
二、I2C体系结构
Linux的i2c体系结构有3部分组成
1）I2C核心：提供了总线和设备驱动的注册和注销办法，I2C通信方法等。
2）I2C总线驱动：I2C硬件体系结构中适配器端的实现。主要包含两个数据结构i2c_adapter,algorithm和产生通信信号的函数。经过这一层的驱动代码，可以控制i2c适配器以主控的方式产生开始位、停止位，读写周期等。
3）I2C设备驱动：I2C硬件体系结构中设备端的实现。设备要挂接在受CPU控制的i2c适配器上，通过i2c适配器与CPU交换数据。
i2c设备驱动主要包含了数据结构i2c_driver和i2c_client。在linux2.6内核中，所有的i2c设备都在sysfs文件系统中显示。
4个重要的数据结构
struct i2c_adapter {
struct module *owner;
unsigned int id;
unsigned int class;
const struct i2c_algorithm *algo; /* the algorithm to access the bus */
void *algo_data;
/* --- administration stuff. */
int (*client_register)(struct i2c_client *);
int (*client_unregister)(struct i2c_client *);
/* data fields that are valid for all devices */
u8 level; /* nesting level for lockdep */
struct mutex bus_lock;
struct mutex clist_lock;
int timeout;
int retries;
struct device dev; /* the adapter device */
int nr;
struct list_head clients; /* DEPRECATED */
char name[48];
struct completion dev_released;
};
i2c_adapter对应于物理上的一个适配器
algo,总线通信方法结构体指针
algo_data,私有数据结构指针
client_register,client注册时调用
client_unregister,client注销时调用
retries,重试次数
dev，适配器设备
name,适配器名称
clien,client链表头
struct i2c_algorithm {
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 *);
};
SMbus_xfer对应SMbus,它是I2C总线的一个子集。
一个i2c适配器需要i2c_algorithm中提供的通信函数来控制适配器上产生特定的周期访问。
master_xfer()用于产生i2c访问周期需要的信号，以i2c_msg为单位。
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_NOSTART 0x4000 /* if I2C_FUNC_PROTOCOL_MANGLING */
#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 */
};
struct i2c_driver {
int id;
unsigned int class;
int (*attach_adapter)(struct i2c_adapter *);
int (*detach_adapter)(struct i2c_adapter *);
int (*detach_client)(struct i2c_client *);
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 *);
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 *, int kind, struct i2c_board_info *);
const struct i2c_client_address_data *address_data;
struct list_head clients;
};
i2c_driver对应一套驱动方法，id_table是该驱动所支持的i2c设备的ID表。
struct i2c_client {
unsigned short flags; /* div., see below */
unsigned short addr; /* chip address - NOTE: 7bit */
/* addresses are stored in the */
/* _LOWER_ 7 bits */
char name[I2C_NAME_SIZE];
struct i2c_adapter *adapter; /* the adapter we sit on */
struct i2c_driver *driver; /* and our access routines */
struct device dev; /* the device structure */
int irq; /* irq issued by device */
struct list_head list; /* DEPRECATED */
struct list_head detected;
struct completion released;
};
addr,低7位芯片地址
name,设备名称
adapter,依附的i2c_adapter
driver,依附的i2c_driver
irq,设备使用的中断号
i2c_client,对应一个真实的物理设备。每一个i2c设备都需要一个i2c_client来描述。i2c_client信息通常在BSP板文件中通过i2c_board_info填充。
struct i2c_board_info {
char type[I2C_NAME_SIZE];
unsigned short flags;
unsigned short addr;
void *platform_data;
int irq;
};
在i2c总线驱动i2c_bus_type的mach()函数会调用i2c_match_id()函数匹配板文件定义的ID和i2c_driver所支持的ID表
i2c_client依附于i2c_adapter。由于一个适配器可以连接多个I2C设备，所以i2c_adpater也可以被多个i2c_client依附，i2c_adapter中包括依附于它的i2c_client的链表。
三、编写I2C驱动
有两方面工作：
1. 编写总线驱动
n 申请，初始化硬件资源
n i2c_adapter数据结构添加删除
n 提供适配器的algorithm的master_xfer指针
2. 编写设备驱动
n 填充i2c_driver结构，并实现其结构成员。
n 注册或注销i2c_driver
总线驱动，即适配器驱动作用，是将设备挂载到总线，实现设备与总线的交互。而设备自身的操作还是依赖于设备驱动。在总线驱动与设备驱动关联中还有一个i2c核心，提供了linux内核与i2c总线驱动，设备驱动之间联系的实现方法。
关于i2c核心中的几个重要操作函数
增加/删除i2c_adapter
int i2c_add_adapter(struct i2c_adapter *adap);
int i2c_del_adapter(struct i2c_adapter *adap);
增加/删除i2c_driver
int i2c_register_driver(struct module *owner,struct i2c_driver *driver);
int i2c_del_driver(struct i2c_driver *driver);
inline int i2c_add_driver(struct i2c_driver *driver);
增加/删除i2c_client
int i2c_attach_client(struct i2c_client *client);
int i2c_detach_client(struct i2c_client *client);
I2C传输、发送和接收
int i2c_transfer(struct i2c_adapter *adap,struct i2c_msg *msgs,int num);
int i2c_master_send(struct i2c_client *client,const char *buf,int count);
int i2c_master_recv(struct i2c_client *client,char *buf,int count);
实例
总线驱动（drivers/i2c/busses/i2c-pnx.c）
i2c适配器的加载与卸载
static int __init i2c_adap_pnx_init(void)
{
return platform_driver_register(&i2c_pnx_driver);
}
static void __exit i2c_adap_pnx_exit(void)
{
platform_driver_unregister(&i2c_pnx_driver);
}
i2c_pnx_driver的定义
static struct platform_driver i2c_pnx_driver = {
.driver = {
.name = "pnx-i2c",
.owner = THIS_MODULE,
},
.probe = i2c_pnx_probe,
.remove = __devexit_p(i2c_pnx_remove),
.suspend = i2c_pnx_controller_suspend,
.resume = i2c_pnx_controller_resume,
};
i2c总线驱动被平台驱动封装了一下，那么加载i2c总线时，应在probe方法里。
static int __devinit i2c_pnx_probe(struct platform_device *pdev)
{
unsigned long tmp;
int ret = 0;
/*以下是i2c_pnx_algo_data的定义，这些数据可以自定义
struct i2c_pnx_algo_data {
u32 base;
u32 ioaddr;
int irq;
struct i2c_pnx_mif mif;
int last;
}; */
struct i2c_pnx_algo_data *alg_data;
int freq_mhz;
/*以下是i2c_pnx_data的定义
struct i2c_pnx_data {
int (*suspend) (struct platform_device *pdev, pm_message_t state);
int (*resume) (struct platform_device *pdev);
u32 (*calculate_input_freq) (struct platform_device *pdev);
int (*set_clock_run) (struct platform_device *pdev);
int (*set_clock_stop) (struct platform_device *pdev);
struct i2c_adapter *adapter;
}; */
struct i2c_pnx_data *i2c_pnx = pdev->dev.platform_data;
struct i2c_client *client;
// printk("guojun i2c: %d, %s \n", pdev->id, i2c_pnx->adapter->name);
if (!i2c_pnx || !i2c_pnx->adapter) {
dev_err(&pdev->dev, "%s: no platform data supplied\n",
__func__);
ret = -EINVAL;
goto out;
}
platform_set_drvdata(pdev, i2c_pnx);
/*device结构体有两个指针成员driver_data和platform_data。此时是将platform_data的指针和driver_data的指针指向同一个位置。因为platform_data在BSP板上已经初始化过，所以此处的作用即初始化driver_data */
//总线设备驱动中申请硬件资源。
if (i2c_pnx->calculate_input_freq)
freq_mhz = i2c_pnx->calculate_input_freq(pdev);
/*根据pdev->id成员，获得设备的时钟*/
else {
freq_mhz = PNX_DEFAULT_FREQ;
dev_info(&pdev->dev, "Setting bus frequency to default value: "
"%d MHz\n", freq_mhz);
}
i2c_pnx->adapter->algo = &pnx_algorithm;
//根据pnx_algorithm可以将数据控制成i2c总线要求的数据格式。
alg_data = i2c_pnx->adapter->algo_data;
//这是一个私有数据结构，一般用来传递一些指针
init_timer(&alg_data->mif.timer);
alg_data->mif.timer.function = i2c_pnx_timeout;
alg_data->mif.timer.data = (unsigned long)i2c_pnx->adapter;
//初始化一个定时器，以及和定时器相关联的函数
//申请完时钟，下一步申请I/O
/* Register I/O resource */
if (!request_region(alg_data->base, I2C_PNX_REGION_SIZE, pdev->name)) {
dev_err(&pdev->dev,
"I/O region 0x%08x for I2C already in use.\n",
alg_data->base);
ret = -ENODEV;
goto out_drvdata;
}
//在platform_device结构中，有一个resource结构，它也可以用来记录所需要的I/O资源。
if (!(alg_data->ioaddr =
(u32)ioremap(alg_data->base, I2C_PNX_REGION_SIZE))) {
dev_err(&pdev->dev, "Couldn't ioremap I2C I/O region\n");
ret = -ENOMEM;
goto out_release;
}
i2c_pnx->set_clock_run(pdev);
/*
* Clock Divisor High This value is the number of system clocks
* the serial clock (SCL) will be high.
* For example, if the system clock period is 50 ns and the maximum
* desired serial period is 10000 ns (100 kHz), then CLKHI would be
* set to 0.5*(f_sys/f_i2c)-2=0.5*(20e6/100e3)-2=98. The actual value
* programmed into CLKHI will vary from this slightly due to
* variations in the output pad's rise and fall times as well as
* the deglitching filter length.
*/
tmp = ((freq_mhz * 1000) / I2C_PNX_SPEED_KHZ) / 2 - 2;
iowrite32(tmp, I2C_REG_CKH(alg_data));
iowrite32(tmp, I2C_REG_CKL(alg_data));
iowrite32(mcntrl_reset, I2C_REG_CTL(alg_data));
if (wait_reset(I2C_PNX_TIMEOUT, alg_data)) {
ret = -ENODEV;
goto out_unmap;
}
//将I2C时钟设置为I2C_PNX_SPEED_KHZ
init_completion(&alg_data->mif.complete);
//初始化完成量
ret = request_irq(alg_data->irq, i2c_pnx_interrupt,
0, pdev->name, i2c_pnx->adapter);
if (ret)
goto out_clock;
//申请中断
/* Register this adapter with the I2C subsystem */
i2c_pnx->adapter->dev.parent = &pdev->dev;
//此处将i2c适配器连接到平台设备下
ret = i2c_add_adapter(i2c_pnx->adapter);
//申请完并初始化硬件资源后添加adapter结构体，从而完成I2C总线设备驱动的前两步
if (ret < 0) {
dev_err(&pdev->dev, "I2C: Failed to add bus\n");
goto out_irq;
}
dev_dbg(&pdev->dev, "%s: Master at %#8x, irq %d.\n",
i2c_pnx->adapter->name, alg_data->base, alg_data->irq);
#if 1
if (pdev->id == 1) { //I2C2
struct i2c_board_info info = {
I2C_BOARD_INFO("pcf8563", 0xa3 >> 1),
};
client = i2c_new_device(i2c_pnx->adapter, &info);
if (client == NULL) {
printk("check pcf8563 faile \n");
}
}
#endif
// printk("i2c go on \n");
return 0;
out_irq:
free_irq(alg_data->irq, alg_data);
out_clock:
i2c_pnx->set_clock_stop(pdev);
out_unmap:
iounmap((void *)alg_data->ioaddr);
out_release:
release_region(alg_data->base, I2C_PNX_REGION_SIZE);
out_drvdata:
platform_set_drvdata(pdev, NULL);
out:
return ret;
}
还有第三步，完成i2c_agorithm算法。其实就是完成其中两个结构成员：master_xfer和functionality两个函数
static struct i2c_algorithm pnx_algorithm = {
.master_xfer = i2c_pnx_xfer,
.functionality = i2c_pnx_func,
};
static u32 i2c_pnx_func(struct i2c_adapter *adapter)
{
return I2C_FUNC_I2C | I2C_FUNC_SMBUS_EMUL;
}
至于I2C_FUNC_I2C, I2C_FUNC_SMBUS_EMUL具体代表什么样的通信协议，再议。
static int i2c_pnx_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
{
struct i2c_msg *pmsg;
int rc = 0, completed = 0, i;
struct i2c_pnx_algo_data *alg_data = adap->algo_data;
u32 stat = ioread32(I2C_REG_STS(alg_data));
//I2C_REG_STS是一个宏，alg_data是一个结构体，最终的效果是查看位于地址
//0x400A0004地址处的i2c状态寄存器
dev_dbg(&adap->dev, "%s(): entering: %d messages, stat = %04x.\n",
__func__, num, ioread32(I2C_REG_STS(alg_data)));
bus_reset_if_active(adap);
/* Process transactions in a loop. */
//为什么要重启一次总线，有待研究
for (i = 0; rc >= 0 && i < num; i++) {
//num为传递过来参数，即msg的数量
u8 addr;
pmsg = &msgs[i];
addr = pmsg->addr;
if (pmsg->flags & I2C_M_TEN) {
dev_err(&adap->dev,
"%s: 10 bits addr not supported!\n",
adap->name);
rc = -EINVAL;
break;
}
// I2C_M_TEN这个标志应该是用来表明地址类型为10位的（未验证）
alg_data->mif.buf = pmsg->buf;
alg_data->mif.len = pmsg->len;
alg_data->mif.mode = (pmsg->flags & I2C_M_RD) ?
I2C_SMBUS_READ : I2C_SMBUS_WRITE;
alg_data->mif.ret = 0;
alg_data->last = (i == num - 1);
//以上数据用来初始化alg_data的mif,并指示未传输的msg.
dev_dbg(&adap->dev, "%s(): mode %d, %d bytes\n", __func__,
alg_data->mif.mode,
alg_data->mif.len);
i2c_pnx_arm_timer(adap);
//运行定时器，定时器处理函数为i2c_pnx_timeout，现将其代码贴出
/*----------------------------------------------------------------------------------------------
static void i2c_pnx_timeout(unsigned long data)
{
struct i2c_adapter *adap = (struct i2c_adapter *)data;
struct i2c_pnx_algo_data *alg_data = adap->algo_data;
u32 ctl;
dev_err(&adap->dev, "Master timed out. stat = %04x, cntrl = %04x. "
"Resetting master...\n",
ioread32(I2C_REG_STS(alg_data)),
ioread32(I2C_REG_CTL(alg_data)));
//读i2c总线的状态和控制寄存器信息，并将其写入stat和cntl
/* Reset master and disable interrupts */
ctl = ioread32(I2C_REG_CTL(alg_data));
ctl &= ~(mcntrl_afie | mcntrl_naie | mcntrl_rffie | mcntrl_drmie);
iowrite32(ctl, I2C_REG_CTL(alg_data));
//设置相关寄存器
ctl |= mcntrl_reset;
iowrite32(ctl, I2C_REG_CTL(alg_data));
//重启以清空RTX_FIFO,7位寻址。
wait_reset(I2C_PNX_TIMEOUT, alg_data);
alg_data->mif.ret = -EIO;
complete(&alg_data->mif.complete);
//唤醒完成量
}
------------------------------------------------------------------------------------------------------------*/
/* initialize the completion var */
init_completion(&alg_data->mif.complete);
//初始化完成量
/* Enable master interrupt */
iowrite32(ioread32(I2C_REG_CTL(alg_data)) | mcntrl_afie |
mcntrl_naie | mcntrl_drmie,
I2C_REG_CTL(alg_data));
//设置相关寄存器
/* Put start-code and slave-address on the bus. */
rc = i2c_pnx_start(addr, adap);
if (rc < 0)
break;
//在i2c_pnx_start函数中有这么一句
//iowrite32((slave_addr << 1) | start_bit | //alg_data->mif.mode,I2C_REG_TX(alg_data));
//作用就是产生发生start条件并发送地址
/* Wait for completion */
wait_for_completion(&alg_data->mif.complete);
//定时的作用应该是等待从机反应。
if (!(rc = alg_data->mif.ret))
completed++;
dev_dbg(&adap->dev, "%s(): Complete, return code = %d.\n",
__func__, rc);
/* Clear TDI and AFI bits in case they are set. */
if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_tdi) {
dev_dbg(&adap->dev,
"%s: TDI still set... clearing now.\n",
adap->name);
iowrite32(stat, I2C_REG_STS(alg_data));
}
if ((stat = ioread32(I2C_REG_STS(alg_data))) & mstatus_afi) {
dev_dbg(&adap->dev,
"%s: AFI still set... clearing now.\n",
adap->name);
iowrite32(stat, I2C_REG_STS(alg_data));
}
}
//最后如果两个中断置1，则清0
bus_reset_if_active(adap);
/* Cleanup to be sure... */
alg_data->mif.buf = NULL;
alg_data->mif.len = 0;
dev_dbg(&adap->dev, "%s(): exiting, stat = %x\n",
__func__, ioread32(I2C_REG_STS(alg_data)));
if (completed != num)
return ((rc < 0) ? rc : -EREMOTEIO);
return num;
}
数据的发送和传输是放在中断函数中完成的。
static irqreturn_t i2c_pnx_interrupt(int irq, void *dev_id)
{
u32 stat, ctl;
struct i2c_adapter *adap = dev_id;
struct i2c_pnx_algo_data *alg_data = adap->algo_data;
dev_dbg(&adap->dev, "%s(): mstat = %x mctrl = %x, mode = %d\n",
__func__,
ioread32(I2C_REG_STS(alg_data)),
ioread32(I2C_REG_CTL(alg_data)),
alg_data->mif.mode);
stat = ioread32(I2C_REG_STS(alg_data));
/* let's see what kind of event this is */
//仲裁失败中断
if (stat & mstatus_afi) {
/* We lost arbitration in the midst of a transfer */
alg_data->mif.ret = -EIO;
/* Disable master interrupts. */
ctl = ioread32(I2C_REG_CTL(alg_data));
ctl &= ~(mcntrl_afie | mcntrl_naie | mcntrl_rffie |
mcntrl_drmie);
iowrite32(ctl, I2C_REG_CTL(alg_data));
/* Stop timer, to prevent timeout. */
del_timer_sync(&alg_data->mif.timer);
complete(&alg_data->mif.complete);
} else if (stat & mstatus_nai) {
//无应答中断时
/* Slave did not acknowledge, generate a STOP */
dev_dbg(&adap->dev, "%s(): "
"Slave did not acknowledge, generating a STOP.\n",
__func__);
i2c_pnx_stop(adap);
/* Disable master interrupts. */
ctl = ioread32(I2C_REG_CTL(alg_data));
ctl &= ~(mcntrl_afie | mcntrl_naie | mcntrl_rffie |
mcntrl_drmie);
iowrite32(ctl, I2C_REG_CTL(alg_data));
/* Our return value. */
alg_data->mif.ret = -EIO;
/* Stop timer, to prevent timeout. */
del_timer_sync(&alg_data->mif.timer);
complete(&alg_data->mif.complete);
} else {
/*
* Two options:
* - Master Tx needs data.
* - There is data in the Rx-fifo
* The latter is only the case if we have requested for data,
* via a dummy write. (See 'i2c_pnx_master_rcv'.)
* We therefore check, as a sanity check, whether that interrupt
* has been enabled.
*/
//主机数据请求中断或从机数据请求中断时
if ((stat & mstatus_drmi) || !(stat & mstatus_rfe)) {
if (alg_data->mif.mode == I2C_SMBUS_WRITE) {
i2c_pnx_master_xmit(adap);
} else if (alg_data->mif.mode == I2C_SMBUS_READ) {
i2c_pnx_master_rcv(adap);
}
}
}
/* Clear TDI and AFI bits */
stat = ioread32(I2C_REG_STS(alg_data));
iowrite32(stat | mstatus_tdi | mstatus_afi, I2C_REG_STS(alg_data));
dev_dbg(&adap->dev, "%s(): exiting, stat = %x ctrl = %x.\n",
__func__, ioread32(I2C_REG_STS(alg_data)),
ioread32(I2C_REG_CTL(alg_data)));
return IRQ_HANDLED;
}
关于remove方法以用中断的具体处理不再分析。分析完毕。
下面分析i2c驱动的设备驱动（drivers/i2c/chips/pcf8574.c）
该设备是以bin_attribute二进制sysfs结点形式出现。大部分I2C设备都会采用这种形式。
模块加载与卸载
static int __init pcf8574_init(void)
{
return i2c_add_driver(&pcf8574_driver);
}
static void __exit pcf8574_exit(void)
{
i2c_del_driver(&pcf8574_driver);
}
加载与卸载模块调用了i2c提供的i2c_driver两个操作函数。
关于pcf8574_driver结构体
static struct i2c_driver pcf8574_driver = {
.driver = {
.name = "pcf8574",
},
.probe = pcf8574_probe,
.remove = pcf8574_remove,
.id_table = pcf8574_id,
.detect = pcf8574_detect,
.address_data = &addr_data,
};
.id_table成员会在i2c_bus_type的mach()函数中检查，以确定和i2c_board_info提供的驱动id是否匹配。
static int pcf8574_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct pcf8574_data *data;
int err;
data = kzalloc(sizeof(struct pcf8574_data), GFP_KERNEL);
if (!data) {
err = -ENOMEM;
goto exit;
}
i2c_set_clientdata(client, data);
/* Initialize the PCF8574 chip */
pcf8574_init_client(client);
/* Register sysfs hooks */
err = sysfs_create_group(&client->dev.kobj, &pcf8574_attr_group);
if (err)
goto exit_free;
return 0;
exit_free:
kfree(data);
exit:
return err;
}
关于其它各函数的实现不再分析。以sysfs节点存在的设备驱动不会在/dev子目录中的相应的设备文件。