详解Linux-I2C驱动(硬件原理\驱动分析\测试)_linux i2c 设备驱动 休眠唤醒 测试

[root@FORLINX210]# cat eeprom                                                                      
�����������X�����������������������������������������������
   
   

    
    
   
   

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<string.h>
 
int main(void){
  int fd, size, len, i;
  char buf[50]= {0};
  char *bufw="Hi,this is an eepromtest!";//要写入的数据
 
  len=strlen(bufw);//数据长度
  fd= open("/sys/bus/i2c/devices/0-0050/eeprom",O_RDWR);//打开文件
  if(fd< 0)
  {
      printf("####i2c test device open failed####/n");
      return(-1);
  }
  //写操作
  lseek(fd,0x40,SEEK_SET); //定位地址，地址是0x40
  if((size=write(fd,bufw, len))<0)//写入数据
  {
      printf("write error\n");
      return 1;
  }
  printf("writeok\n");
  //读操作
  lseek(fd,0x40, SEEK_SET);//准备读，首先定位地址，因为前面写入的时候更新了当前文件偏移量，所以这边需要重新定位到0x40.
  if((size=read(fd,buf,len))<0)//读数据
  {
      printf("readerror\n");
      return 1;
  }
  printf("readok\n");
  for(i=0; i< len; i++)
      printf("buff[%d]=%x\n",i, buf[i]);//打印数据
  close(fd);
 
  return 0;
}
   
   

    
    
   
   

struct i2c_msg { //i2c消息结构体，每个i2c消息对应一个结构体
 __u16 addr; /* 从设备地址，此处就是eeprom地址，即0x50 */
 __u16 flags;    /* 一些标志，比如i2c读等*/
 __u16 len;      /* i2c消息的长度 */
 __u8 *buf;      /* 指向i2c消息中的数据 */
 };
 
struct i2c_rdwr_ioctl_data {
 struct i2c_msg __user *msgs;    /* 指向一个i2c消息 */
 __u32 nmsgs;            /* i2c消息的数量 */
};
   
   

    
    
   
   

#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 fd,ret;
    struct i2c_rdwr_ioctl_data e2prom_data;
    fd=open("/dev/i2c/0",O_RDWR);//打开eeprom设备文件结点
    if(fd<0)
    {
        perror("open error");
    }
 
    e2prom_data.nmsgs=2; 
    e2prom_data.msgs=(struct i2c_msg*)malloc(e2prom_data.nmsgs*sizeof(struct i2c_msg));//分配空间
    if(!e2prom_data.msgs)
    {
        perror("malloc error");
        exit(1);
    }
    ioctl(fd,I2C_TIMEOUT,1);/*超时时间*/
    ioctl(fd,I2C_RETRIES,2);/*重复次数*/
 
    /*写eeprom*/
    e2prom_data.nmsgs=1;//由前面eeprom读写分析可知，写eeprom需要一条消息
    (e2prom_data.msgs[0]).len=2; //此消息的长度为2个字节，第一个字节是要写入数据的地址，第二个字节是要写入的数据
    (e2prom_data.msgs[0]).addr=0x50;//e2prom 设备地址
    (e2prom_data.msgs[0]).flags=0; //写
    (e2prom_data.msgs[0]).buf=(unsigned char*)malloc(2);
    (e2prom_data.msgs[0]).buf[0]=0x10;// e2prom 写入目标的地址
    (e2prom_data.msgs[0]).buf[1]=0x58;//写入的数据
    ret=ioctl(fd,I2C_RDWR,(unsigned long)&e2prom_data);//通过ioctl进行实际写入操作，后面会详细分析
    if(ret<0)
    {
        perror("ioctl error1");
    }
    sleep(1);
 
    /*读eeprom*/
    e2prom_data.nmsgs=2;//读eeprom需要两条消息
    (e2prom_data.msgs[0]).len=1; //第一条消息实际是写eeprom，需要告诉eeprom需要读数据的地址，因此长度为1个字节
    (e2prom_data.msgs[0]).addr=0x50; // e2prom 设备地址
    (e2prom_data.msgs[0]).flags=0;//先是写
    (e2prom_data.msgs[0]).buf[0]=0x10;//e2prom上需要读的数据的地址
    (e2prom_data.msgs[1]).len=1;//第二条消息才是读eeprom，
    (e2prom_data.msgs[1]).addr=0x50;// e2prom 设备地址 
    (e2prom_data.msgs[1]).flags=I2C_M_RD;//然后是读
    (e2prom_data.msgs[1]).buf=(unsigned char*)malloc(1);//存放返回值的地址。
    (e2prom_data.msgs[1]).buf[0]=0;//初始化读缓冲，读到的数据放到此缓冲区
    ret=ioctl(fd,I2C_RDWR,(unsigned long)&e2prom_data);//通过ioctl进行实际的读操作
    if(ret<0)
    {
        perror("ioctl error2");
    }
 
    printf("buff[0]=%x\n",(e2prom_data.msgs[1]).buf[0]);
    /***打印读出的值，没错的话，就应该是前面写的0x58了***/
    close(fd);
 
    return 0;
}
   
   

    
    
   
   

