基于S3C2440的Linux-3.6.6移植——devfs文件系统的IIC应用

来源：互联网发布：淘宝网鱼的十字绣编辑：程序博客网时间：2024/04/29 21:18

Linux-3.6.6提供了两种访问IIC的方法，一种是基于devfs的方法，另一种是基于sysfs的方法，文中介绍第一种方法，下一篇文章介绍第二种方法。

在arch/arm/plat-samsung/devs.c文件已经定义了IIC平台设备及其资源：

static struct resource s3c_i2c0_resource[]= {

[0]= DEFINE_RES_MEM(S3C_PA_IIC,SZ_4K),

[1] = DEFINE_RES_IRQ(IRQ_IIC),

};

struct platform_device s3c_device_i2c0 = {

.name = "s3c2410-i2c",

#ifdef CONFIG_S3C_DEV_I2C1

.id = 0,

#else

.id = -1,

#endif

.num_resources = ARRAY_SIZE(s3c_i2c0_resource),

.resource = s3c_i2c0_resource,

};

并且通过arch/arm/mach-s3c24xx/mach-zhaocj2440.c文件中的zhaocj2440_init函数把IIC平台设备添加到了总线上。

在zhaocj2440_init函数中还有一条关于IIC的语句：

s3c_i2c0_set_platdata(NULL);

该语句在devs.c中被定义，作用是设置IIC的平台设备数据：

void __init s3c_i2c0_set_platdata(structs3c2410_platform_i2c *pd)

{

structs3c2410_platform_i2c *npd;

if(!pd) {

pd= &default_i2c_data;

pd->bus_num= 0;

}

//设置IIC平台设备的数据

npd= s3c_set_platdata(pd,sizeof(struct s3c2410_platform_i2c),

&s3c_device_i2c0);

//定义IIC的引脚——GPE14和GPE15

if(!npd->cfg_gpio)

npd->cfg_gpio= s3c_i2c0_cfg_gpio;

}

其中default_i2c_data定义为：

struct s3c2410_platform_i2c default_i2c_data__initdata = {

.flags =0, //标识

.slave_addr = 0x10, //从模式地址

.frequency = 100*1000, //频率

.sda_delay = 100, //数据传输延时

};

我们再来看看IIC的平台驱动。在drivers/i2c/busses/i2c-s3c2410.c文件中，IIC子系统的初始化为：

staticint __init i2c_adap_s3c_init(void)

{

return platform_driver_register(&s3c24xx_i2c_driver);

}

s3c24xx_i2c_driver为IIC的平台驱动：

