558行，又重试2次。
560行，调用s3c24xx_i2c_doxfer函数：
static int s3c24xx_i2c_doxfer(struct s3c24xx_i2c *i2c,
struct i2c_msg *msgs, int num)
{
unsigned long iicstat, timeout;
int spins = ;
int ret; if (i2c->suspended)
return -EIO; ret = s3c24xx_i2c_set_master(i2c);
if (ret != ) {
dev_err(i2c->dev, "cannot get bus (error %d)\n", ret);
ret = -EAGAIN;
goto out;
} spin_lock_irq(&i2c->lock); i2c->msg = msgs;
i2c->msg_num = num;
i2c->msg_ptr = ;
i2c->msg_idx = ;
i2c->state = STATE_START; s3c24xx_i2c_enable_irq(i2c);
s3c24xx_i2c_message_start(i2c, msgs);
spin_unlock_irq(&i2c->lock); timeout = wait_event_timeout(i2c->wait, i2c->msg_num == , HZ * ); ret = i2c->msg_idx; /* having these next two as dev_err() makes life very
00000516 * noisy when doing an i2cdetect */ if (timeout == )
dev_dbg(i2c->dev, "timeout\n");
else if (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 bus idle\n"); /* first, try busy waiting briefly */
do {
iicstat = readl(i2c->regs + S3C2410_IICSTAT);
} while ((iicstat & S3C2410_IICSTAT_START) && --spins); /* if that timed out sleep */
if (!spins) {
msleep();
iicstat = readl(i2c->regs + S3C2410_IICSTAT);
} if (iicstat & S3C2410_IICSTAT_START)
dev_warn(i2c->dev, "timeout waiting for bus idle\n"); out:
return ret;
}
489行，如果IIC控制器挂起了的话就不用往下走了，返回出错。
492至497行，调用s3c24xx_i2c_set_master函数，读取IICSTAT寄存器，等待IIC总线空闲。
501至505行，记住这些变量的值，后面的分析会遇到。
507行，使能IIC控制器中断。
508行，调用s3c24xx_i2c_message_start函数开始读写操作，它的定义如下：
static void s3c24xx_i2c_message_start(struct s3c24xx_i2c *i2c,
struct i2c_msg *msg)
{
unsigned int addr = (msg->addr & 0x7f) << ;
unsigned long stat;
unsigned long iiccon; stat = ;
stat |= S3C2410_IICSTAT_TXRXEN; if (msg->flags & I2C_M_RD) {
stat |= S3C2410_IICSTAT_MASTER_RX;
addr |= ;
} else
stat |= S3C2410_IICSTAT_MASTER_TX; if (msg->flags & I2C_M_REV_DIR_ADDR)
addr ^= ; /* todo - check for wether ack wanted or not */
s3c24xx_i2c_enable_ack(i2c); iiccon = readl(i2c->regs + S3C2410_IICCON);
writel(stat, i2c->regs + S3C2410_IICSTAT); dev_dbg(i2c->dev, "START: %08lx to IICSTAT, %02x to DS\n", stat, addr);
writeb(addr, i2c->regs + S3C2410_IICDS); /* delay here to ensure the data byte has gotten onto the bus
00000192 * before the transaction is started */ ndelay(i2c->tx_setup); dev_dbg(i2c->dev, "iiccon, %08lx\n", iiccon);
writel(iiccon, i2c->regs + S3C2410_IICCON); stat |= S3C2410_IICSTAT_START;
writel(stat, i2c->regs + S3C2410_IICSTAT);
}
166行，高7位表示从机地址，最低1位表示读或写操作，0表示写，1表示读。
171行，IIC控制器发送和接收使能。
173行，条件不成立，所以执行177行，主机发送使能。
179行，与读操作相关的，因此if条件不成立。
183行，使能IIC控制器ACK应答。
剩下那些语句基本上都是在操作IIC控制器的寄存器，具体含义请看s3c6410的数据手册。
189行，将从机地址写入移位寄存器。
s3c24xx_i2c_message_start函数执行完后硬件就开始进行数据传输，回到s3c24xx_i2c_doxfer函数的第509行，释放锁，与499行是配对使用的。
511行，等待，等待传输操作完成，等待，只因曾经承若。有两种情况会唤醒它，一是超时，二是传输完成。
程序是在等待了，但我们的步伐却不会因此而停留，前面还有很长的路等着我们呢，还等什么，继续前进！
接下来看等待过程中发生的事情，没错，就是在中断里。中断处理函数是s3c24xx_i2c_irq，它的定义：
static irqreturn_t s3c24xx_i2c_irq(int irqno, void *dev_id)
{
struct s3c24xx_i2c *i2c = dev_id;
unsigned long status;
unsigned long tmp; status = readl(i2c->regs + S3C2410_IICSTAT); if (status & S3C2410_IICSTAT_ARBITR) {
/* deal with arbitration loss */
dev_err(i2c->dev, "deal with arbitration loss\n");
} if (i2c->state == STATE_IDLE) {
dev_dbg(i2c->dev, "IRQ: error i2c->state == IDLE\n"); tmp = readl(i2c->regs + S3C2410_IICCON);
tmp &= ~S3C2410_IICCON_IRQPEND;
writel(tmp, i2c->regs + S3C2410_IICCON);
goto out;
} /* pretty much this leaves us with the fact that we've
00000446 * transmitted or received whatever byte we last sent */ i2s_s3c_irq_nextbyte(i2c, status); out:
return IRQ_HANDLED;
}
429行，读取状态寄存器。
431至434行，如果总线仲裁失败就打印错误信息。
436至443行，我们知道i2c->state是等于STATE_START的，因此这里的if条件不成立。
448行，i2s_s3c_irq_nextbyte函数执行具体中断处理，i2s_s3c_irq_nextbyte函数的定义：
static int i2s_s3c_irq_nextbyte(struct s3c24xx_i2c *i2c, unsigned long iicstat)
{
unsigned long tmp;
unsigned char byte;
int ret = ; switch (i2c->state) { case STATE_IDLE:
dev_err(i2c->dev, "%s: called in STATE_IDLE\n", __func__);
goto out;
break; case STATE_STOP:
dev_err(i2c->dev, "%s: called in STATE_STOP\n", __func__);
s3c24xx_i2c_disable_irq(i2c);
goto out_ack; case STATE_START:
/* last thing we did was send a start condition on the
00000277 * bus, or started a new i2c message
00000278 */ if (iicstat & S3C2410_IICSTAT_LASTBIT &&
!(i2c->msg->flags & I2C_M_IGNORE_NAK)) {
/* ack was not received... */ dev_dbg(i2c->dev, "ack was not received\n");
s3c24xx_i2c_stop(i2c, -ENXIO);
goto out_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
00000295 * as this is used by the i2c probe to find devices. */ if (is_lastmsg(i2c) && i2c->msg->len == ) {
s3c24xx_i2c_stop(i2c, );
goto out_ack;
} if (i2c->state == STATE_READ)
goto prepare_read; /* fall through to the write state, as we will need to
00000306 * send a byte as well */ case STATE_WRITE:
/* we are writing data to the device... check for the
00000310 * end of the message, and if so, work out what to do
00000311 */ 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);
goto out_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
00000329 * data setup time on the bus, as writing the
00000330 * data to the register causes the first bit
00000331 * to appear on SDA, and SCL will change as
00000332 * soon as the interrupt is acknowledged */ ndelay(i2c->tx_setup); } else if (!is_lastmsg(i2c)) {
/* we need to go to the next i2c message */ dev_dbg(i2c->dev, "WRITE: Next Message\n"); i2c->msg_ptr = ;
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
00000350 * forces us to send a new START
00000351 * when we change direction */ s3c24xx_i2c_stop(i2c, -EINVAL);
} goto retry_write;
} else {
/* send the new start */
s3c24xx_i2c_message_start(i2c, i2c->msg);
i2c->state = STATE_START;
} } else {
/* send stop */ s3c24xx_i2c_stop(i2c, );
}
break; case STATE_READ:
/* we have a byte of data in the data register, do
00000372 * something with it, and then work out wether we are
00000373 * going to do any more read/write
00000374 */ 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
00000388 * 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, );
} else {
/* go to the next transfer */
dev_dbg(i2c->dev, "READ: Next Transfer\n"); i2c->msg_ptr = ;
i2c->msg_idx++;
i2c->msg++;
}
} break;
} /* acknowlegde the IRQ and get back on with the work */ out_ack:
tmp = readl(i2c->regs + S3C2410_IICCON);
tmp &= ~S3C2410_IICCON_IRQPEND;
writel(tmp, i2c->regs + S3C2410_IICCON);
out:
return ret;
}
函数够长的，不过一路走来，早就已经习惯了。
263行，因为i2c->state=STATE_START，因此忽略其他case，直接从275行开始看。
280行，如果没有收到ACK信号并且没有设置忽略ACK则停止这次传输。
289行，if条件不成立，执行292行，i2c->state = STATE_WRITE。
297行，is_lastmsg函数的定义：
static inline int is_lastmsg(struct s3c24xx_i2c *i2c)
{
return i2c->msg_idx >= (i2c->msg_num - );
}
因为i2c->msg_idx=0，i2c->msg_num=1，所以返回1。但是i2c->msg->len=2不为0，所以297行的if条件不成立。
302行，if条件不成立。
注意，这个case里没有并没有break，因此会继续往下执行。
313至320行，也是没收到ACK条件才会成立的。
324行，is_msgend函数的定义：
static inline int is_msgend(struct s3c24xx_i2c *i2c)
{
return i2c->msg_ptr >= i2c->msg->len;
}
因为i2c->msg_ptr=0，i2c->msg->len=2，因此返回0。324行的if条件成立。
325行，读取第一个要写的字节数据，然后i2c->msg_ptr= i2c->msg_ptr +1。
326行，将数据写入移位寄存器。
334行，延时一下。
368行，跳出switch，到411行。
411至413行，清除pending标志，恢复IIC传输。
下一次进中断的时候会进入308行的case，经过313至320行的判断后来到324行，这次is_msgend函数还是会返回0。325行，读取下一个字节数据，326行，将数据写入移位寄存器，过程和前面的一样。
当第三次进中断的时候，324行的条件就不会成立了，并且336行的if条件也不会成立，因此就会执行366行的s3c24xx_i2c_stop函数，它的定义如下：
static inline void s3c24xx_i2c_stop(struct s3c24xx_i2c *i2c, int ret)
{
unsigned long iicstat = readl(i2c->regs + S3C2410_IICSTAT); dev_dbg(i2c->dev, "STOP\n"); /* stop the transfer */
iicstat &= ~S3C2410_IICSTAT_START;
writel(iicstat, i2c->regs + S3C2410_IICSTAT); i2c->state = STATE_STOP; s3c24xx_i2c_master_complete(i2c, ret);
s3c24xx_i2c_disable_irq(i2c);
}
205行，读取状态寄存器。
210、211行，发送停止信号。
213行，i2c->state = STATE_STOP。
215行，调用s3c24xx_i2c_master_complete函数。
216行，禁止IIC控制器中断。下面看s3c24xx_i2c_master_complete函数的定义：
static inline void s3c24xx_i2c_master_complete(struct s3c24xx_i2c *i2c, int ret)
{
dev_dbg(i2c->dev, "master_complete %d\n", ret); i2c->msg_ptr = ;
i2c->msg = NULL;
i2c->msg_idx++;
i2c->msg_num = ;
if (ret)
i2c->msg_idx = ret; wake_up(&i2c->wait);
}
113至118行，不用说了。
120行，唤醒那个睡着了的她，谁？就是那个“承若”。忘记了的话就回去看看呗。
至此，可以说ioctl的整个写过程已经说完了，至于读过程就不说了。累，确实有点累。
结束语
i2c-dev.c提供了一套不依赖于具体平台的驱动，让具体的驱动逻辑放在应用程序中，和SPI中的spidev.c的作用是很类似的。