struct i2c_adapter {
  struct module *owner;//所属模块
  unsigned int id;
  unsigned int class;       /* classes to allow probing for */
  const struct i2c_algorithm *algo; /* 总线通讯方法指针，需要其产生特定的访问周期信号 */
  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 list_head userspace_clients;
};
   
   

    
    
   
   

struct i2c_algorithm {
  int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
            int num);//产生i2c访问周期说需要的信号
  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 *);//返回说支持的通讯协议
};
   
   

    
    
   
   

struct i2c_driver {
 unsigned int class;
 
 int (*probe)(struct i2c_client *, const struct i2c_device_id *);
 int (*remove)(struct i2c_client *);
 void (*shutdown)(struct i2c_client *);
 int (*suspend)(struct i2c_client *, pm_message_t mesg);
 int (*resume)(struct i2c_client *);
 void (*alert)(struct i2c_client *, unsigned int data);
 int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
 struct device_driver driver;
 const struct i2c_device_id *id_table;//该驱动所支持的i2c设备的ID表
 int (*detect)(struct i2c_client *, struct i2c_board_info *);
 const unsigned short *address_list;
 struct list_head clients;
};
   
   

    
    
   
   

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

    
    
   
   

struct i2c_msg {
 __u16 addr; /* slave address            */
 __u16 flags;
 __u16 len;      /* msg length               */
 __u8 *buf;      /* pointer to msg data          */
};
   
   

    
    
   
   

static struct at24_platform_data at24c01 = {
 .byte_len = SZ_8K / 8,/*eeprom大小*/
 .page_size = 8,/*页大小*/
};
 
/* I2C0 */
static struct i2c_board_info i2c_devs0[] __initdata = {
 {
     I2C_BOARD_INFO("24c01",0x50),//0x50是eeprom的设备地址
     .platform_data=&at24c01,
 },
}
   
   

    
    
   
   

 static void __init smdkc110_machine_init(void)
 {
 ….
 i2c_register_board_info(0, i2c_devs0, ARRAY_SIZE(i2c_devs0));
 ….
 }
   
   

    
    
   
   

 static struct i2c_driver at24_driver = {
 .driver = {
     .name = "at24",
     .owner = THIS_MODULE,
 },
 .probe = at24_probe,
 .remove = __devexit_p(at24_remove),
 .id_table = at24_ids,
 };
   
   

    
    
   
   

 static int __init at24_init(void)//模块初始化
 {
    io_limit = rounddown_pow_of_two(io_limit);//io_limit是写eeprom时允许一次写入的最大字节，默认128Byte，是驱动模块参数。
    return i2c_add_driver(&at24_driver);//添加i2c_driver,在i2c核心中实现，会调用at24_probe.
 }
 module_init(at24_init);
 
 static void __exit at24_exit(void)//模块卸载
 {
    i2c_del_driver(&at24_driver);//删除i2c_driver,会调用at24_remove
 }
 module_exit(at24_exit);
   
   

    
    
   
   