staticstruct platform_driver s3c24xx_i2c_driver = {

.probe = s3c24xx_i2c_probe,

.remove = s3c24xx_i2c_remove,

.id_table = s3c24xx_driver_ids,

.driver = {

.owner = THIS_MODULE,

.name = "s3c-i2c",

.pm = S3C24XX_DEV_PM_OPS,

.of_match_table= of_match_ptr(s3c24xx_i2c_match),

};

在驱动列表s3c24xx_driver_ids中，可以找到"s3c2410-i2c"，因此IIC的设备和驱动匹配上了：

staticstruct platform_device_id s3c24xx_driver_ids[]= {

{

.name = "s3c2410-i2c",

.driver_data = 0,

}, {

.name = "s3c2440-i2c",

.driver_data = QUIRK_S3C2440,

}, {

.name = "s3c2440-hdmiphy-i2c",

.driver_data = QUIRK_S3C2440 | QUIRK_HDMIPHY | QUIRK_NO_GPIO,

},{ },

};

按惯例，我们再来介绍s3c24xx_i2c_probe函数：

static int s3c24xx_i2c_probe(structplatform_device *pdev)

{

structs3c24xx_i2c *i2c;

structs3c2410_platform_i2c *pdata = NULL;

structresource *res;

intret;

if(!pdev->dev.of_node) {

//获得平台设备数据

pdata =pdev->dev.platform_data;

if(!pdata) {

dev_err(&pdev->dev,"no platform data\n");

return-EINVAL;

}

//申请内存空间

i2c = devm_kzalloc(&pdev->dev,sizeof(struct s3c24xx_i2c), GFP_KERNEL);

if(!i2c) {

dev_err(&pdev->dev,"no memory for state\n");

return-ENOMEM;

}

i2c->pdata =devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);

if(!i2c->pdata) {

ret= -ENOMEM;

gotoerr_noclk;

}

i2c->quirks = s3c24xx_get_device_quirks(pdev);

if (pdata)

memcpy(i2c->pdata, pdata, sizeof(*pdata));

else

s3c24xx_i2c_parse_dt(pdev->dev.of_node,i2c);

//为i2c结构赋值

strlcpy(i2c->adap.name, "s3c2410-i2c",sizeof(i2c->adap.name));

i2c->adap.owner = THIS_MODULE;

i2c->adap.algo = &s3c24xx_i2c_algorithm; //IIC算法

i2c->adap.retries = 2;

i2c->adap.class = I2C_CLASS_HWMON| I2C_CLASS_SPD;

i2c->tx_setup = 50;

spin_lock_init(&i2c->lock);

init_waitqueue_head(&i2c->wait);

/*find the clock and enable it */

i2c->dev = &pdev->dev;

i2c->clk = clk_get(&pdev->dev,"i2c"); //IIC时钟

if(IS_ERR(i2c->clk)) {

dev_err(&pdev->dev,"cannot get clock\n");

ret= -ENOENT;

gotoerr_noclk;

}

dev_dbg(&pdev->dev,"clock source %p\n", i2c->clk);

//IIC时钟使能

clk_enable(i2c->clk);

/*map the registers */

//获得内存资源，这里指的是IIC的寄存器

res= platform_get_resource(pdev, IORESOURCE_MEM, 0);

if(res == NULL) {

dev_err(&pdev->dev,"cannot find IO resource\n");

ret= -ENOENT;

gotoerr_clk;

}

//申请内存区域

i2c->ioarea =request_mem_region(res->start, resource_size(res),

pdev->name);

if(i2c->ioarea == NULL) {

dev_err(&pdev->dev,"cannot request IO\n");

ret= -ENXIO;

gotoerr_clk;

}

//内存重镜像

i2c->regs = ioremap(res->start,resource_size(res));

if(i2c->regs == NULL) {

dev_err(&pdev->dev,"cannot map IO\n");

ret = -ENXIO;

goto err_ioarea;

}

dev_dbg(&pdev->dev,"registers %p (%p, %p)\n",

i2c->regs, i2c->ioarea, res);

/*setup info block for the i2c core*/

i2c->adap.algo_data= i2c;

i2c->adap.dev.parent =&pdev->dev;

/*initialise the i2ccontroller */

//初始化IIC

ret= s3c24xx_i2c_init(i2c);

if(ret != 0)

gotoerr_iomap;

/*find the IRQ for this unit (note, this relies on the init call to

* ensure no current IRQs pending

//得到IIC的中断

i2c->irq = ret = platform_get_irq(pdev,0);

if(ret <= 0) {

dev_err(&pdev->dev,"cannot find IRQ\n");

gotoerr_iomap;

}

//申请中断

ret= request_irq(i2c->irq,s3c24xx_i2c_irq, 0,

dev_name(&pdev->dev), i2c);

if(ret != 0) {

dev_err(&pdev->dev,"cannot claim IRQ %d\n", i2c->irq);

gotoerr_iomap;

}

ret= s3c24xx_i2c_register_cpufreq(i2c);

if(ret < 0) {

dev_err(&pdev->dev,"failed to register cpufreq notifier\n");

gotoerr_irq;

}

/*Note, previous versions of the driver used i2c_add_adapter()

* to add the bus at any number. We now passthe bus number via

* the platform data, so if unset it will nowdefault to always

* being bus 0.

i2c->adap.nr = i2c->pdata->bus_num;

i2c->adap.dev.of_node =pdev->dev.of_node;

//使用静态总线号来声明IIC适配器

ret= i2c_add_numbered_adapter(&i2c->adap);

if(ret < 0) {

dev_err(&pdev->dev,"failed to add bus to i2ccore\n");

goto err_cpufreq;

}

of_i2c_register_devices(&i2c->adap);

platform_set_drvdata(pdev, i2c);

pm_runtime_enable(&pdev->dev);

pm_runtime_enable(&i2c->adap.dev);

dev_info(&pdev->dev,"%s: S3C I2C adapter\n", dev_name(&i2c->adap.dev));

clk_disable(i2c->clk);

return 0;

err_cpufreq:

s3c24xx_i2c_deregister_cpufreq(i2c);

err_irq:

free_irq(i2c->irq, i2c);

err_iomap:

iounmap(i2c->regs);

err_ioarea:

release_resource(i2c->ioarea);

kfree(i2c->ioarea);

err_clk:

clk_disable(i2c->clk);

clk_put(i2c->clk);

err_noclk:

returnret;

}

前面提到的IIC算法结构为：

static const struct i2c_algorithm s3c24xx_i2c_algorithm= {

.master_xfer = s3c24xx_i2c_xfer,

.functionality = s3c24xx_i2c_func,

};

在s3c24xx_i2c_xfer函数内，关键用到了s3c24xx_i2c_doxfer函数：

static int s3c24xx_i2c_doxfer(structs3c24xx_i2c *i2c,

struct i2c_msg *msgs, int num)

{

unsignedlong iicstat, timeout;

intspins = 20;

intret;

if(i2c->suspended)

return-EIO;

//设置寄存器，为传输数据做准备

ret= s3c24xx_i2c_set_master(i2c);

if(ret != 0) {

dev_err(i2c->dev, "cannot get bus (error%d)\n", ret);

ret= -EAGAIN;

gotoout;

}

spin_lock_irq(&i2c->lock);

i2c->msg =msgs; //数据

i2c->msg_num = num; //字节数

i2c->msg_ptr = 0;

i2c->msg_idx = 0;

i2c->state = STATE_START; //开始标识

s3c24xx_i2c_enable_irq(i2c); //开启IIC中断

s3c24xx_i2c_message_start(i2c,msgs); //开始传输，把数据头字节放在总线上

spin_unlock_irq(&i2c->lock);

timeout= wait_event_timeout(i2c->wait,i2c->msg_num == 0, HZ * 5);

ret= i2c->msg_idx;

/*having these next two as dev_err() makes life very

* noisy when doing an i2cdetect */

if(timeout == 0)

dev_dbg(i2c->dev, "timeout\n");

elseif (ret != num)

dev_dbg(i2c->dev, "incomplete xfer(%d)\n", ret);

/*ensure the stop has been through the bus */

dev_dbg(i2c->dev, "waiting for busidle\n");

/*first, try busy waiting briefly */

//等待传输结束

do{

cpu_relax();

iicstat= readl(i2c->regs +S3C2410_IICSTAT);

}while ((iicstat & S3C2410_IICSTAT_START)&& --spins);

/*if that timed out sleep */

if(!spins) {

msleep(1);

iicstat= readl(i2c->regs +S3C2410_IICSTAT);

}

if(iicstat & S3C2410_IICSTAT_START)

dev_warn(i2c->dev, "timeout waiting for busidle\n");

out:

returnret;

}

从上面的分析可以看出，s3c24xx_i2c_xfer的作用是在开启中断后把数据的头字节放到总线上。当数据真正开始传输的时候，就会触发IIC的中断，因此，实际的数据传输是在中断内完成的。我们来看看IIC的中断处理函数s3c24xx_i2c_irq：

static irqreturn_t s3c24xx_i2c_irq(int irqno, void *dev_id)

{

structs3c24xx_i2c *i2c = dev_id;

unsignedlong status;

unsignedlong tmp;

//读IICSTAT

status= readl(i2c->regs +S3C2410_IICSTAT);

//IIC仲裁失败

if(status & S3C2410_IICSTAT_ARBITR){

/*deal with arbitration loss */

dev_err(i2c->dev, "deal with arbitrationloss\n");

}

//如果总线处理闲置状况，则退出中断

if(i2c->state == STATE_IDLE) {

dev_dbg(i2c->dev, "IRQ: error i2c->state == IDLE\n");

//并清IIC中断悬挂标识

tmp =readl(i2c->regs +S3C2410_IICCON);

tmp&= ~S3C2410_IICCON_IRQPEND;

writel(tmp,i2c->regs + S3C2410_IICCON);

gotoout;

}

/*pretty much this leaves us with the fact that we've

* transmitted or received whatever byte welast sent */

i2c_s3c_irq_nextbyte(i2c, status);

out:

returnIRQ_HANDLED;

}

真正的传输函数出现了——i2c_s3c_irq_nextbyte：

static int i2c_s3c_irq_nextbyte(structs3c24xx_i2c *i2c, unsigned long iicstat)

{

unsignedlong tmp;

unsignedchar byte;

intret = 0;

switch(i2c->state) {

caseSTATE_IDLE: //空闲状态，什么也不做直接退出该函数

dev_err(i2c->dev, "%s: called inSTATE_IDLE\n", __func__);

gotoout;

caseSTATE_STOP: //数据传输结束

dev_err(i2c->dev, "%s: called inSTATE_STOP\n", __func__);

s3c24xx_i2c_disable_irq(i2c); //关闭中断

gotoout_ack; //跳到应答

caseSTATE_START: //传输开始，或者是传输结束为下一次传输做准备

/*last thing we did was send a start condition on the

* bus, or started a new i2c message

if(iicstat & S3C2410_IICSTAT_LASTBIT&& //传输结束

!(i2c->msg->flags& I2C_M_IGNORE_NAK)){ //不忽略应答

/*ack was not received... */

dev_dbg(i2c->dev, "ack was notreceived\n");

s3c24xx_i2c_stop(i2c,-ENXIO); //由于从设备没有响应，而结束传输

gotoout_ack; //跳到应答

}

//判断此次传输是发送还是接受，即是读还是写

if(i2c->msg->flags & I2C_M_RD)

i2c->state = STATE_READ;

else

i2c->state = STATE_WRITE;

/*terminate the transfer if there is nothing to do

* as this is used by the i2c probe to find devices. */

//判断是否传输结束

if(is_lastmsg(i2c)&& i2c->msg->len== 0) {

s3c24xx_i2c_stop(i2c,0); //结束传输

gotoout_ack;

}

if(i2c->state ==STATE_READ) //读状态

goto prepare_read;

/*fall through to the write state, as we will need to

* send a byte as well */

caseSTATE_WRITE: //写入状态

/*we are writing data to the device... check for the

* end of the message, and if so, work out whatto do

//从设备拒绝写入

if(!(i2c->msg->flags & I2C_M_IGNORE_NAK)) {

if(iicstat & S3C2410_IICSTAT_LASTBIT){

dev_dbg(i2c->dev, "WRITE: No Ack\n");

s3c24xx_i2c_stop(i2c,-ECONNREFUSED);

gotoout_ack;

}

retry_write:

if(!is_msgend(i2c)) { //信息传输尚未结束

byte= i2c->msg->buf[i2c->msg_ptr++];

writeb(byte,i2c->regs + S3C2410_IICDS); //写入数据

/*delay after writing the byte to allow the

* data setup time on the bus, as writing the

* data to the register causes the first bit

* to appear on SDA, and SCL will change as

* soon as the interrupt is acknowledged */

ndelay(i2c->tx_setup); //等待，延时

}else if (!is_lastmsg(i2c)) { //不是最后一组信息

/*we need to go to the next i2cmessage */

dev_dbg(i2c->dev, "WRITE: Next Message\n");

//为下一组信息传输做准备，即调整指针

i2c->msg_ptr = 0;

i2c->msg_idx++;

i2c->msg++;

/*check to see if we need to do another message */

if (i2c->msg->flags & I2C_M_NOSTART) {

if (i2c->msg->flags & I2C_M_RD) {

/* cannot do this, the controller

* forces us to send a new START

* when we change direction */

s3c24xx_i2c_stop(i2c,-EINVAL);

}

gotoretry_write;

}else {

/*send the new start */

//准备传输下一组信息

s3c24xx_i2c_message_start(i2c, i2c->msg);

i2c->state = STATE_START;

}

}else { //所有信息都传输结束

/*send stop */

s3c24xx_i2c_stop(i2c,0);

}

break;

caseSTATE_READ: //读入状态

/*we have a byte of data in the data register, do

* something with it, and then work out wetherwe are

* going to do any more read/write

//读入数据

byte= readb(i2c->regs +S3C2410_IICDS);

i2c->msg->buf[i2c->msg_ptr++] = byte;

prepare_read:

if(is_msglast(i2c)) { //是当前信息的最后一个字节

/*last byte of buffer */

if(is_lastmsg(i2c)) //是最后一组信息，即再没有数据需要读入了

s3c24xx_i2c_disable_ack(i2c); //无需应答

}else if (is_msgend(i2c)) { //当前信息的尾部

/*ok, we've read the entire buffer, see if there

* is anything else we need to do */

if(is_lastmsg(i2c)) { //最后一组信息

/*last message, send stop and complete */

dev_dbg(i2c->dev, "READ: Send Stop\n");

s3c24xx_i2c_stop(i2c,0);

}else {

/*go to the next transfer */

dev_dbg(i2c->dev, "READ: NextTransfer\n");

i2c->msg_ptr = 0;

i2c->msg_idx++;

i2c->msg++;

}

break;

}

