使用的系统是64位的系统，而要求使用32位的库对i2c进行I2C_RDWR操作时出现问题，当使用32位的库进行2C_RDWR操作时总是失败，提示i2c_core_read fd(/dev/i2c-0) addr(12) reg(f0) nCnt(3)Error during I2C_RDWR ioctl with error code: -1，原本以为直接将arg参数直接转换一下就行了（compat_ptr(arg)），转换后发现还是不行，原因是参数的结构类型比较复杂的问题。具体可参考如下

具体的修改如下：

diff --git a/kernel-3.10/drivers/i2c/i2c-dev.c b/kernel-3.10/drivers/i2c/i2c-dev.c
index 2ac450f..3e6f811 100644
--- a/kernel-3.10/drivers/i2c/i2c-dev.c
+++ b/kernel-3.10/drivers/i2c/i2c-dev.c
@@ -41,6 +41,10 @@
 #include <linux/uaccess.h>
 #include <linux/dma-mapping.h>
 
+#ifdef CONFIG_COMPAT
+#include <linux/compat.h>
+#endif
+
 #define MAX_DMA_TRANSACTION_LEN 1024
 #define SUPPORT_I2C_DMA     1
 
@@ -49,6 +53,29 @@ static u8*gpDMABuf_va = NULL;
 static dma_addr_t gpDMABuf_pa ;	/* = NULL; */
 #endif 
 