static int at24_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
struct at24_platform_data chip;
bool writable;
int use_smbus = 0;
struct at24_data *at24;
int err;
unsigned i, num_addresses;
kernel_ulong_t magic;
 
//获取板级设备信息
if (client->dev.platform_data) {
    chip = *(struct at24_platform_data *)client->dev.platform_data;
} else {
    if (!id->driver_data) {
        err = -ENODEV;
        goto err_out;
    }
    magic = id->driver_data;
    chip.byte_len = BIT(magic & AT24_BITMASK(AT24_SIZE_BYTELEN));
    magic >>= AT24_SIZE_BYTELEN;
    chip.flags = magic & AT24_BITMASK(AT24_SIZE_FLAGS);
    /*
     * This is slow, but we can't know all eeproms, so we better
     * play safe. Specifying custom eeprom-types via platform_data
     * is recommended anyhow.
     */
    chip.page_size = 1;
 
    chip.setup = NULL;
    chip.context = NULL;
}
 
//检查参数，必须为2的幂
if (!is_power_of_2(chip.byte_len))
    dev_warn(&client->dev,
        "byte_len looks suspicious (no power of 2)!\n");
if (!is_power_of_2(chip.page_size))
    dev_warn(&client->dev,
        "page_size looks suspicious (no power of 2)!\n");
 
/* Use I2C operations unless we're stuck with SMBus extensions. */
//检查是否支持I2C协议，如果不支持则检查是否支持SMBUS
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
    if (chip.flags & AT24_FLAG_ADDR16) {
        err = -EPFNOSUPPORT;
        goto err_out;
    }
    if (i2c_check_functionality(client->adapter,
            I2C_FUNC_SMBUS_READ_I2C_BLOCK)) {
        use_smbus = I2C_SMBUS_I2C_BLOCK_DATA;
    } else if (i2c_check_functionality(client->adapter,
            I2C_FUNC_SMBUS_READ_WORD_DATA)) {
        use_smbus = I2C_SMBUS_WORD_DATA;
    } else if (i2c_check_functionality(client->adapter,
            I2C_FUNC_SMBUS_READ_BYTE_DATA)) {
        use_smbus = I2C_SMBUS_BYTE_DATA;
    } else {
        err = -EPFNOSUPPORT;
        goto err_out;
    }
}
if (chip.flags & AT24_FLAG_TAKE8ADDR)//检查时候使用8个地址
    num_addresses = 8;
else
    num_addresses = DIV_ROUND_UP(chip.byte_len,//AT24C01使用一个地址
        (chip.flags & AT24_FLAG_ADDR16) ? 65536 : 256);
at24 = kzalloc(sizeof(struct at24_data) +
    num_addresses * sizeof(struct i2c_client *), GFP_KERNEL);//为at24_data分配内存，同时根据地址个数分配i2c_client
if (!at24) {
    err = -ENOMEM;
    goto err_out;
}
mutex_init(&at24->lock);
//初始化at24_data，也就是填充此结构体
at24->use_smbus = use_smbus;
at24->chip = chip;
at24->num_addresses = num_addresses;
/*
 * Export the EEPROM bytes through sysfs, since that's convenient.
 * By default, only root should see the data (maybe passwords etc)
 */
//以二进制结点的形式呈现eeprom的数据
sysfs_bin_attr_init(&at24->bin);
at24->bin.attr.name = "eeprom";//结点名字
at24->bin.attr.mode = chip.flags & AT24_FLAG_IRUGO ? S_IRUGO : S_IRUSR;
at24->bin.read = at24_bin_read;//绑定读函数
at24->bin.size = chip.byte_len;
 