/*acknowlegde the IRQ and get back on with the work */

out_ack: //并清IIC中断悬挂标识

tmp= readl(i2c->regs +S3C2410_IICCON);

tmp&= ~S3C2410_IICCON_IRQPEND;

writel(tmp,i2c->regs + S3C2410_IICCON);

out:

returnret;

}

s3c24xx_i2c_probe函数中还用到了s3c24xx_i2c_init函数：

static int s3c24xx_i2c_init(structs3c24xx_i2c *i2c)

{

unsignedlong iicon = S3C2410_IICCON_IRQEN| S3C2410_IICCON_ACKEN;

structs3c2410_platform_i2c *pdata;

unsignedint freq;

/*get the plafrom data */

pdata = i2c->pdata;

/* inititalise the gpio */

//初始化IIC的引脚

if(pdata->cfg_gpio)

pdata->cfg_gpio(to_platform_device(i2c->dev));

else

if(s3c24xx_i2c_parse_dt_gpio(i2c))

return-EINVAL;

/*write slave address */

//写IICADD寄存器

writeb(pdata->slave_addr,i2c->regs + S3C2410_IICADD);

dev_info(i2c->dev, "slave address0x%02x\n", pdata->slave_addr);

//写IICCON，IIC应答使能，IIC中断使能

writel(iicon,i2c->regs + S3C2410_IICCON);

/*we need to work out the divisors for the clock... */

//分频

if(s3c24xx_i2c_clockrate(i2c, &freq) != 0) {

writel(0,i2c->regs + S3C2410_IICCON);

dev_err(i2c->dev, "cannot meet bus frequencyrequired\n");

return-EINVAL;

}

/*todo - check that the i2clines aren't being dragged anywhere */

dev_info(i2c->dev, "bus frequency set to %dKHz\n", freq);

dev_dbg(i2c->dev, "S3C2410_IICCON=0x%02lx\n", iicon);

return 0;

}

