I2C驱动程序设计(3)—I2C用户态驱动程序设计

之前已经说过，有2种i2c驱动程序的设计，比如说针对EEPROM的驱动程序。我们可以专门编写一个针对EEPROM的驱动程序。另一种方式就是通过i2c-dev，即通过i2c通用通用驱动，来编写一个应用程序，来完成对设备的控制。我们现在就来实现i2c用户态驱动程序的设计。

1.通用设备驱动分析

• 首先需要分析i2c-dev，先打开i2c-dev.c这个文件，找到i2c_dev_init函数。
• register_chrdev用于创建注册一个字符设备，class_create用于生产一个字符类的设备文件，i2c_add_driver这是用来向Linux系统注册一个i2c设备驱动。

/* ------------------------------------------------------------------------- */
 
/*
 * module load/unload record keeping
 */
 
static int __init i2c_dev_init(void)
{
	int res;
 
	printk(KERN_INFO "i2c /dev entries driver\n");
 
	res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);
	if (res)
		goto out;
 
	i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");
	if (IS_ERR(i2c_dev_class)) {
		res = PTR_ERR(i2c_dev_class);
		goto out_unreg_chrdev;
	}
 
	res = i2c_add_driver(&i2cdev_driver);
	if (res)
		goto out_unreg_class;
 
	return 0;
 
out_unreg_class:
	class_destroy(i2c_dev_class);
out_unreg_chrdev:
	unregister_chrdev(I2C_MAJOR, "i2c");
out:
	printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
	return res;
}

• 接下来分析操作函数

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

• 这里包含很多操作，我们重点分析i2cdev_ioctl，因为在用户态中，主要通过这个函数来实现对设备的操作。

static long i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
	struct i2c_client *client = (struct i2c_client *)file->private_data;
	unsigned long funcs;
 
	dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
		cmd, arg);
 
	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;
}

• 里面实现了很多操作，我们主要关心的又是I2C_RDWR这个操作，即读和写。我们看看这个函数i2cdev_ioctl_rdrw.

static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client,
		unsigned long arg)
{
	struct i2c_rdwr_ioctl_data rdwr_arg;
	struct i2c_msg *rdwr_pa;
	u8 __user **data_ptrs;
	int i, res;
 
	if (copy_from_user(&rdwr_arg,
			   (struct i2c_rdwr_ioctl_data __user *)arg,
			   sizeof(rdwr_arg)))
		return -EFAULT;
 
	/* Put an arbitrary limit on the number of messages that can
	 * be sent at once */
	if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
		return -EINVAL;
 
	rdwr_pa = (struct i2c_msg *)
		kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg),
		GFP_KERNEL);
	if (!rdwr_pa)
		return -ENOMEM;
 
	if (copy_from_user(rdwr_pa, rdwr_arg.msgs,
			   rdwr_arg.nmsgs * sizeof(struct i2c_msg))) {
		kfree(rdwr_pa);
		return -EFAULT;
	}
 
	data_ptrs = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL);
	if (data_ptrs == NULL) {
		kfree(rdwr_pa);
		return -ENOMEM;
	}
 
	res = 0;
	for (i = 0; i < rdwr_arg.nmsgs; i++) {
		/* Limit the size of the message to a sane amount;
		 * and don't let length change either. */
		if ((rdwr_pa[i].len > 8192) ||
		    (rdwr_pa[i].flags & I2C_M_RECV_LEN)) {
			res = -EINVAL;
			break;
		}
		data_ptrs[i] = (u8 __user *)rdwr_pa[i].buf;
		rdwr_pa[i].buf = kmalloc(rdwr_pa[i].len, GFP_KERNEL);
		if (rdwr_pa[i].buf == NULL) {
			res = -ENOMEM;
			break;
		}
		if (copy_from_user(rdwr_pa[i].buf, data_ptrs[i],
				   rdwr_pa[i].len)) {
				++i; /* Needs to be kfreed too */
				res = -EFAULT;
			break;
		}
	}
	if (res < 0) {
		int j;
		for (j = 0; j < i; ++j)
			kfree(rdwr_pa[j].buf);
		kfree(data_ptrs);
		kfree(rdwr_pa);
		return res;
	}
 
	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);
	}
	kfree(data_ptrs);
	kfree(rdwr_pa);
	return res;
}