at24->macc.read = at24_macc_read;
 
//判断是否可写
writable = !(chip.flags & AT24_FLAG_READONLY);
if (writable) {//如果可写
    if (!use_smbus || i2c_check_functionality(client->adapter,
            I2C_FUNC_SMBUS_WRITE_I2C_BLOCK)) {
 
        unsigned write_max = chip.page_size;
 
        at24->macc.write = at24_macc_write;
 
        at24->bin.write = at24_bin_write;//绑定写函数
        at24->bin.attr.mode |= S_IWUSR;//文件拥有者可写
 
        if (write_max > io_limit)//一次最多写io_limit个字节
            write_max = io_limit;
        if (use_smbus && write_max > I2C_SMBUS_BLOCK_MAX)
            write_max = I2C_SMBUS_BLOCK_MAX;
        at24->write_max = write_max;
 
        /* buffer (data + address at the beginning) */
        at24->writebuf = kmalloc(write_max + 2, GFP_KERNEL);//分配缓冲区，多余两个字节用于保存寄存器地址
        if (!at24->writebuf) {
            err = -ENOMEM;
            goto err_struct;
        }
    } else {
        dev_warn(&client->dev,
            "cannot write due to controller restrictions.");
    }
}
 
at24->client[0] = client;
 
/* use dummy devices for multiple-address chips */
for (i = 1; i < num_addresses; i++) {
    at24->client[i] = i2c_new_dummy(client->adapter,
                client->addr + i);
    if (!at24->client[i]) {
        dev_err(&client->dev, "address 0x%02x unavailable\n",
                client->addr + i);
        err = -EADDRINUSE;
        goto err_clients;
    }
}
 
//向sysfs文件系统注册二进制结点
err = sysfs_create_bin_file(&client->dev.kobj, &at24->bin);
if (err)
    goto err_clients;
 
//保存驱动数据
i2c_set_clientdata(client, at24);
 
dev_info(&client->dev, "%zu byte %s EEPROM %s\n",
    at24->bin.size, client->name,
    writable ? "(writable)" : "(read-only)");
if (use_smbus == I2C_SMBUS_WORD_DATA ||
    use_smbus == I2C_SMBUS_BYTE_DATA) {
    dev_notice(&client->dev, "Falling back to %s reads, "
           "performance will suffer\n", use_smbus ==
           I2C_SMBUS_WORD_DATA ? "word" : "byte");
}
dev_dbg(&client->dev,
    "page_size %d, num_addresses %d, write_max %d, use_smbus %d\n",
    chip.page_size, num_addresses,
    at24->write_max, use_smbus);
 
/* export data to kernel code */
if (chip.setup)
    chip.setup(&at24->macc, chip.context);
 
return 0;
err_clients:
for (i = 1; i < num_addresses; i++)
    if (at24->client[i])
        i2c_unregister_device(at24->client[i]);
 
kfree(at24->writebuf);
err_struct:
kfree(at24);
err_out:
dev_dbg(&client->dev, "probe error %d\n", err);
return err;
}
   
   

    
    
   
   

struct at24_data {
 struct at24_platform_data chip;
 struct memory_accessor macc;
 int use_smbus;
 
 /*
  * Lock protects against activities from other Linux tasks,
  * but not from changes by other I2C masters.
  */
 struct mutex lock;
 struct bin_attribute bin;//二进制结点
 
 u8 *writebuf;//写缓冲区
 unsigned write_max;
 unsigned num_addresses;
 
 /* 
  * Some chips tie up multiple I2C addresses; dummy devices reserve
  * them for us, and we'll use them with SMBus calls.
  */
 struct i2c_client *client[];
};
   
   

    
    
   
   