我们最后看看IIC的文件层drivers/i2c/i2c-dev.c：

static int __init i2c_dev_init(void)

{

int res;

printk(KERN_INFO "i2c /dev entries driver\n");

//注册字符设备

res =register_chrdev(I2C_MAJOR,"i2c",&i2cdev_fops);

if(res)

gotoout;

//创建子类

i2c_dev_class = class_create(THIS_MODULE,"i2c-dev");

if(IS_ERR(i2c_dev_class)){

res= PTR_ERR(i2c_dev_class);

gotoout_unreg_chrdev;

}

/*Keep track of adapters which will be added or removed later */

res= bus_register_notifier(&i2c_bus_type,&i2cdev_notifier);

if(res)

goto out_unreg_class;

/*Bind to already existing adapters right away */

//绑定现有的IIC适配器

i2c_for_each_dev(NULL, i2cdev_attach_adapter);

return0;

out_unreg_class:

class_destroy(i2c_dev_class);

out_unreg_chrdev:

unregister_chrdev(I2C_MAJOR, "i2c");

out:

printk(KERN_ERR"%s: Driver Initialisation failed\n", __FILE__);

returnres;

}

IIC的操作集i2cdev_fops：

static const struct file_operationsi2cdev_fops = {

.owner = THIS_MODULE,

.llseek = no_llseek,

.read = i2cdev_read,

.write = i2cdev_write,

.unlocked_ioctl = i2cdev_ioctl,

.open = i2cdev_open,

.release = i2cdev_release,

};

