struct i2c_adapter {struct module *owner;unsigned int class;       /*classes to allow probing for */const struct i2c_algorithm*algo; /* 总线上数据传输的算法*/void *algo_data;              /* algorithm 数据 */int timeout;            /* injiffies */int retries;             /* 重试次数 */struct device dev;      /* the adapter device */int nr;char name[48];                 /* 适配器名字 */struct completion dev_released;   /* 用于同步 */
};

struct i2c_algorithm {int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs, intnum);int (*smbus_xfer) (struct i2c_adapter *adap, u16 addr,unsigned short flags, charread_write,u8 command, int size, unioni2c_smbus_data *data);u32 (*functionality) (structi2c_adapter *);
};

static int i2c_adapter_xxx_xfer(structi2c_adapter *adap, struct i2c_msg *msgs, int num)
{......for (i = 0; i < num; i++) {i2c_adapter_xxx_start();         /*产生起始位*/if (msgs[i]->flags & I2C_M_RD) {    /*读取*/i2c_adapter_xxx_setaddr((msg->addr << 1) | 1);  /*发送从设备地址*/i2c_adapter_xxx_wait_ack();   /*获得从设备的ACK*/
i2c_adapter_xxx_readbytes(msgs[i]->buf,msgs[i]->len);  /*读取len长度的数据到buf中*/} else {i2c_adapter_xxx_setaddr(msg->addr << 1);i2c_adapter_xxx_wait_ack();i2c_adapter_xxx_writebytes(msgs[i]->buf, msgs[i]->len);}}i2c_adapter_xxx_stop(); /*产生停止位*/
}

struct i2c_driver {unsignedint class;int(*attach_adapter)(struct i2c_adapter *) __deprecated; /*依附i2c适配器函数指针*/int(*detach_adapter)(struct i2c_adapter *) __deprecated;/*脱离i2c适配器函数指针*/int (*probe)(struct i2c_client*, const struct i2c_device_id *);int (*remove)(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;  /* 该驱动所支持的设备ID表 *//*Device detection callback for automatic device creation */int(*detect)(struct i2c_client *, struct i2c_board_info *);constunsigned short *address_list;structlist_head clients;
};

struct i2c_client {
unsigned short flags;                 /*I2C_CLIENT_TEN：使用10位从地址，I2C_CLIENT_PEC：使用SMBus包错误检测*/unsignedshort addr;                 /* chipaddress - NOTE: 7bit    */charname[I2C_NAME_SIZE];struct i2c_adapter *adapter; /* 依附的i2c_adapter   */struct i2c_driver *driver;         /* 依附的i2c_driver*/structdevice dev;             /* the devicestructure             */intirq;                         /* irq issuedby device               */structlist_head detected;
};

static int i2c_register_adapter(struct i2c_adapter *adap)
{int res = 0;/* Can't register until after driver model init */if (unlikely(WARN_ON(!i2c_bus_type.p))) {res = -EAGAIN;goto out_list;}/* Sanity checks */if (unlikely(adap->name[0] == '\0')) {pr_err("i2c-core: Attempt to register an adapter with ""no name!\n");return -EINVAL;}if (unlikely(!adap->algo)) {pr_err("i2c-core: Attempt to register adapter '%s' with ""no algo!\n", adap->name);return -EINVAL;}rt_mutex_init(&adap->bus_lock);mutex_init(&adap->userspace_clients_lock);INIT_LIST_HEAD(&adap->userspace_clients);/* Set default timeout to 1 second if not already set */if (adap->timeout == 0)adap->timeout = HZ;dev_set_name(&adap->dev, "i2c-%d", adap->nr);adap->dev.bus = &i2c_bus_type;adap->dev.type = &i2c_adapter_type;res = device_register(&adap->dev);if (res)goto out_list;dev_dbg(&adap->dev, "adapter [%s] registered\n", adap->name);#ifdef CONFIG_I2C_COMPATres = class_compat_create_link(i2c_adapter_compat_class, &adap->dev,adap->dev.parent);if (res)dev_warn(&adap->dev,"Failed to create compatibility class link\n");
#endif/* create pre-declared device nodes */if (adap->nr < __i2c_first_dynamic_bus_num)i2c_scan_static_board_info(adap);/* Notify drivers */mutex_lock(&core_lock);bus_for_each_drv(&i2c_bus_type, NULL, adap, __process_new_adapter);mutex_unlock(&core_lock);return 0;out_list:mutex_lock(&core_lock);idr_remove(&i2c_adapter_idr, adap->nr);mutex_unlock(&core_lock);return res;
}

/** An i2c_driver is used with one or more i2c_client (device) nodes to access* i2c slave chips, on a bus instance associated with some i2c_adapter.*/
int i2c_register_driver(struct module *owner, struct i2c_driver *driver)
{int res;/* Can't register until after driver model init */if (unlikely(WARN_ON(!i2c_bus_type.p)))return -EAGAIN;/* add the driver to the list of i2c drivers in the driver core */driver->driver.owner = owner;driver->driver.bus = &i2c_bus_type;/* When registration returns, the driver core* will have called probe() for all matching-but-unbound devices.*/res = driver_register(&driver->driver);if (res)return res;pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);INIT_LIST_HEAD(&driver->clients);/* Walk the adapters that are already present */mutex_lock(&core_lock);bus_for_each_dev(&i2c_bus_type, NULL, driver, __process_new_driver);mutex_unlock(&core_lock);return 0;
}
EXPORT_SYMBOL(i2c_register_driver);