static int __devexit at24_remove(struct i2c_client *client)
{
struct at24_data *at24;
int i;
 
at24 = i2c_get_clientdata(client);
sysfs_remove_bin_file(&client->dev.kobj, &at24->bin);
 
for (i = 1; i < at24->num_addresses; i++)
    i2c_unregister_device(at24->client[i]);
 
kfree(at24->writebuf);
kfree(at24);
return 0;
}
   
   

    
    
   
   

static ssize_t at24_bin_read(struct file *filp, struct kobject *kobj,
     struct bin_attribute *attr,
     char *buf, loff_t off, size_t count)
{
 struct at24_data *at24;
 
 //通过kobj获得device，再获取driver_data
 at24 = dev_get_drvdata(container_of(kobj, struct device, kobj));
 return at24_read(at24, buf, off, count);//调用at24_read()
}
   
   

    
    
   
   

static ssize_t at24_read(struct at24_data *at24,
     char *buf, loff_t off, size_t count)
{
 ssize_t retval = 0;
 
 if (unlikely(!count))
     return count;
 
 /*
  * Read data from chip, protecting against concurrent updates
  * from this host, but not from other I2C masters.
  */
 mutex_lock(&at24->lock);//访问设备前加锁
 
 while (count) {
     ssize_t status;
 
     status = at24_eeprom_read(at24, buf, off, count);
     if (status <= 0) {
         if (retval == 0)
             retval = status;
         break;
     }
     buf += status;
     off += status;
     count -= status;
     retval += status;
 }
 
 mutex_unlock(&at24->lock);//访问结束后解锁
 
 return retval;
}
   
   

    
    
   
   

static ssize_t at24_eeprom_read(struct at24_data *at24, char *buf,
    unsigned offset, size_t count)
{
struct i2c_msg msg[2];
u8 msgbuf[2];
struct i2c_client *client;
unsigned long timeout, read_time;
int status, i;
 
memset(msg, 0, sizeof(msg));
 
/*
 * REVISIT some multi-address chips don't rollover page reads to
 * the next slave address, so we may need to truncate the count.
 * Those chips might need another quirk flag.
 *
 * If the real hardware used four adjacent 24c02 chips and that
 * were misconfigured as one 24c08, that would be a similar effect:
 * one "eeprom" file not four, but larger reads would fail when
 * they crossed certain pages.
 */
/*
 * Slave address and byte offset derive from the offset. Always
 * set the byte address; on a multi-master board, another master
 * may have changed the chip's "current" address pointer.
 */
client = at24_translate_offset(at24, &offset);//获得client
 
if (count > io_limit)
    count = io_limit;
 
switch (at24->use_smbus) {//如果使用SMBUS
case I2C_SMBUS_I2C_BLOCK_DATA:
    /* Smaller eeproms can work given some SMBus extension calls */
    if (count > I2C_SMBUS_BLOCK_MAX)
        count = I2C_SMBUS_BLOCK_MAX;
    break;
case I2C_SMBUS_WORD_DATA:
    count = 2;
    break;
case I2C_SMBUS_BYTE_DATA:
    count = 1;
    break;
default://使用I2C协议
    /*
     * When we have a better choice than SMBus calls, use a
     * combined I2C message. Write address; then read up to
     * io_limit data bytes. Note that read page rollover helps us
     * here (unlike writes). msgbuf is u8 and will cast to our
     * needs.
     */
    i = 0;
    if (at24->chip.flags & AT24_FLAG_ADDR16)
        msgbuf[i++] = offset >> 8;
    msgbuf[i++] = offset;
 
    //由前小节读eeprom的时序可知，需要2条消息，第一条消息是写eeprom
    msg[0].addr = client->addr;//设备地址，即0x50
    msg[0].buf = msgbuf;
    msg[0].len = i;
 
    //第二条消息才是读eeprom，读到的数据存储在buf中。
    msg[1].addr = client->addr;//设备地址
    msg[1].flags = I2C_M_RD;//读
    msg[1].buf = buf;//读缓冲区
    msg[1].len = count;//要读数据的长度
}
 
/*
 * Reads fail if the previous write didn't complete yet. We may
 * loop a few times until this one succeeds, waiting at least
 * long enough for one entire page write to work.
 */
timeout = jiffies + msecs_to_jiffies(write_timeout);
do {
    read_time = jiffies;
    switch (at24->use_smbus) {
    case I2C_SMBUS_I2C_BLOCK_DATA:
        status = i2c_smbus_read_i2c_block_data(client, offset,
                count, buf);
        break;
    case I2C_SMBUS_WORD_DATA:
        status = i2c_smbus_read_word_data(client, offset);
        if (status >= 0) {
            buf[0] = status & 0xff;
            buf[1] = status >> 8;
            status = count;
        }
        break;
    case I2C_SMBUS_BYTE_DATA:
        status = i2c_smbus_read_byte_data(client, offset);
        if (status >= 0) {
            buf[0] = status;
            status = count;
        }
        break;
    default://使用I2C协议去读
        status = i2c_transfer(client->adapter, msg, 2);//实际的数据传输，
        if (status == 2)
            status = count;
    }
    dev_dbg(&client->dev, "read %zu@%d --> %d (%ld)\n",
            count, offset, status, jiffies);
 
    if (status == count)//已经全部读取，则返回
        return count;
 
    /* REVISIT: at HZ=100, this is sloooow */
    msleep(1);
} while (time_before(read_time, timeout));
 
return -ETIMEDOUT;
}
   
   

    
    
   
   

 static ssize_t at24_bin_write(struct file *filp, struct kobject *kobj,
     struct bin_attribute *attr,
     char *buf, loff_t off, size_t count)
 {
 struct at24_data *at24;
 
 at24 = dev_get_drvdata(container_of(kobj, struct device, kobj));
 return at24_write(at24, buf, off, count);
 }
   
   

    
    
   
   