我们对i2cdev_read、i2cdev_write和i2cdev_ioctl这三个主要的函数进行分析：

static ssize_t i2cdev_read(struct file*file, char __user *buf, size_t count,

loff_t*offset)

{

char*tmp;

intret;

structi2c_client *client =file->private_data;

if(count > 8192)

count= 8192; //限制字节数

tmp= kmalloc(count, GFP_KERNEL); //开辟内存空间

if(tmp == NULL)

return-ENOMEM;

pr_debug("i2c-dev: i2c-%d reading %zu bytes.\n",

iminor(file->f_path.dentry->d_inode),count);

ret= i2c_master_recv(client, tmp,count); //以master形式接受数据

if(ret >= 0)

ret= copy_to_user(buf, tmp, count) ? -EFAULT : ret; //复制到用户程序中

kfree(tmp);

returnret;

}

static ssize_t i2cdev_write(struct file*file, const char __user *buf,

size_tcount, loff_t *offset)

{

intret;

char*tmp;

structi2c_client *client =file->private_data;

if(count > 8192)

count= 8192;

tmp= memdup_user(buf, count);

if(IS_ERR(tmp))

returnPTR_ERR(tmp);

pr_debug("i2c-dev: i2c-%d writing %zu bytes.\n",

iminor(file->f_path.dentry->d_inode),count);

ret= i2c_master_send(client, tmp,count); //以master形式发送数据

kfree(tmp);

returnret;

}

i2c_master_recv函数和i2c_master_send函数都在drviers/i2c/I2c-core.c文件内，而且这两个函数最终都是调用的i2c_transfer函数。

由于对IIC的读i2cdev_read和写i2cdev_write操作有一些局限性，而且这两个操作完全可以用i2cdev_ioctl来替代：

static long i2cdev_ioctl(struct file *file,unsigned int cmd, unsigned long arg)