+#ifdef CONFIG_COMPAT
+struct i2c_msg_compat {
+	__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_STOP		0x8000	/* if I2C_FUNC_PROTOCOL_MANGLING */
+#define I2C_M_NOSTART		0x4000	/* if I2C_FUNC_NOSTART */
+#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				*/
+	compat_uptr_t buf;		/* pointer to msg data		__u8 *buf;	*/
+	__u32 timing;			/* paramters of timings		*/
+	__u32 ext_flag;
+};
+
+struct i2c_rdwr_ioctl_data_compat {
+	compat_uptr_t msgs;	/* pointers to i2c_msgs */
+	__u32 nmsgs;			/* number of i2c_msgs */
+};
+#endif
 /*
  * An i2c_dev represents an i2c_adapter ... an I2C or SMBus master, not a
  * slave (i2c_client) with which messages will be exchanged.  It's coupled
@@ -243,6 +270,181 @@ static int i2cdev_check_addr(struct i2c_adapter *adapter, unsigned int addr)
 	return result;
 }
 
+#ifdef CONFIG_COMPAT
+static void compat_get_info_struct(
+            struct i2c_msg_compat *data32,
+            struct i2c_msg *data, int num)
+{
+    int i;
+	for (i=0; i<num; i++) {
+		data[i].addr = data32[i].addr;
+		data[i].flags = data32[i].flags;
+		data[i].len = data32[i].len;
+		data[i].buf = compat_ptr(data32[i].buf);
+		data[i].timing = data32[i].timing;
+		data[i].ext_flag = data32[i].ext_flag;
+	}
+}
+
+static noinline int i2cdev_ioctl_rdrw_compat(struct i2c_client *client,
+		unsigned long arg)
+{
+	struct i2c_rdwr_ioctl_data_compat  rdwr_arg;
+	struct i2c_msg_compat *rdwr_pa32;
+	struct i2c_msg *rdwr_pa;
+	u8 __user **data_ptrs;
+	int i, res;
+
+	if (copy_from_user(&rdwr_arg,(void __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;
+	pr_debug("i2cdev_ioctl_rdrw_compat rdwr_arg.nmsgs = %d\n", rdwr_arg.nmsgs);
+	rdwr_pa32 = memdup_user(compat_ptr(rdwr_arg.msgs),
+			      rdwr_arg.nmsgs * sizeof(struct i2c_msg_compat));
+
+	if (IS_ERR(rdwr_pa32))
+		return PTR_ERR(rdwr_pa32);
+
+	rdwr_pa = kmalloc(rdwr_arg.nmsgs * sizeof(*rdwr_pa), GFP_KERNEL);
+	compat_get_info_struct(rdwr_pa32, rdwr_pa, rdwr_arg.nmsgs);
+
+    #if SUPPORT_I2C_DMA
+    for(i = 0; i < rdwr_arg.nmsgs; i++)
+    {
+        if(rdwr_pa[i].timing == 0)
+        {
+            rdwr_pa[i].timing = client->timing;
+        }
+        rdwr_pa[i].ext_flag = client->ext_flag;
+    }
+    #endif
+
+	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 */
+		if (rdwr_pa[i].len > 8192) {
+			res = -EINVAL;
+			break;
+		}
+
+		data_ptrs[i] = (u8 __user *)rdwr_pa[i].buf;
+        #if SUPPORT_I2C_DMA
+        if(rdwr_pa[i].len > 8)
+        {
+            if (gpDMABuf_va == NULL)
+            {
+                gpDMABuf_va = dma_alloc_coherent(&client->dev,MAX_DMA_TRANSACTION_LEN, &gpDMABuf_pa, GFP_KERNEL);
+            }
+
+            if(copy_from_user(gpDMABuf_va,data_ptrs[i],rdwr_pa[i].len))
+				return -EFAULT;
+            rdwr_pa[i].buf = (u8 *)gpDMABuf_pa;
+            if(rdwr_pa[i].timing >= 300)
+            {
+                rdwr_pa[i].ext_flag = rdwr_pa[i].ext_flag|I2C_DMA_FLAG|I2C_HS_FLAG|I2C_RS_FLAG|I2C_PUSHPULL_FLAG;
+            }
+            else
+            {
+                rdwr_pa[i].ext_flag = rdwr_pa[i].ext_flag|I2C_DMA_FLAG|I2C_RS_FLAG|I2C_PUSHPULL_FLAG;
+            }
+        }
+        else
+        {
+            rdwr_pa[i].buf = memdup_user(data_ptrs[i], rdwr_pa[i].len);
+            rdwr_pa[i].ext_flag = rdwr_pa[i].ext_flag |I2C_RS_FLAG|I2C_PUSHPULL_FLAG;
+        }
+        #else
+		rdwr_pa[i].buf = memdup_user(data_ptrs[i], rdwr_pa[i].len);
+        #endif
+		if (IS_ERR(rdwr_pa[i].buf)) {
+			res = PTR_ERR(rdwr_pa[i].buf);
+			break;
+		}
+
+		/*
+		 * If the message length is received from the slave (similar
+		 * to SMBus block read), we must ensure that the buffer will
+		 * be large enough to cope with a message length of
+		 * I2C_SMBUS_BLOCK_MAX as this is the maximum underlying bus
+		 * drivers allow. The first byte in the buffer must be
+		 * pre-filled with the number of extra bytes, which must be
+		 * at least one to hold the message length, but can be
+		 * greater (for example to account for a checksum byte at
+		 * the end of the message.)
+		 */
+		if (rdwr_pa[i].flags & I2C_M_RECV_LEN) {
+			if (!(rdwr_pa[i].flags & I2C_M_RD) ||
+			    rdwr_pa[i].buf[0] < 1 ||
+			    rdwr_pa[i].len < rdwr_pa[i].buf[0] +
+					     I2C_SMBUS_BLOCK_MAX) {
+				res = -EINVAL;
+				break;
+			}
+
+			rdwr_pa[i].len = rdwr_pa[i].buf[0];
+		}
+	}
+	if (res < 0) {
+		int j;
+		for (j = 0; j < i; ++j)
+		{
+		    #if SUPPORT_I2C_DMA
+            if(rdwr_pa[i].ext_flag & I2C_DMA_FLAG)
+            {
+                rdwr_pa[j].buf = NULL;
+            }
+            #endif
+            {
+		        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 SUPPORT_I2C_DMA
+        if (res >= 0 && (rdwr_pa[i].flags & I2C_M_RD) && (rdwr_pa[i].ext_flag & I2C_DMA_FLAG))
+        {
+            if (copy_to_user(data_ptrs[i], gpDMABuf_va, rdwr_pa[i].len))
+				res = -EFAULT;
+        }
+        else
+        #endif
+        {
+			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;
+			}
+        }
+        #if SUPPORT_I2C_DMA
+        if(rdwr_pa[i].ext_flag & I2C_DMA_FLAG)
+        {
+            rdwr_pa[i].buf = NULL;
+        }
+        #endif
+        {
+	        kfree(rdwr_pa[i].buf);
+        }
+	}
+	kfree(data_ptrs);
+	kfree(rdwr_pa);
+       kfree(rdwr_pa32);
+	return res;
+}
+#endif
+
 static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client,
 		unsigned long arg)
 {
@@ -556,6 +758,17 @@ static long i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 	return 0;
 }
 
+#ifdef CONFIG_COMPAT
+static long i2cdev_ioctl_compat(struct file *file, unsigned int cmd, unsigned long arg)
+{
+	pr_debug("i2cdev_ioctl_compat cmd = %d arg=0x%02lx\n", cmd, arg);
+	if (cmd == I2C_RDWR) {
+		return i2cdev_ioctl_rdrw_compat(file->private_data, arg);
+	}
+    return i2cdev_ioctl(file, cmd, compat_ptr(arg));
+}
+#endif
+
 static int i2cdev_open(struct inode *inode, struct file *file)
 {
 	unsigned int minor = iminor(inode);
@@ -608,6 +821,9 @@ static const struct file_operations i2cdev_fops = {
 	.read		= i2cdev_read,
 	.write		= i2cdev_write,
 	.unlocked_ioctl	= i2cdev_ioctl,
+#ifdef CONFIG_COMPAT
+    .compat_ioctl = i2cdev_ioctl_compat,
+#endif
 	.open		= i2cdev_open,
 	.release	= i2cdev_release,
 };