static ssize_t at24_write(struct at24_data *at24, const char *buf, loff_t off,
           size_t count)
{
 ssize_t retval = 0;
 
 if (unlikely(!count))
     return count;
 
 /*
  * Write data to chip, protecting against concurrent updates
  * from this host, but not from other I2C masters.
  */
 mutex_lock(&at24->lock);
 
 while (count) {
     ssize_t status;
 
     status = at24_eeprom_write(at24, buf, off, count);
     if (status <= 0) {
         if (retval == 0)
             retval = status;
         break;
     }
     buf += status;
     off += status;
     count -= status;
     retval += status;
 }
 
 mutex_unlock(&at24->lock);
 
 return retval;
}
   
   

    
    
   
   

static ssize_t at24_eeprom_write(struct at24_data *at24, const char *buf,
    unsigned offset, size_t count)
{
struct i2c_client *client;
struct i2c_msg msg;
ssize_t status;
unsigned long timeout, write_time;
unsigned next_page;
 
/* Get corresponding I2C address and adjust offset */
client = at24_translate_offset(at24, &offset);//获得对应的client
 
/* write_max is at most a page */
//检查写入字数
if (count > at24->write_max)
    count = at24->write_max;
 
/* Never roll over backwards, to the start of this page */
//写入不会越过页边界（下一页）
next_page = roundup(offset + 1, at24->chip.page_size);
if (offset + count > next_page)
    count = next_page - offset;
 
/* If we'll use I2C calls for I/O, set up the message */
if (!at24->use_smbus) {//使用i2c协议，则填充i2c消息结构体
    int i = 0;
    //由前小节分析，写eeprom只需一条i2c消息
    msg.addr = client->addr;//设备地址
    msg.flags = 0;//写eeprom
    /* msg.buf is u8 and casts will mask the values */
    msg.buf = at24->writebuf;//写缓冲区
    if (at24->chip.flags & AT24_FLAG_ADDR16)
        msg.buf[i++] = offset >> 8;
    msg.buf[i++] = offset;
    memcpy(&msg.buf[i], buf, count);//复制需要发送的数据
    msg.len = i + count;//发送传读为要发送的数据长度，加上地址长度
}
/*
 * Writes fail if the previous one didn't complete yet. We may
 * loop a few times until this one succeeds, waiting at least
 * long enough for one entire page write to work.
 */
timeout = jiffies + msecs_to_jiffies(write_timeout);//超时时间，为驱动模块参数，默认25ms
do {
    write_time = jiffies;
    if (at24->use_smbus) {
        status = i2c_smbus_write_i2c_block_data(client,
                offset, count, buf);
        if (status == 0)
            status = count;
    } else {//i2c传输
        status = i2c_transfer(client->adapter, &msg, 1);//实际传输
        if (status == 1)
            status = count;
    }
    dev_dbg(&client->dev, "write %zu@%d --> %zd (%ld)\n",
            count, offset, status, jiffies);
 
    if (status == count)//已经全部写入，返回
        return count;
 
    /* REVISIT: at HZ=100, this is sloooow */
    msleep(1);
} while (time_before(write_time, timeout));
 
return -ETIMEDOUT;
}
   
   

    
    
   
   