{

structi2c_client *client =file->private_data;

unsignedlong funcs;

dev_dbg(&client->adapter->dev,"ioctl, cmd=0x%02x, arg=0x%02lx\n",

cmd, arg);

switch(cmd) {

caseI2C_SLAVE:

caseI2C_SLAVE_FORCE: //设置从设备地址

/*NOTE: devices set up to work with"new style" drivers

* can't use I2C_SLAVE, even when the device node is not

* bound to a driver. Only I2C_SLAVE_FORCE will work.

* Setting the PEC flag here won't affectkernel drivers,

* which will be using the i2c_client node registered with

* the driver model core. Likewise, when that client has

* the PEC flag already set, the i2c-dev driver won't see

* (or use) this setting.

if((arg > 0x3ff) ||

(((client->flags & I2C_M_TEN)== 0) && arg > 0x7f))

return-EINVAL;

if(cmd == I2C_SLAVE&& i2cdev_check_addr(client->adapter, arg))

return-EBUSY;

/*REVISIT: address could become busy later */

client->addr= arg;

return0;

caseI2C_TENBIT: //设置7位地址还是10位地址

if (arg) //非零是十位

client->flags |= I2C_M_TEN;

else

client->flags &= ~I2C_M_TEN; //七位

return 0;

caseI2C_PEC:

if(arg)

client->flags |= I2C_CLIENT_PEC;

else

client->flags &= ~I2C_CLIENT_PEC;

return 0;

caseI2C_FUNCS: //返回控制器算法所支持的传输种类

funcs= i2c_get_functionality(client->adapter);

returnput_user(funcs, (unsigned long __user *)arg);

caseI2C_RDWR: //IIC的读写操作，master方式

returni2cdev_ioctl_rdrw(client, arg);

caseI2C_SMBUS: //IIC的SMBus传输方式

returni2cdev_ioctl_smbus(client, arg);

caseI2C_RETRIES: //重复次数

client->adapter->retries = arg;

break;

case I2C_TIMEOUT: //延时

/*For historical reasons, user-space sets the timeout

* value in units of 10 ms.

client->adapter->timeout= msecs_to_jiffies(arg * 10);

break;

default:

/*NOTE: returning a fault code here couldcause trouble

* in buggy userspace code. Some old kernel bugs returned

* zero in this case, and userspace code mightaccidentally

* have depended on that bug.

return-ENOTTY;

}

return0;

}

最主要的IIC读写操作i2cdev_ioctl_rdrw函数：

static noinline inti2cdev_ioctl_rdrw(struct i2c_client*client,

unsignedlong arg)

{

structi2c_rdwr_ioctl_data rdwr_arg;

structi2c_msg *rdwr_pa;

u8 __user **data_ptrs;

int i, res;

//复制用户空间中的数据

if(copy_from_user(&rdwr_arg,

(struct i2c_rdwr_ioctl_data __user *)arg,

sizeof(rdwr_arg)))

return-EFAULT;

/*Put an arbitrary limit on the number of messages that can

* be sent at once */

if(rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)

return-EINVAL;

//从用户空间复制内存

rdwr_pa= memdup_user(rdwr_arg.msgs,

rdwr_arg.nmsgs * sizeof(struct i2c_msg));

if(IS_ERR(rdwr_pa))

returnPTR_ERR(rdwr_pa);

//开辟一段内存空间给data_ptrs

data_ptrs= kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL);

if(data_ptrs == NULL) {

kfree(rdwr_pa);

return -ENOMEM;

}

res = 0;

//复制数据

for (i = 0; i < rdwr_arg.nmsgs; i++) {

/* Limitthe size of the message to a sane amount */

if(rdwr_pa[i].len > 8192) {

res= -EINVAL;

break;

}

//复制数据

data_ptrs[i]= (u8 __user *)rdwr_pa[i].buf;

rdwr_pa[i].buf= memdup_user(data_ptrs[i], rdwr_pa[i].len);

if(IS_ERR(rdwr_pa[i].buf)) {

res = PTR_ERR(rdwr_pa[i].buf);

break;

}

* If the message length is received from theslave (similar

* to SMBus block read), we must ensure thatthe buffer will

* be large enough to cope with a messagelength of

* I2C_SMBUS_BLOCK_MAXas this is the maximum underlying bus

* drivers allow. The first byte in the buffermust be

* pre-filled with the number of extra bytes,which must be

* at least one to hold the message length, butcan be

* greater (for example to account for achecksum byte at

* the end of the message.)

if (rdwr_pa[i].flags & I2C_M_RECV_LEN) {

if (!(rdwr_pa[i].flags& I2C_M_RD) || //不是读命令

rdwr_pa[i].buf[0] < 1 ||

rdwr_pa[i].len < rdwr_pa[i].buf[0] +

I2C_SMBUS_BLOCK_MAX){

res = -EINVAL;

break; //退出for循环

}

rdwr_pa[i].len= rdwr_pa[i].buf[0];

}

if(res < 0) {

int j;

for (j = 0; j < i; ++j)

kfree(rdwr_pa[j].buf);

kfree(data_ptrs);

kfree(rdwr_pa);

returnres;

}

//IIC的传输数据

res= i2c_transfer(client->adapter,rdwr_pa, rdwr_arg.nmsgs);

//如果是读命令（数据传输方向是从设备向主设备），把数据传递给用户

while(i-- > 0) {

//读命令判断

if (res >= 0 &&(rdwr_pa[i].flags & I2C_M_RD)){

if(copy_to_user(data_ptrs[i], rdwr_pa[i].buf, //传输数据给用户

rdwr_pa[i].len))

res = -EFAULT;

}

kfree(rdwr_pa[i].buf);

}

kfree(data_ptrs);

kfree(rdwr_pa);

return res;

}

再来看看上面这个函数最关键的一条——i2c_transfer。i2cdev_write和i2cdev_read实际上也主要是调用这个函数，因此正如上文介绍的，完全可以用ioctl来代替read和write：

int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)

