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

res = bus_register_notifier(&i2c_bus_type, &i2cdev_notifier);

/* Bind to already existing adapters right away */

i2c_for_each_dev(NULL, i2cdev_attach_adapter);

struct i2c_adapter *adap; /*适配器，用来描述一个i2c控制器的结构体*/

i2c_dev->dev = device_create(i2c_dev_class, &adap->dev,

     MKDEV(I2C_MAJOR, adap->nr), NULL,

     "i2c-%d", adap->nr);

struct device *device_create(struct class *class, struct device *parent,
     dev_t devt, void *drvdata, const char *fmt, ...)

static const struct file_operations i2cdev_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.read = i2cdev_read,
.write = i2cdev_write,
.unlocked_ioctl = i2cdev_ioctl, /*这个对用户态驱动来说就重要啦！*/
.open = i2cdev_open,
.release = i2cdev_release,
};

/*

 * After opening an instance of this character special file, a file

 * descriptor starts out associated only with an i2c_adapter (and bus).

 *

 * Using the I2C_RDWR ioctl(), you can then *immediately* issue i2c_msg

 * traffic to any devices on the bus used by that adapter.  That's because

 * the i2c_msg vectors embed all the addressing information they need, and

 * are submitted directly to an i2c_adapter.  However, SMBus-only adapters

 * don't support that interface.

 *

 * To use read()/write() system calls on that file descriptor, or to use

 * SMBus interfaces (and work with SMBus-only hosts!), you must first issue

 * an I2C_SLAVE (or I2C_SLAVE_FORCE) ioctl.  That configures an anonymous

 * (never registered) i2c_client so it holds the addressing information

 * needed by those system calls and by this SMBus interface.

 */

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

	struct i2c_client *client = file->private_data;

	unsigned long funcs;

	switch (cmd) {

		case I2C_SLAVE:

		case I2C_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 affect kernel 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;

		return 0;

		case I2C_TENBIT:
			if (arg)
				client->flags |= I2C_M_TEN;
			else
				client->flags &= ~I2C_M_TEN;
			return 0;

			case I2C_PEC:
			if (arg)
				client->flags |= I2C_CLIENT_PEC;
			else
				client->flags &= ~I2C_CLIENT_PEC;
			return 0;

		case I2C_FUNCS:
			funcs = i2c_get_functionality(client->adapter);
			return put_user(funcs, (unsigned long __user *)arg);

		case I2C_RDWR:
			return i2cdev_ioctl_rdrw(client, arg);
		case I2C_SMBUS:
			return i2cdev_ioctl_smbus(client, arg);
		case I2C_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 could cause trouble

		 * in buggy userspace code.  Some old kernel bugs returned

		 * zero in this case, and userspace code might accidentally

		 * have depended on that bug.

		 */

		return -ENOTTY;

	}

	return 0;
}

static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client,unsigned long arg)

/*重点就在这个消怎么构造*/
copy_from_user(&rdwr_arg, (struct i2c_rdwr_ioctl_data __user *)arg,sizeof(rdwr_arg))

struct i2c_msg {

__u16 addr; /* slave address */

__u16 flags; /*读写标志，在协议那里说明了，0或1*/

__u16 len; /* msg length*/

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

};

#include<stdio.h>
#include<sys/ioctl.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdlib.h>

typedef unsigned long long  __u64;
typedef unsigned int __u32;
typedef unsigned short __u16;
typedef unsigned char    __u8;

#define I2C_RDWR 0x0707 /* Combined R/W transfer (one STOP only) */

#define PATH  "/dev/i2c-0"

/*数据消息*/

typedef struct i2c_msg {
	__u16 addr; /* slave address */
	__u16 flags; /*读写标志，下面这些定义都是它的标志*/
	__u16 len; /* msg length*/
	__u8 *buf; /* pointer to msg data */
}I2C_MSG;

 

/* 传递给驱动的结构体 */

typedef struct i2c_rdwr_ioctl_data {
	I2C_MSG  *msgs; /* pointers to i2c_msgs */
	__u32 nmsgs; /* number of i2c_msgs */
}I2C_CtlData;

 

int main(void)
{

	int fd = 0;
	int ret = 0;

	/*定义通过控制函数传递给驱动的数据*/
	I2C_CtlData  e2p_Data;

	/*指针类型的必须分配空间，要不会段错误*/
	/*这里分配最大的消息空间，因为随机读数据需要两个消息*/
	e2p_Data.msgs = (I2C_MSG *)malloc(2*sizeof(I2C_MSG));
	(e2p_Data.msgs[0]).buf = (__u8 *)malloc(2); /*给指针分配两个字节*/
	(e2p_Data.msgs[1]).buf = (__u8 *)malloc(1);

	/*打开设备文件*/
	if( (fd = open(PATH,O_RDWR)) < 0)
		printf("No such file!\n");

	/*向i2c设备写入数据*/

	/*构建写消息*/
	e2p_Data.nmsgs = 1; /*写只有一条消息*/
	(e2p_Data.msgs[0]).flags = 0; /*0表示主设备向从设备写数据*/
	(e2p_Data.msgs[0]).addr = 0x50; /*看电路查看芯片手册*/
	(e2p_Data.msgs[0]).len = 2; /*消息长度，每个消息需要两个字节，一个地址，一个数据*/

	(e2p_Data.msgs[0]).buf[0] = 0X12; /*将数据方到芯片的0x12地址处*/
	(e2p_Data.msgs[0]).buf[1] = 0x11; /*消息数据*/
	
	if( (ret = ioctl(fd,I2C_RDWR,(unsigned long)&e2p_Data)) <0)
		printf("Control err in write data ! fd is %d\n",fd);

	/*读取i2c设备数据*/

	/*构建读消息*/

	e2p_Data.nmsgs = 2; /*读取数据需要两条消息，一条为写，一条读*/
	(e2p_Data.msgs[0]).len = 1; /*消息长度，只读一个数据*/
	(e2p_Data.msgs[0]).addr = 0x50; /*芯片片选地址*/
	(e2p_Data.msgs[0]).flags = 0; /*0表示写*/
	(e2p_Data.msgs[0]).buf[0] = 0X12; /*读取0x12地址*/
	(e2p_Data.msgs[1]).len = 1; /*读一个数据*/
	(e2p_Data.msgs[1]).addr = 0x50;
	(e2p_Data.msgs[1]).flags = 1; /*1表示读取数据*/ 
	(e2p_Data.msgs[1]).buf[0] = 0; /*将数据存放到此处*/

	if( (ret = ioctl(fd,I2C_RDWR,(unsigned long )&e2p_Data)) <0 )
		printf("Control err in read data! fd is:%d\n",fd);

	/*关闭设备文件*/
	printf("read data form e2prom is : %x\n",(e2p_Data.msgs[1]).buf[0]);

	free((e2p_Data.msgs[1]).buf );
	free((e2p_Data.msgs[0]).buf);
	free(e2p_Data.msgs);
	close(fd);
	return 0;
}