int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num)
{
 unsigned long orig_jiffies;
 int ret, try;
 
 /* 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
  *    continue executing the rest of this combined message, if
  *    that's the appropriate response.
  *
  *  - When for example "num" is two and we successfully complete
  *    the first 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) {
 #ifdef DEBUG
     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 = rt_mutex_trylock(&adap->bus_lock); 
         if (!ret)
             /* I2C activity is ongoing. */
             return -EAGAIN;
     } else {
         rt_mutex_lock(&adap->bus_lock);
     }   
 
     /* Retry automatically on arbitration loss */
     orig_jiffies = jiffies;
     for (ret = 0, try = 0; try <= adap->retries; try++) {
         ret = adap->algo->master_xfer(adap, msgs, num);//i2c总线驱动的入口
         if (ret != -EAGAIN)
             break;
         if (time_after(jiffies, orig_jiffies + adap->timeout))
             break;
     }
     rt_mutex_unlock(&adap->bus_lock);
 
     return ret;
 } else {
     dev_dbg(&adap->dev, "I2C level transfers not supported\n");
     return -EOPNOTSUPP;
 }
}
   
   

    
    
   
   

#define S3C2410_IICREG(x) (x)
 
#define S3C2410_IICCON    S3C2410_IICREG(0x00)//i2c控制寄存器
#define S3C2410_IICSTAT   S3C2410_IICREG(0x04)//i2c状态寄存器
#define S3C2410_IICADD    S3C2410_IICREG(0x08)//i2c地址寄存器
#define S3C2410_IICDS     S3C2410_IICREG(0x0C)//i2c收发数据移位寄存器
   
   

    
    
   
   

static int __init i2c_adap_s3c_init(void)
{
 return platform_driver_register(&s3c24xx_i2c_driver);//注册为平台驱动
}
subsys_initcall(i2c_adap_s3c_init);
 
static void __exit i2c_adap_s3c_exit(void)
{
 platform_driver_unregister(&s3c24xx_i2c_driver);
}
module_exit(i2c_adap_s3c_exit);
   
   

    
    
   
   

static struct 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,
 },
};
   
   

    
    
   
   