{

intret;

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

* continueexecuting the rest of this combined message, if

* that's the appropriate response.

* -When for example "num" is two and we successfully complete

* thefirst 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) { //IIC算法为master

#ifdefDEBUG

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 = i2c_trylock_adapter(adap);

if(!ret)

/*I2C activity is ongoing. */

return-EAGAIN;

}else {

i2c_lock_adapter(adap);

}

//IIC传输数据

ret = __i2c_transfer(adap, msgs, num);

i2c_unlock_adapter(adap);

returnret;

}else {

dev_dbg(&adap->dev,"I2C leveltransfers not supported\n");

return-EOPNOTSUPP;

}

__i2c_transfer函数也在drviers/i2c/I2c-core.c文件内：

int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)

{

unsignedlong orig_jiffies;

intret, try;

/*Retry automatically on arbitration loss */

orig_jiffies= jiffies;

//根据所设置的重试次数来循环

for(ret = 0, try = 0; try <= adap->retries; try++) {

//使用master进行传输，即调用s3c24xx_i2c_xfer函数

ret =adap->algo->master_xfer(adap, msgs, num);

if (ret !=-EAGAIN)

break;

if(time_after(jiffies, orig_jiffies + adap->timeout)) //延时

break;

}

returnret;

}

在写应用程序的时候，如果我们要用I2C_RDWR这个命令，那么就要用到i2c_rdwr_ioctl_data结构（它是在include/linux/i2c-dev.h中定义的），所以我们给出它的定义：

struct i2c_rdwr_ioctl_data {

structi2c_msg __user *msgs; /* pointers to i2c_msgs */

__u32nmsgs; /* number of i2c_msgs */

};

struct i2c_msg {

__u16addr; /* slave address */

__u16flags;

#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 */

__u16len; /* msg length */

__u8*buf; /* pointer to msg data */

};

下面我们就来写访问IIC的应用程序。在开发板上，用IIC连接的设备是AT24C02的eeprom。我们首先用write和read来读写eeprom：

#include <stdio.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <string.h>

//下面两个头文件是操作IIC的关键

#include <linux/i2c.h>

#include <linux/i2c-dev.h>

int main(void){

int fd, i;

char sendadd;

char buf[50];

fd = open("/dev/i2c-0", O_RDWR);

if(fd < 0){

printf("####i2ctest device open failed####/n");

return (-1);

}

ioctl(fd,I2C_TENBIT,0); //七位地址

//AT24C02的地址为0xa0，但由于是七位地址，最低一位是读写位，因此0xa0右移一位就变为0x50

if (ioctl(fd, I2C_SLAVE_FORCE, 0x50) < 0) {

printf("####i2cset slave address failed####/n");

return (-1);

}

ioctl(fd,I2C_TIMEOUT,1); //超时时间

ioctl(fd,I2C_RETRIES,2); //重复次数

sendaddr = 0x28; //这里设置读的地址为0x28

write(fd, &sendadd,1); //发送地址

read(fd, buf, 8); //连续读出8个数据

for(i=0; i<8; i++)

printf("buff[%d]=%x\n", i, buf[i]);

close(fd);

return 0;

}

上面的程序实现了读取AT24C02中从地址0x28开始的连续8个数据。下面的程序实现了从0x30地址开始，连续写入8个数据：

#include <stdio.h>

#include <stdlib.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <string.h>

#include <linux/i2c.h>

#include <linux/i2c-dev.h>

int main(void){

int fd;

charbuf[8]={0xef,0x9f,0x3,0x5a,0x2e,0x67,0x89,0x10}; //要写入的数据

//senddata为传输的数据，它包括第一个字节的地址信息，和后8个字节的写入数据信息

char senddata[9];

fd = open("/dev/i2c-0", O_RDWR);

if(fd < 0){

printf("####i2ctest device open failed####/n");

return (-1);

}

ioctl(fd,I2C_TENBIT,0);

if (ioctl(fd, I2C_SLAVE_FORCE, 0x50) < 0) {

printf("####i2cset slave address failed####/n");

return (-1);

}

ioctl(fd,I2C_TIMEOUT,1);

ioctl(fd,I2C_RETRIES,2);

memcpy(senddata+1,buf, 8);

senddata[0]=0x30; //要写入的地址

write(fd, senddata,9);

close(fd);

return 0;

}

