[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>intmain(void){intfd,size,len,i;charbuf[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);//定位地址，地址是0x40if((size=write(fd,bufw,len))<0)//写入数据{printf("write error\n");return1;}printf("writeok\n");//读操作lseek(fd,0x40,SEEK_SET);//准备读，首先定位地址，因为前面写入的时候更新了当前文件偏移量，所以这边需要重新定位到0x40.if((size=read(fd,buf,len))<0)//读数据{printf("readerror\n");return1;}printf("readok\n");for(i=0;i<len;i++)printf("buff[%d]=%x\n",i,buf[i]);//打印数据close(fd);return0;}

structi2c_msg{//i2c消息结构体，每个i2c消息对应一个结构体__u16 addr;/* 从设备地址，此处就是eeprom地址，即0x50 */__u16 flags;/* 一些标志，比如i2c读等*/__u16 len;/* i2c消息的长度 */__u8*buf;/* 指向i2c消息中的数据 */};structi2c_rdwr_ioctl_data{structi2c_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>intmain(){intfd,ret;structi2c_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=(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);/*重复次数*//*写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=(unsignedchar*)malloc(2);(e2prom_data.msgs[0]).buf[0]=0x10;// e2prom 写入目标的地址(e2prom_data.msgs[0]).buf[1]=0x58;//写入的数据ret=ioctl(fd,I2C_RDWR,(unsignedlong)&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=(unsignedchar*)malloc(1);//存放返回值的地址。(e2prom_data.msgs[1]).buf[0]=0;//初始化读缓冲，读到的数据放到此缓冲区ret=ioctl(fd,I2C_RDWR,(unsignedlong)&e2prom_data);//通过ioctl进行实际的读操作if(ret<0){perror("ioctl error2");}printf("buff[0]=%x\n",(e2prom_data.msgs[1]).buf[0]);/***打印读出的值，没错的话，就应该是前面写的0x58了***/close(fd);return0;}

structi2c_adapter{structmodule*owner;//所属模块unsignedintid;unsignedintclass;/* classes to allow probing for */conststructi2c_algorithm*algo;/* 总线通讯方法指针，需要其产生特定的访问周期信号 */void*algo_data;/* data fields that are valid for all devices   */structrt_mutex bus_lock;inttimeout;/* in jiffies */intretries;/* 重复次数 */structdevice dev;/* the adapter device */intnr;charname[48];structcompletion dev_released;structlist_head userspace_clients;};

structi2c_algorithm{int(*master_xfer)(structi2c_adapter*adap,structi2c_msg*msgs,intnum);//产生i2c访问周期说需要的信号int(*smbus_xfer)(structi2c_adapter*adap,u16 addr,unsignedshortflags,charread_write,u8 command,intsize,unioni2c_smbus_data*data);/* To determine what the adapter supports */u32(*functionality)(structi2c_adapter*);//返回说支持的通讯协议};

structi2c_driver{unsignedintclass;int(*probe)(structi2c_client*,conststructi2c_device_id*);int(*remove)(structi2c_client*);void(*shutdown)(structi2c_client*);int(*suspend)(structi2c_client*,pm_message_tmesg);int(*resume)(structi2c_client*);void(*alert)(structi2c_client*,unsignedintdata);int(*command)(structi2c_client*client,unsignedintcmd,void*arg);structdevice_driver driver;conststructi2c_device_id*id_table;//该驱动所支持的i2c设备的ID表int(*detect)(structi2c_client*,structi2c_board_info*);constunsignedshort*address_list;structlist_head clients;};

structi2c_client{unsignedshortflags;/* div., see below      */unsignedshortaddr;/* chip address - NOTE: 7bit    *//* addresses are stored in the  *//* _LOWER_ 7 bits       */charname[I2C_NAME_SIZE];structi2c_adapter*adapter;/* the adapter we sit on    */structi2c_driver*driver;/* and our access routines  */structdevice dev;/* the device structure     */intirq;/* irq issued by device     */structlist_head detected;};

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

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

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

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

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

staticintat24_probe(structi2c_client*client,conststructi2c_device_id*id){structat24_platform_data chip;boolwritable;intuse_smbus=0;structat24_data*at24;interr;unsignedi,num_addresses;kernel_ulong_tmagic;//获取板级设备信息if(client->dev.platform_data){chip=*(structat24_platform_data*)client->dev.platform_data;}else{if(!id->driver_data){err=-ENODEV;gotoerr_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协议，如果不支持则检查是否支持SMBUSif(!i2c_check_functionality(client->adapter,I2C_FUNC_I2C)){if(chip.flags&AT24_FLAG_ADDR16){err=-EPFNOSUPPORT;gotoerr_out;}if(i2c_check_functionality(client->adapter,I2C_FUNC_SMBUS_READ_I2C_BLOCK)){use_smbus=I2C_SMBUS_I2C_BLOCK_DATA;}elseif(i2c_check_functionality(client->adapter,I2C_FUNC_SMBUS_READ_WORD_DATA)){use_smbus=I2C_SMBUS_WORD_DATA;}elseif(i2c_check_functionality(client->adapter,I2C_FUNC_SMBUS_READ_BYTE_DATA)){use_smbus=I2C_SMBUS_BYTE_DATA;}else{err=-EPFNOSUPPORT;gotoerr_out;}}if(chip.flags&AT24_FLAG_TAKE8ADDR)//检查时候使用8个地址num_addresses=8;elsenum_addresses=DIV_ROUND_UP(chip.byte_len,//AT24C01使用一个地址(chip.flags&AT24_FLAG_ADDR16)?65536:256);at24=kzalloc(sizeof(structat24_data)+num_addresses*sizeof(structi2c_client*),GFP_KERNEL);//为at24_data分配内存，同时根据地址个数分配i2c_clientif(!at24){err=-ENOMEM;gotoerr_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)){unsignedwrite_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;gotoerr_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;gotoerr_clients;}}//向sysfs文件系统注册二进制结点err=sysfs_create_bin_file(&client->dev.kobj,&at24->bin);if(err)gotoerr_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);return0;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);returnerr;}

structat24_data{structat24_platform_data chip;structmemory_accessor macc;intuse_smbus;/** Lock protects against activities from other Linux tasks,* but not from changes by other I2C masters.*/structmutexlock;structbin_attribute bin;//二进制结点u8*writebuf;//写缓冲区unsignedwrite_max;unsignednum_addresses;/* * Some chips tie up multiple I2C addresses; dummy devices reserve* them for us, and we'll use them with SMBus calls.*/structi2c_client*client[];};

staticint__devexit at24_remove(structi2c_client*client){structat24_data*at24;inti;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);return0;}

staticssize_tat24_bin_read(structfile*filp,structkobject*kobj,structbin_attribute*attr,char*buf,loff_toff,size_tcount){structat24_data*at24;//通过kobj获得device，再获取driver_dataat24=dev_get_drvdata(container_of(kobj,structdevice,kobj));returnat24_read(at24,buf,off,count);//调用at24_read()}

staticssize_tat24_read(structat24_data*at24,char*buf,loff_toff,size_tcount){ssize_tretval=0;if(unlikely(!count))returncount;/** Read data from chip, protecting against concurrent updates* from this host, but not from other I2C masters.*/mutex_lock(&at24->lock);//访问设备前加锁while(count){ssize_tstatus;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);//访问结束后解锁returnretval;}

staticssize_tat24_eeprom_read(structat24_data*at24,char*buf,unsignedoffset,size_tcount){structi2c_msg msg[2];u8 msgbuf[2];structi2c_client*client;unsignedlongtimeout,read_time;intstatus,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);//获得clientif(count>io_limit)count=io_limit;switch(at24->use_smbus){//如果使用SMBUScaseI2C_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;caseI2C_SMBUS_WORD_DATA:count=2;break;caseI2C_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条消息，第一条消息是写eeprommsg[0].addr=client->addr;//设备地址，即0x50msg[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){caseI2C_SMBUS_I2C_BLOCK_DATA:status=i2c_smbus_read_i2c_block_data(client,offset,count,buf);break;caseI2C_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;caseI2C_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)//已经全部读取，则返回returncount;/* REVISIT: at HZ=100, this is sloooow */msleep(1);}while(time_before(read_time,timeout));return-ETIMEDOUT;}

staticssize_tat24_bin_write(structfile*filp,structkobject*kobj,structbin_attribute*attr,char*buf,loff_toff,size_tcount){structat24_data*at24;at24=dev_get_drvdata(container_of(kobj,structdevice,kobj));returnat24_write(at24,buf,off,count);}

staticssize_tat24_write(structat24_data*at24,constchar*buf,loff_toff,size_tcount){ssize_tretval=0;if(unlikely(!count))returncount;/** Write data to chip, protecting against concurrent updates* from this host, but not from other I2C masters.*/mutex_lock(&at24->lock);while(count){ssize_tstatus;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);returnretval;}

staticssize_tat24_eeprom_write(structat24_data*at24,constchar*buf,unsignedoffset,size_tcount){structi2c_client*client;structi2c_msg msg;ssize_tstatus;unsignedlongtimeout,write_time;unsignednext_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消息结构体inti=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);//超时时间，为驱动模块参数，默认25msdo{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)//已经全部写入，返回returncount;/* REVISIT: at HZ=100, this is sloooow */msleep(1);}while(time_before(write_time,timeout));return-ETIMEDOUT;}

inti2c_transfer(structi2c_adapter*adap,structi2c_msg*msgs,intnum){unsignedlongorig_jiffies;intret,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){#ifdefDEBUGfor(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)?"+":"");}#endifif(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);returnret;}else{dev_dbg(&adap->dev,"I2C level transfers not supported\n");return-EOPNOTSUPP;}}

#defineS3C2410_IICREG(x)(x)#defineS3C2410_IICCON    S3C2410_IICREG(0x00)//i2c控制寄存器#defineS3C2410_IICSTAT   S3C2410_IICREG(0x04)//i2c状态寄存器#defineS3C2410_IICADD    S3C2410_IICREG(0x08)//i2c地址寄存器#defineS3C2410_IICDS     S3C2410_IICREG(0x0C)//i2c收发数据移位寄存器

staticint__init i2c_adap_s3c_init(void){returnplatform_driver_register(&s3c24xx_i2c_driver);//注册为平台驱动}subsys_initcall(i2c_adap_s3c_init);staticvoid__exit i2c_adap_s3c_exit(void){platform_driver_unregister(&s3c24xx_i2c_driver);}module_exit(i2c_adap_s3c_exit);

staticstructplatform_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
*/staticints3c24xx_i2c_probe(structplatform_device*pdev){structs3c24xx_i2c*i2c;//封装i2c适配器的信息structs3c2410_platform_i2c*pdata;//i2c平台数据structresource*res;//平台资源intret;pdata=pdev->dev.platform_data;//找到平台数据if(!pdata){dev_err(&pdev->dev,"no platform data\n");return-EINVAL;}i2c=kzalloc(sizeof(structs3c24xx_i2c),GFP_KERNEL);//为i2c适配器私有数据结构体分配内存空间，并且初始化为0if(!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;gotoerr_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;gotoerr_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;gotoerr_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;gotoerr_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)gotoerr_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");gotoerr_iomap;}//申请中断，指定了中断处理函数s3c24xx_i2c_irqret=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);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 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");gotoerr_cpufreq;}platform_set_drvdata(pdev,i2c);clk_disable(i2c->clk);dev_info(&pdev->dev,"%s: S3C I2C adapter\n",dev_name(&i2c->adap.dev));return0;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);returnret;}

structs3c24xx_i2c{spinlock_tlock;//用于防止并发访问的锁wait_queue_head_twait;//等待队列unsignedintsuspended:1;structi2c_msg*msg;//i2c消息unsignedintmsg_num;//i2c消息的数量unsignedintmsg_idx;//当前消息中的一个指针unsignedintmsg_ptr;//消息索引unsignedinttx_setup;//等待数据发送到总线上的一个建立时间unsignedintirq;//中断enums3c24xx_i2c_state  state;//i2c状态unsignedlongclkrate;void__iomem*regs;structclk*clk;structdevice*dev;structresource*ioarea;structi2c_adapter  adap;//i2c_adapter#ifdefCONFIG_CPU_FREQstructnotifier_block   freq_transition;#endif};

staticints3c24xx_i2c_init(structs3c24xx_i2c*i2c){unsignedlongiicon=S3C2410_IICCON_IRQEN|S3C2410_IICCON_ACKEN;//中断使能，ACK使能structs3c2410_platform_i2c*pdata;unsignedintfreq;/* get the plafrom data */pdata=i2c->dev->platform_data;//获取平台数据/* inititalise the gpio */if(pdata->cfg_gpio)//初始化gpio ，流程（1）pdata->cfg_gpio(to_platform_device(i2c->dev));/* write slave address */writeb(pdata->slave_addr,i2c->regs+S3C2410_IICADD);//写从设备地址dev_dbg(i2c->dev,"slave address 0x%02x\n",pdata->slave_addr);writel(iicon,i2c->regs+S3C2410_IICCON);//写控制寄存器，也就是使能中断和使能ACK，流程（2）/* 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 frequency required\n");return-EINVAL;}/* todo - check that the i2c lines aren't being dragged anywhere */dev_dbg(i2c->dev,"bus frequency set to %d KHz\n",freq);dev_dbg(i2c->dev,"S3C2410_IICCON=0x%02lx\n",iicon);dev_dbg(i2c->dev,"S3C2440_IICLC=%08x\n",pdata->sda_delay);writel(pdata->sda_delay,i2c->regs+S3C2440_IICLC);return0;}

staticconststructi2c_algorithm s3c24xx_i2c_algorithm={.master_xfer=s3c24xx_i2c_xfer,.functionality=s3c24xx_i2c_func,};

staticints3c24xx_i2c_xfer(structi2c_adapter*adap,structi2c_msg*msgs,intnum){structs3c24xx_i2c*i2c=(structs3c24xx_i2c*)adap->algo_data;//获得i2c适配器私有数据结构intretry;intret;clk_enable(i2c->clk);//使能时钟for(retry=0;retry<adap->retries;retry++){//传输不成功，则重试，retries为重试次数。ret=s3c24xx_i2c_doxfer(i2c,msgs,num);//启动一次i2c传输if(ret!=-EAGAIN)gotoout;dev_dbg(i2c->dev,"Retrying transmission (%d)\n",retry);udelay(100);}ret=-EREMOTEIO;out:clk_disable(i2c->clk);returnret;}

staticints3c24xx_i2c_doxfer(structs3c24xx_i2c*i2c,structi2c_msg*msgs,intnum){unsignedlongtimeout;intret;if(i2c->suspended)return-EIO;ret=s3c24xx_i2c_set_master(i2c);//检查i2c总线状态，总线不忙返回0if(ret!=0){dev_err(i2c->dev,"cannot get bus (error %d)\n",ret);ret=-EAGAIN;gotoout;}spin_lock_irq(&i2c->lock);//把消息写入i2c适配器的私有数据结构体中i2c->msg=msgs;//i2c消息i2c->msg_num=num;//消息数量i2c->msg_ptr=0;//消息指针，指向当前消息未发送部分的开始i2c->msg_idx=0;//消息索引i2c->state=STATE_START;//将状态改为STATE_STARTs3c24xx_i2c_enable_irq(i2c);//使能中断s3c24xx_i2c_message_start(i2c,msgs);//发送第一个byte，获得ACK后触发中断。spin_unlock_irq(&i2c->lock);timeout=wait_event_timeout(i2c->wait,i2c->msg_num==0,HZ*5);//等待消息传输完成，否则超时

staticints3c24xx_i2c_set_master(structs3c24xx_i2c*i2c){unsignedlongiicstat;inttimeout=400;while(timeout-->0){iicstat=readl(i2c->regs+S3C2410_IICSTAT);//读i2c状态寄存器if(!(iicstat&S3C2410_IICSTAT_BUSBUSY))//总线不忙，则返回0；否则直到超时return0;msleep(1);}writel(iicstat&~S3C2410_IICSTAT_TXRXEN,i2c->regs+S3C2410_IICSTAT);if(!(readl(i2c->regs+S3C2410_IICSTAT)&S3C2410_IICSTAT_BUSBUSY))return0;return-ETIMEDOUT;}

staticvoids3c24xx_i2c_message_start(structs3c24xx_i2c*i2c,structi2c_msg*msg){unsignedintaddr=(msg->addr&0x7f)<<1;//从设备地址，7位地址，最低位用来表示读或者写，1为读，0为写。unsignedlongstat;unsignedlongiiccon;stat=0;stat|=S3C2410_IICSTAT_TXRXEN;//使能RxTxif(msg->flags&I2C_M_RD){//从i2c消息判断，如果是读stat|=S3C2410_IICSTAT_MASTER_RX;//把状态设为主模式读addr|=1;//别且设置第一byte最低位为1，表示读}else//否则是写stat|=S3C2410_IICSTAT_MASTER_TX;//把状态设为主模式写if(msg->flags&I2C_M_REV_DIR_ADDR)//如果是读写反转addr^=1;//读写交换/* todo - check for wether ack wanted or not */s3c24xx_i2c_enable_ack(i2c);//使能ACKiiccon=readl(i2c->regs+S3C2410_IICCON);writel(stat,i2c->regs+S3C2410_IICSTAT);//根据前面的设置来配置控制寄存器，流程（3）dev_dbg(i2c->dev,"START: %08lx to IICSTAT, %02x to DS\n",stat,addr);writeb(addr,i2c->regs+S3C2410_IICDS);//把第一个byte写入i2c收发数据移位寄存器，流程（3）/* delay here to ensure the data byte has gotten onto the bus* 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);//修改状态，流程（3）}

staticirqreturn_ts3c24xx_i2c_irq(intirqno,void*dev_id){structs3c24xx_i2c*i2c=dev_id;unsignedlongstatus;unsignedlongtmp;status=readl(i2c->regs+S3C2410_IICSTAT);//获得i2c状态寄存器的值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);gotoout;}/* pretty much this leaves us with the fact that we've* transmitted or received whatever byte we last sent */i2c_s3c_irq_nextbyte(i2c,status);//推进传输，传输下一个byteout:returnIRQ_HANDLED;}

staticinti2c_s3c_irq_nextbyte(structs3c24xx_i2c*i2c,unsignedlongiicstat{unsignedlongtmp;unsignedcharbyte;intret=0;switch(i2c->state){//根据i2c的状态选择caseSTATE_IDLE://空闲dev_err(i2c->dev,"%s: called in STATE_IDLE\n",__func__);gotoout;break;caseSTATE_STOP://停止dev_err(i2c->dev,"%s: called in STATE_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*///切换为开始状态之前，刚发送了第一个byte，也就是设备地址//首先检查下state时候与硬件寄存器的状态一致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);//停止i2c传输gotoout_ack;}if(i2c->msg->flags&I2C_M_RD)//如果当前i2c消息的标志为i2c读i2c->state=STATE_READ;//则修改状态为i2c读elsei2c->state=STATE_WRITE;//否则修改为i2c写/* 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){//如果是最后一条消息则停止i2c传输。s3c24xx_i2c_stop(i2c,0);gotoout_ack;}if(i2c->state==STATE_READ)//如果i2c状态为读，就跳到读，否则，，就会跳到写，，，因为没有breakgotoprepare_read;/* fall through to the write state, as we will need to* send a byte as well */caseSTATE_WRITE://第一次开始写i2c/* we are writing data to the device... check for the* end of the message, and if so, work out what to 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)){//不是一条消息的最后1Bytebyte=i2c->msg->buf[i2c->msg_ptr++];//取出此消息的下一个bytewriteb(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);//延迟，等待数据发送}elseif(!is_lastmsg(i2c)){//是一条消息的最后一个byte，不是最后一条消息/* we need to go to the next i2c message */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 wether we are* going to do any more read/write*/byte=readb(i2c->regs+S3C2410_IICDS);//先获取读到的消息，后面再决定时候有用i2c->msg->buf[i2c->msg_ptr++]=byte;//把消息存入读缓冲prepare_read://如果第一个byte是读，则跳到此处。if(is_msglast(i2c)){//是当前消息的最后一byte，也就是当前消息只剩1Byte的空余/* last byte of buffer */if(is_lastmsg(i2c))//如果也是最后一条消息s3c24xx_i2c_disable_ack(i2c);//那么就禁止ACK}elseif(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);//停止i2c传输}else{//否则进入下一条i2c传输/* go to the next transfer */dev_dbg(i2c->dev,"READ: Next Transfer\n");i2c->msg_ptr=0;i2c->msg_idx++;i2c->msg++;//下一条i2c消息}}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:returnret;}