• 先来分析这个函数的参数，参数有2个client和arg，client应该是需要操作的设备，arg则是需要读写的参数，这个参数首先被强制转化为struct i2c_rdwr_ioctl_data这种结构体类型。

/* This is the structure as used in the I2C_RDWR ioctl call */
struct i2c_rdwr_ioctl_data {
	struct i2c_msg __user *msgs;	/* pointers to i2c_msgs */
	__u32 nmsgs;			/* number of i2c_msgs */
};

• 这里有2个成员，一个是消息指针，另一个是消息的数量，消息数量很好理解，我们看看消息指针的类型：

struct i2c_msg {
	__u16 addr;	/* slave address			*/
	__u16 flags;
#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 */
	__u16 len;		/* msg length				*/
	__u8 *buf;		/* pointer to msg data			*/
};

• 里面包含了设备的地址addr，flags（0为写，1为读）读写标志，消息的字节数，消息的数据指针，一次读操作和写操作可以视为一条消息。
• 接着来分析这个函数，做一些判断之后，接下来肯定就是读取消息数据了，它通过一个大循环for (i = 0; i < rdwr_arg.nmsgs; i++) 来读取参数里面的数据，然后使用i2c_transfer来传输这些数据。这个函数是属于i2c-croe里面的一个函数，但是这个函数并不会直接读写，而是找到挂载i2c总线控制器，通过总线控制器上面的算法来真正实现数据的传输。这个数据传输的线路和上面一节的数据流程图一摸一样。

2.用户态驱动设计

我们先分析一下程序大概的流程：

（1）打开通用的字符设备文件

• 依然是使用open打开设备文件，在开发板的/dev/下面我们可以找到一个叫做i2c-0的设备文件，我们以读写的方式打开这个设备文件。

// 1.打开通用设备文件
fd = open("/dev/i2c-0", O_RDWR);

（2）构造需要写入到EEPROM中的消息

• 我们首先需要赋值消息的定义到我们的程序中。即i2c_msg和i2c_rdwr_ioctl_data，可以把一些不需要的数据删掉。

struct i2c_msg 
{
	unsigned short addr;	
	unsigned short flags;
	unsigned short len;		
	unsigned char *buf;		
};

struct i2c_rdwr_ioctl_data 
{
	struct i2c_msg *msgs; // 消息指针
	unsigned int nmsgs;	// 消息数量		
};

• 然后定义一个消息结构，i2c_rdwr_ioctl_data eeprom_data，然后初始化这个结构（别忘了给指针分配空间）。特别要注意的是对应消息的数量读和写肯定是不一样的，因为对于写只需要一个消息，而对于读只需要2个消息，因为先做了一次写，然后在做了一次读。因此我们按最大的长度2，来给i2c_msg分配空间。
• 接下来可以初始化写的消息，写的信息有2个字节，所以len=2，第一个是偏移地址，第二个是需要写入的数据。初始化后如下：

// 因为对于写只需要一个消息
// 对于读只需要2个消息，因为先做了一次写，然后在做了一次读
// 因此我们按最大的长度2，来给i2c_msg分配空间 
e2prom_data.msgs = (struct i2c_msg *)malloc(2 * sizeof(struct i2c_msg)); 
	
// 2.构造写数据到eeprom的消息
e2prom_data.nmsgs = 1;  // 写只有一条消息
(e2prom_data.msgs[0]).len = 2;  // 偏移地址+数据
(e2prom_data.msgs[0]).addr = 0x50;  // eeprom设备地址
(e2prom_data.msgs[0]).flags = 0;  // 0为写，1为读
(e2prom_data.msgs[0]).buf = (unsigned char *)malloc(2);
(e2prom_data.msgs[0]).buf[0] = 0x10;  // 写入到EEPROM的偏移地址
(e2prom_data.msgs[0]).buf[1] = 0x60;  // 写入到偏移地址的数据

•  补充：EEPROM 芯片的设备地址一共有 7 位，其中高 4 位固定为：1010b，低 3 位则由 A0/A1/A2 信号线的电平决定，见图 24-10，图中的 R/W 是读写方向位，与地址无关。

 （3）使用ioctl写入数据

• ioctl的第一个参数是fd，第二个参数是操作类型，这里是I2C_RDWR，我们需要拷贝I2C_RDWR到自己的程序中，第三个是参数就是eeprom_data了，我们在取地址之后需要进行类型转换，因为i2cdev_ioctl_rdrw的参数是unsigned long.