下面我们再用ioctl的方法来实现读写功能：

/*******************

* iicr.c *

******************/

#include <stdio.h>

#include <linux/types.h>

#include <stdlib.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/ioctl.h>

#include <errno.h>

#include<linux/i2c.h>

#include<linux/i2c-dev.h>

int main(int argc, char **argv)

{

int fd,ret;

struct i2c_rdwr_ioctl_data e2prom_data;

unsigned intreg_address;

fd=open("/dev/i2c-0",O_RDWR);

if(fd<0){

perror("open error");

exit(1);

}

sscanf(argv[1],"%x", &reg_address); //转换参数类型，第一个参数为目标地址

e2prom_data.nmsgs=2;

*因为操作时序中，最多是用到2个开始信号（字节读操作中），所以此将

*e2prom_data.nmsgs配置为2

e2prom_data.msgs=(structi2c_msg*)malloc(e2prom_data.nmsgs*sizeof(structi2c_msg));

if(!e2prom_data.msgs){

perror("malloc error");

exit(1);

}

ioctl(fd,I2C_TIMEOUT,1);

ioctl(fd,I2C_RETRIES,2);

/***write datato e2prom**/

e2prom_data.nmsgs=2;

(e2prom_data.msgs[0]).len=1; //1个 e2prom 写入目标的地址

(e2prom_data.msgs[0]).addr=0x50; //e2prom 设备地址

(e2prom_data.msgs[0]).flags=0; //write

(e2prom_data.msgs[0]).buf=(unsignedchar*)malloc(1);

(e2prom_data.msgs[0]).buf[0]=reg_address; // e2prom 写入目标的地址

(e2prom_data.msgs[1]).len=1; //读出的数据

(e2prom_data.msgs[1]).addr=0x50; // e2prom 设备地址

(e2prom_data.msgs[1]).flags=I2C_M_RD; //read

(e2prom_data.msgs[1]).buf=(unsignedchar*)malloc(1);//存放返回值的地址。

(e2prom_data.msgs[1]).buf[0]=0; //初始化读缓冲

ret=ioctl(fd, I2C_RDWR, (unsigned long)&e2prom_data);

if(ret<0){

perror("ioctl error1");

exit(1);

}

printf("buf[0]=%x\n",(e2prom_data.msgs[1]).buf[0]);

close(fd);

return 0;

}

上面的程序实现了可以读取AT24C02中的任意一个地址数据的功能。而下面的程序实现了可以写入任意一个地址数据的功能，其中第一个参数内存地址，第二个参数为要写入的数据：

/***************

* iicw.c *

***************/

#include <stdio.h>

#include <linux/types.h>

#include <stdlib.h>

#include <fcntl.h>

#include <unistd.h>

#include <sys/types.h>

#include <sys/ioctl.h>

#include <errno.h>

#include<string.h>

#include<linux/i2c.h>

#include<linux/i2c-dev.h>

int main(int argc, char *argv[])

{

int fd, ret;

struct i2c_rdwr_ioctl_data e2prom_data;

unsignedint reg_address,value;

fd=open("/dev/i2c-0",O_RDWR);

if(fd<0){

perror("open error");

}

sscanf(argv[1],"%x", &reg_address); //目标地址

sscanf(argv[2],"%x", &value); //要写入的数据

e2prom_data.nmsgs=1;

e2prom_data.msgs=(structi2c_msg*)malloc(e2prom_data.nmsgs*sizeof(structi2c_msg));

if(!e2prom_data.msgs){

perror("malloc error");

exit(1);

}

ioctl(fd,I2C_TIMEOUT,1);

ioctl(fd,I2C_RETRIES,2);

e2prom_data.nmsgs=1;

(e2prom_data.msgs[0]).len=2; //1个 e2prom 写入目标的地址和1个数据

(e2prom_data.msgs[0]).addr=0x50; //e2prom 设备地址

(e2prom_data.msgs[0]).flags=0; //write

(e2prom_data.msgs[0]).buf=(unsignedchar*)malloc(2);

(e2prom_data.msgs[0]).buf[0]=reg_address; // e2prom 写入目标的地址

(e2prom_data.msgs[0]).buf[1]=value; //要写入的数据

ret=ioctl(fd,I2C_RDWR,(unsigned long)&e2prom_data);

if(ret<0){

perror("ioctl error2");

}

close(fd);

return 0;

}

正如前面介绍的，用ioctl完全可以实现read和write的功能，但ioctl一次只能读写一个字节，而read和write可以一次读写多个字节。