/*** i2c_transfer - execute a single or combined I2C message* @adap: Handle to I2C bus* @msgs: One or more messages to execute before STOP is issued to*    terminate the operation; each message begins with a START.* @num: Number of messages to be executed.** Returns negative errno, else the number of messages executed.** Note that there is no requirement that each message be sent to* the same slave address, although that is the most common model.*/
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 DEBUGfor (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 = i2c_trylock_adapter(adap);if (!ret)/* I2C activity is ongoing. */return -EAGAIN;} else {i2c_lock_adapter(adap);}/* 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);if (ret != -EAGAIN)break;if (time_after(jiffies, orig_jiffies + adap->timeout))break;}i2c_unlock_adapter(adap);return ret;} else {dev_dbg(&adap->dev, "I2C level transfers not supported\n");return -EOPNOTSUPP;}
}
EXPORT_SYMBOL(i2c_transfer);

struct bus_type i2c_bus_type = {.name        = "i2c",.match        = i2c_device_match,.probe        = i2c_device_probe,.remove        = i2c_device_remove,.shutdown    = i2c_device_shutdown,.pm        = &i2c_device_pm_ops,
};
EXPORT_SYMBOL_GPL(i2c_bus_type);
//
static int __init i2c_init(void)
{int retval;retval = bus_register(&i2c_bus_type);if (retval)return retval;
#ifdef CONFIG_I2C_COMPATi2c_adapter_compat_class = class_compat_register("i2c-adapter");if (!i2c_adapter_compat_class) {retval = -ENOMEM;goto bus_err;}
#endifretval = i2c_add_driver(&dummy_driver);if (retval)goto class_err;return 0;class_err:
#ifdef CONFIG_I2C_COMPATclass_compat_unregister(i2c_adapter_compat_class);
bus_err:
#endifbus_unregister(&i2c_bus_type);return retval;
}static void __exit i2c_exit(void)
{i2c_del_driver(&dummy_driver);
#ifdef CONFIG_I2C_COMPATclass_compat_unregister(i2c_adapter_compat_class);
#endifbus_unregister(&i2c_bus_type);
}/* We must initialize early, because some subsystems register i2c drivers* in subsys_initcall() code, but are linked (and initialized) before i2c.*/
postcore_initcall(i2c_init);
module_exit(i2c_exit);

static int __init i2c_dev_init(void)
{res= register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);i2c_dev_class= class_create(THIS_MODULE, "i2c-dev");/*Keep track of adapters which will be added or removed later */res= bus_register_notifier(&i2c_bus_type, &i2cdev_notifier);/*绑定已经存在的适配器 */i2c_for_each_dev(NULL,i2cdev_attach_adapter);
}

/* This is the structure as used in theI2C_RDWR ioctl call */
struct i2c_rdwr_ioctl_data {structi2c_msg __user *msgs;         /* pointersto i2c_msgs */__u32nmsgs;                    /* number ofi2c_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_NOSTART                  0x4000     /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_REV_DIR_ADDR     0x2000     /*if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_IGNORE_NAK          0x1000     /*if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_NO_RD_ACK           0x0800     /* if I2C_FUNC_PROTOCOL_MANGLING */
#define I2C_M_RECV_LEN               0x0400     /* length will be first received byte */__u16len;                  /* msg length                              */__u8*buf;                 /* pointer to msgdata                       */
};

static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client,unsignedlong arg)
{structi2c_rdwr_ioctl_data rdwr_arg;structi2c_msg *rdwr_pa;u8__user **data_ptrs;inti, res;if(copy_from_user(&rdwr_arg,(struct i2c_rdwr_ioctl_data __user *)arg,sizeof(rdwr_arg)))return-EFAULT;if(rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)return-EINVAL;rdwr_pa= kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg), GFP_KERNEL);if(copy_from_user(rdwr_pa, rdwr_arg.msgs,rdwr_arg.nmsgs * sizeof(struct i2c_msg))) {kfree(rdwr_pa);return-EFAULT;}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);}
}