/* s3c24xx_i2c_probe
*
* called by the bus driver when a suitable device is found
*/
static int s3c24xx_i2c_probe(struct platform_device *pdev)
{
struct s3c24xx_i2c *i2c;//封装i2c适配器的信息
struct s3c2410_platform_i2c *pdata;//i2c平台数据
struct resource *res;//平台资源
int ret;
 
pdata = pdev->dev.platform_data;//找到平台数据
if (!pdata) {
    dev_err(&pdev->dev, "no platform data\n");
    return -EINVAL;
}
 
i2c = kzalloc(sizeof(struct s3c24xx_i2c), GFP_KERNEL);//为i2c适配器私有数据结构体分配内存空间，并且初始化为0
if (!i2c) {
    dev_err(&pdev->dev, "no memory for state\n");
    return -ENOMEM;
}
 
//填充i2c适配器私有数据结构体
strlcpy(i2c->adap.name, "s3c2410-i2c", sizeof(i2c->adap.name));//名字
i2c->adap.owner   = THIS_MODULE;//模块拥有者
i2c->adap.algo    = &s3c24xx_i2c_algorithm;//总线通讯方法
i2c->adap.retries = 2;//重试次数
i2c->adap.class   = I2C_CLASS_HWMON | I2C_CLASS_SPD;
i2c->tx_setup     = 50;
 
spin_lock_init(&i2c->lock);//i2c适配器私有数据的锁进行初始化
init_waitqueue_head(&i2c->wait);//初始化等待队列
 
/* find the clock and enable it */
//找到时钟，并且使能
i2c->dev = &pdev->dev;
i2c->clk = clk_get(&pdev->dev, "i2c");//找到时钟
 
if (IS_ERR(i2c->clk)) {
    dev_err(&pdev->dev, "cannot get clock\n");
    ret = -ENOENT;
    goto err_noclk;
}
 
dev_dbg(&pdev->dev, "clock source %p\n", i2c->clk);
 
clk_enable(i2c->clk);//使能
 
/* map the registers */
//映射寄存器
 
//获取平台设备资源，对于IORESOURSE_MEM类型的资源，start,end表示platform_device占据的内存的开始地址和结束地址
res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (res == NULL) {
    dev_err(&pdev->dev, "cannot find IO resource\n");
    ret = -ENOENT;
    goto err_clk;
}
 
//申请io内存资源
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;
    goto err_clk;
}
 
//映射io
//I/O端口空间映射到内存的虚拟地址
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核心所需数据
 
i2c->adap.algo_data = i2c;
i2c->adap.dev.parent = &pdev->dev;
 
/* initialise the i2c controller */
//i2c适配器私有数据结构提填充完了，就初始化i2c控制器
 
ret = s3c24xx_i2c_init(i2c);
if (ret != 0)
    goto err_iomap;
 
/* find the IRQ for this unit (note, this relies on the init call to
 * ensure no current IRQs pending
 */
//找到要申请的中断号
i2c->irq = ret = platform_get_irq(pdev, 0);
if (ret <= 0) {
    dev_err(&pdev->dev, "cannot find IRQ\n");
    goto err_iomap;
}
 
//申请中断，指定了中断处理函数s3c24xx_i2c_irq
ret = request_irq(i2c->irq, s3c24xx_i2c_irq, IRQF_DISABLED,
          dev_name(&pdev->dev), i2c);
 
if (ret != 0) {
    dev_err(&pdev->dev, "cannot claim IRQ %d\n", i2c->irq);
    goto err_iomap;
}
 
//动态变频，忽略
ret = s3c24xx_i2c_register_cpufreq(i2c);
if (ret < 0) {
    dev_err(&pdev->dev, "failed to register cpufreq notifier\n");
    goto err_irq;
}
 
/* Note, previous versions of the driver used i2c_add_adapter()
 * to add the bus at any number. We now pass the bus number via
 * the platform data, so if unset it will now default to always
 * being bus 0.
 */
i2c->adap.nr = pdata->bus_num;
 
//添加i2c适配器（cpu内部集成）
ret = i2c_add_numbered_adapter(&i2c->adap);
if (ret < 0) {
    dev_err(&pdev->dev, "failed to add bus to i2c core\n");
    goto err_cpufreq;
}
 
platform_set_drvdata(pdev, i2c);
 
clk_disable(i2c->clk);
 
dev_info(&pdev->dev, "%s: S3C I2C adapter\n", dev_name(&i2c->adap.dev));
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:
    kfree(i2c);
return ret;
}