#define I2C_RDWR	0x0707	
// 3.使用ioctl写入数据
ioctl(fd, I2C_RDWR, (unsigned long)&e2prom_data);

（4）构造从EEPROM读数据的消息

• 读消息的构造也类似，不过这里需要2个消息，第一个实现写，第二个实现读：

// 4.构造从EEPROM读数据的消息
eeprom_data.nmsgs = 2;  // 读有二条消息
(eeprom_data.msgs[0]).addr = 0x50;// 先写入需要开始读取的偏移地址，然后开始读
(eeprom_data.msgs[0]).flags = 0;
(eeprom_data.msgs[0]).len = 1;
(eeprom_data.msgs[0]).buf[0] = 0x10;

(eeprom_data.msgs[1]).addr = 0x50;
(eeprom_data.msgs[1]).flags = 1;
(eeprom_data.msgs[1]).len = 1;
(eeprom_data.msgs[1]).buf = (unsigned char *)malloc(2);
(eeprom_data.msgs[1]).buf[0] = 0;  // 先把读取缓冲清0

（5）使用ioctl读出消息

ioctl(fd, I2C_RDWR, (unsigned long)&eeprom_data);

// 读取到的消息会保存在以buf[0]为起始地址的存储空间中。

（6）关闭字符设备

• close(fd)

完整代码：

#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <linux/types.h>

#define I2C_RDWR 0x0707	

struct i2c_msg 
{
	unsigned short addr;	
	unsigned short flags;
	unsigned short len;		
	unsigned char *buf;		
};

struct i2c_rdwr_ioctl_data 
{
	struct i2c_msg *msgs;	// 消息指针
	unsigned int nmsgs;	// 消息数量		
};

int main()
{
	int fd;	
	struct i2c_rdwr_ioctl_data e2prom_data;
	
	// 1.打开通用设备文件
	fd = open("/dev/i2c-0", O_RDWR);
	
	// 因为对于写只需要一个消息
	// 对于读只需要2个消息，因为先做了一次写，然后在做了一次读
	// 因此我们按最大的长度2，来给i2c_msg分配空间 
	e2prom_data.msgs = (struct i2c_msg *)malloc(2 * sizeof(struct i2c_msg)); 
	
	// 2.构造写数据到eeprom的消息
	e2prom_data.nmsgs = 1;  // 写只有一条消息
	(e2prom_data.msgs[0]).len = 2;  // 偏移地址+数据
	(e2prom_data.msgs[0]).addr = 0x50;  // eeprom设备地址
	(e2prom_data.msgs[0]).flags = 0;  // //0为写，1为读
	(e2prom_data.msgs[0]).buf = (unsigned char *)malloc(2);
	(e2prom_data.msgs[0]).buf[0] = 0x10;  // 写入到EEPROM的偏移地址
	(e2prom_data.msgs[0]).buf[1] = 0x60;  // 写入到偏移地址的数据
	
	// 3.使用ioctl写入数据
	ioctl(fd, I2C_RDWR, (unsigned long)&e2prom_data);
	
	// 4.构造从EEPROM读数据的消息
	eeprom_data.nmsgs = 2;  // 读有二条消息
	(eeprom_data.msgs[0]).addr = 0x50;// 先写入需要开始读取的偏移地址，然后开始读
	(eeprom_data.msgs[0]).flags = 0;
	(eeprom_data.msgs[0]).len = 1;
	(eeprom_data.msgs[0]).buf[0] = 0x10;

	(eeprom_data.msgs[1]).addr = 0x50;
	(eeprom_data.msgs[1]).flags = 1;
	(eeprom_data.msgs[1]).len = 1;
	(eeprom_data.msgs[1]).buf = (unsigned char *)malloc(2);
	(eeprom_data.msgs[1]).buf[0] = 0;  // 先把读取缓冲清0

	
	// 5.使用ioctl读出数据	
	ioctl(fd, I2C_RDWR, (unsigned long)&e2prom_data);
	printf("buffer[0] = %x\n", (e2prom_data.msgs[1]).buf[0]);
	
	// 6.关闭设备
	close(fd);
}

3.编译

• arm-linux-gcc -static i2c-app-drv.c -o i2c-app-drv
• 拷贝到开发板上，执行./i2c-app-drv： 
•