#include <sys/ioctl.h>
#include <fcntl.h>
#include <unistd.h>
#include <string.h>
#include <stdio.h>
#include <linux/i2c.h>
#include <linux/i2c-dev.h>#define OSA_SOK      0  ///< Status : OK
#define OSA_EFAIL   -1  ///< Status : Generic error#define I2C_DEFAULT_INST_ID  (2)
#define I2C_TRANSFER_SIZE_MAX   (254)#ifndef TRUE
#define TRUE              1
#endif#ifndef FALSE
#define FALSE             0
#endiftypedef unsigned short    Bool;
typedef unsigned long long Uint64;      ///< Unsigned 64-bit integer
typedef unsigned int Uint32;            ///< Unsigned 32-bit integer
typedef unsigned short Uint16;          ///< Unsigned 16-bit integer
typedef unsigned char Uint8;            ///< Unsigned  8-bit integer

#define OSA_ERROR(...) \do \{ \fprintf(stderr, " ERROR  (%s|%s|%d): ", __FILE__, __func__, __LINE__); \fprintf(stderr, __VA_ARGS__); \} \while(0);typedef struct {int fd;} OSA_I2cHndl;#define OSA_I2C_DEBUGstatic char xtod(char c) {if (c>='0' && c<='9') return c-'0';if (c>='A' && c<='F') return c-'A'+10;if (c>='a' && c<='f') return c-'a'+10;return c=0;        // not Hex digit
}static int HextoDec(char *hex, int l)
{if (*hex==0) return(l);return HextoDec(hex+1, l*16+xtod(*hex)); // hex+1?
}int xstrtoi(char *hex)      // hex string to integer
{return HextoDec(hex,0);
}int OSA_i2cOpen(OSA_I2cHndl *hndl, Uint8 instId)
{char deviceName[20];int status = 0;sprintf(deviceName, "/dev/i2c-%d", instId);printf("dev name = %s \n", deviceName);hndl->fd = open(deviceName, O_RDWR);if(hndl->fd<0)return OSA_EFAIL;return status;
}int OSA_i2cRead8(OSA_I2cHndl *hndl, Uint16 devAddr, Uint8 *reg, Uint8 *value, Uint32 count)
{int i, j;int status = 0;struct i2c_msg * msgs = NULL;struct i2c_rdwr_ioctl_data data;msgs = (struct i2c_msg *) malloc(sizeof(struct i2c_msg) * count * 2);if(msgs==NULL){printf(" I2C (0x%02x): Malloc ERROR during Read !!! (reg[0x%02x], count = %d)\n", devAddr, reg[0], count);return OSA_EFAIL;}for (i = 0, j = 0; i < count * 2; i+=2, j++){msgs[i].addr  = devAddr;msgs[i].flags = 0;msgs[i].len   = 1;msgs[i].buf   = &reg[j];msgs[i+1].addr  = devAddr;msgs[i+1].flags = I2C_M_RD /* | I2C_M_REV_DIR_ADDR */;msgs[i+1].len   = 1;msgs[i+1].buf   = &value[j];}data.msgs = msgs;data.nmsgs = count * 2;status = ioctl(hndl->fd, I2C_RDWR, &data);if(status < 0){status = OSA_EFAIL;
#ifdef OSA_I2C_DEBUGprintf(" I2C (0x%02x): Read ERROR !!! (reg[0x%02x], count = %d)\n", devAddr, reg[0], count);
#endif}elsestatus = OSA_SOK;free(msgs);return status;
}int OSA_i2cWrite8(OSA_I2cHndl *hndl, Uint16 devAddr,  Uint8 *reg, Uint8 *value, Uint32 count)
{int i,j;unsigned char * bufAddr;int status = 0;struct i2c_msg * msgs = NULL;struct i2c_rdwr_ioctl_data data;msgs = (struct i2c_msg *) malloc(sizeof(struct i2c_msg) * count);if(msgs==NULL){printf(" I2C (0x%02x): Malloc ERROR during Write !!! (reg[0x%02x], count = %d)\n", devAddr, reg[0], count);return OSA_EFAIL;}bufAddr = (unsigned char *) malloc(sizeof(unsigned char) * count * 2);if(bufAddr == NULL){free(msgs);printf(" I2C (0x%02x): Malloc ERROR during Write !!! (reg[0x%02x], count = %d)\n", devAddr, reg[0], count);return OSA_EFAIL;}for (i = 0, j = 0; i < count; i++, j+=2){bufAddr[j] = reg[i];bufAddr[j + 1] = value[i];msgs[i].addr  = devAddr;msgs[i].flags = 0;msgs[i].len   = 2;msgs[i].buf   = &bufAddr[j];}data.msgs = msgs;data.nmsgs = count;status = ioctl(hndl->fd, I2C_RDWR, &data);if(status < 0){status = OSA_EFAIL;
#ifdef OSA_I2C_DEBUGprintf(" I2C (0x%02x): Write ERROR !!! (reg[0x%02x], count = %d)\n", devAddr, reg[0], count);
#endif}elsestatus = OSA_SOK;free(msgs);free(bufAddr);return status;
}int OSA_i2cRawWrite8(OSA_I2cHndl *hndl, Uint16 devAddr, Uint8 *value, Uint32 count)
{int status = 0;struct i2c_msg msgs[1];struct i2c_rdwr_ioctl_data data;msgs[0].addr  = devAddr;msgs[0].flags = 0;msgs[0].len   = count;msgs[0].buf   = value;data.msgs = msgs;data.nmsgs = 1;status = ioctl(hndl->fd, I2C_RDWR, &data);if(status < 0){status = OSA_EFAIL;
#ifdef OSA_I2C_DEBUGprintf(" I2C (0x%02x): Raw Write ERROR !!! (count = %d)\n", devAddr, count);
#endif}elsestatus = OSA_SOK;return status;
}int OSA_i2cRawRead8(OSA_I2cHndl *hndl, Uint16 devAddr, Uint8 *value, Uint32 count)
{int status = 0;struct i2c_msg msgs[1];struct i2c_rdwr_ioctl_data data;msgs[0].addr  = devAddr;msgs[0].flags = I2C_M_RD;msgs[0].len   = count;msgs[0].buf   = value;data.msgs = msgs;data.nmsgs = 1;status = ioctl(hndl->fd, I2C_RDWR, &data);if(status < 0){status = OSA_EFAIL;
#ifdef OSA_I2C_DEBUGprintf(" I2C (0x%02x): Raw Read ERROR !!! count = %d)\n", devAddr, count);
#endif}elsestatus = OSA_SOK;return status;
}int OSA_i2cClose(OSA_I2cHndl *hndl)
{return close(hndl->fd);
}int OSA_i2cTestShowUsage(char *str)
{printf(" \n");printf(" I2C Test Utility, \r\n");printf(" Usage: %s -r|-w <devAddrInHex> <regAddrInHex> <regValueInHex or numRegsToReadInDec> \r\n", str);printf(" \n");return 0;
}int main(int argc, char **argv)
{OSA_I2cHndl i2cHndl;Uint8 devAddr, numRegs;Bool doRead;int status, i;static Uint8 regAddr[I2C_TRANSFER_SIZE_MAX], regValue8[I2C_TRANSFER_SIZE_MAX];if(argc<3) {OSA_i2cTestShowUsage(argv[0]);return -1;}if(strcmp(argv[1], "-r")==0)doRead=TRUE;elseif(strcmp(argv[1], "-w")==0)doRead=FALSE;else {OSA_i2cTestShowUsage(argv[0]);return -1;}devAddr = 0;numRegs = 4;regValue8[0] = 0;regAddr[0] = 0;if(argc>2)devAddr = xstrtoi(argv[2]);if(argc>3)regAddr[0] = xstrtoi(argv[3]);if(argc>4) {if(doRead){numRegs = atoi(argv[4]);if(numRegs>I2C_TRANSFER_SIZE_MAX)numRegs = I2C_TRANSFER_SIZE_MAX;}else {regValue8[0] = xstrtoi(argv[4]);}}if(devAddr==0) {printf(" I2C: Invalid device address\n");OSA_i2cTestShowUsage(argv[0]);return -1;}status = OSA_i2cOpen(&i2cHndl, I2C_DEFAULT_INST_ID);if(status != OSA_SOK) {OSA_ERROR("OSA_i2cOpen( instId = %d )\n", I2C_DEFAULT_INST_ID);return status;}if(status==OSA_SOK){if(doRead) {for(i=0; i<numRegs; i++)regValue8[i] = 0;for(i=1; i<numRegs; i++){regAddr[i] = regAddr[0]+i;}status = OSA_i2cRead8(&i2cHndl, devAddr, regAddr, regValue8, numRegs);if(status==OSA_SOK) {for(i=0; i<numRegs; i++) {printf(" I2C (0x%02x): 0x%02x = 0x%02x \n", devAddr, regAddr[i], regValue8[i] );}} else {printf(" I2C (0x%02x): Read ERROR !!! (reg[0x%02x], count = %d)\n", devAddr, regAddr[0], numRegs);}} else {status = OSA_i2cWrite8(&i2cHndl, devAddr, regAddr, regValue8, 1);if(status==OSA_SOK) {status = OSA_i2cRead8(&i2cHndl, devAddr, regAddr, regValue8, 1);}if(status==OSA_SOK) {printf(" I2C (0x%02x): 0x%02x = 0x%02x \n", devAddr, regAddr[0], regValue8[0] );} else {printf(" I2C (0x%02x): Write ERROR !!! (reg[0x%02x], value = 0x%02x\n", devAddr, regAddr[0], regValue8[0]);}}OSA_i2cClose(&i2cHndl);}return 0;
}