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;	case I2C_SMBUS:		if (copy_from_user(&data_arg,		                   (struct i2c_smbus_ioctl_data __user *) arg,		                   sizeof(struct i2c_smbus_ioctl_data)))			return -EFAULT;		if ((data_arg.size != I2C_SMBUS_BYTE) &&		    (data_arg.size != I2C_SMBUS_QUICK) &&		    (data_arg.size != I2C_SMBUS_BYTE_DATA) &&		    (data_arg.size != I2C_SMBUS_WORD_DATA) &&		    (data_arg.size != I2C_SMBUS_PROC_CALL) &&		    (data_arg.size != I2C_SMBUS_BLOCK_DATA) &&		    (data_arg.size != I2C_SMBUS_I2C_BLOCK_BROKEN) &&		    (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA) &&		    (data_arg.size != I2C_SMBUS_BLOCK_PROC_CALL)) {			dev_dbg(&client->adapter->dev,				"size out of range (%x) in ioctl I2C_SMBUS.\n",				data_arg.size);			return -EINVAL;		}		/* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,		   so the check is valid if size==I2C_SMBUS_QUICK too. */		if ((data_arg.read_write != I2C_SMBUS_READ) &&		    (data_arg.read_write != I2C_SMBUS_WRITE)) {			dev_dbg(&client->adapter->dev,				"read_write out of range (%x) in ioctl I2C_SMBUS.\n",				data_arg.read_write);			return -EINVAL;		}		/* Note that command values are always valid! */		if ((data_arg.size == I2C_SMBUS_QUICK) ||		    ((data_arg.size == I2C_SMBUS_BYTE) &&		    (data_arg.read_write == I2C_SMBUS_WRITE)))			/* These are special: we do not use data */			return i2c_smbus_xfer(client->adapter, client->addr,					      client->flags,					      data_arg.read_write,					      data_arg.command,					      data_arg.size, NULL);		if (data_arg.data == NULL) {			dev_dbg(&client->adapter->dev,				"data is NULL pointer in ioctl I2C_SMBUS.\n");			return -EINVAL;		}		if ((data_arg.size == I2C_SMBUS_BYTE_DATA) ||		    (data_arg.size == I2C_SMBUS_BYTE))			datasize = sizeof(data_arg.data->byte);		else if ((data_arg.size == I2C_SMBUS_WORD_DATA) ||		         (data_arg.size == I2C_SMBUS_PROC_CALL))			datasize = sizeof(data_arg.data->word);		else /* size == smbus block, i2c block, or block proc. call */			datasize = sizeof(data_arg.data->block);		if ((data_arg.size == I2C_SMBUS_PROC_CALL) ||		    (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) ||		    (data_arg.size == I2C_SMBUS_I2C_BLOCK_DATA) ||		    (data_arg.read_write == I2C_SMBUS_WRITE)) {			if (copy_from_user(&temp, data_arg.data, datasize))				return -EFAULT;		}		if (data_arg.size == I2C_SMBUS_I2C_BLOCK_BROKEN) {			/* Convert old I2C block commands to the new			   convention. This preserves binary compatibility. */			data_arg.size = I2C_SMBUS_I2C_BLOCK_DATA;			if (data_arg.read_write == I2C_SMBUS_READ)				temp.block[0] = I2C_SMBUS_BLOCK_MAX;		}		res = i2c_smbus_xfer(client->adapter,client->addr,client->flags,		      data_arg.read_write,		      data_arg.command,data_arg.size,&temp);		if (! res && ((data_arg.size == I2C_SMBUS_PROC_CALL) ||		              (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) ||			      (data_arg.read_write == I2C_SMBUS_READ))) {			if (copy_to_user(data_arg.data, &temp, datasize))				return -EFAULT;		}		return res;	case I2C_RETRIES:		client->adapter->retries = arg;		break;	case I2C_TIMEOUT:		client->adapter->timeout = arg;		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 int i2cdev_open(struct inode *inode, struct file *file){	unsigned int minor = iminor(inode);	struct i2c_client *client;	struct i2c_adapter *adap;	struct i2c_dev *i2c_dev;	i2c_dev = i2c_dev_get_by_minor(minor);	if (!i2c_dev)		return -ENODEV;	adap = i2c_get_adapter(i2c_dev->adap->nr);	if (!adap)		return -ENODEV;	/* This creates an anonymous i2c_client, which may later be	 * pointed to some address using I2C_SLAVE or I2C_SLAVE_FORCE.	 *	 * This client is ** NEVER REGISTERED ** with the driver model	 * or I2C core code!!  It just holds private copies of addressing	 * information and maybe a PEC flag.	 */	client = kzalloc(sizeof(*client), GFP_KERNEL);	if (!client) {		i2c_put_adapter(adap);		return -ENOMEM;	}	snprintf(client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr);	client->driver = &i2cdev_driver;	client->adapter = adap;	file->private_data = client;	return 0;}static int i2cdev_release(struct inode *inode, struct file *file){	struct i2c_client *client = file->private_data;	i2c_put_adapter(client->adapter);	kfree(client);	file->private_data = NULL;	return 0;}static const struct file_operations i2cdev_fops = {	.owner		= THIS_MODULE,	.llseek		= no_llseek,	.read		= i2cdev_read,	.write		= i2cdev_write,	.ioctl		= i2cdev_ioctl,	.open		= i2cdev_open,	.release	= i2cdev_release,};/* ------------------------------------------------------------------------- *//* * The legacy "i2cdev_driver" is used primarily to get notifications when * I2C adapters are added or removed, so that each one gets an i2c_dev * and is thus made available to userspace driver code. */static struct class *i2c_dev_class;static int i2cdev_attach_adapter(struct i2c_adapter *adap){	struct i2c_dev *i2c_dev;	int res;	i2c_dev = get_free_i2c_dev(adap);	if (IS_ERR(i2c_dev))		return PTR_ERR(i2c_dev);	/* register this i2c device with the driver core */	i2c_dev->dev = device_create(i2c_dev_class, &adap->dev,				     MKDEV(I2C_MAJOR, adap->nr),				     "i2c-%d", adap->nr);	if (IS_ERR(i2c_dev->dev)) {		res = PTR_ERR(i2c_dev->dev);		goto error;	}	res = device_create_file(i2c_dev->dev, &dev_attr_name);	if (res)		goto error_destroy;	pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",		 adap->name, adap->nr);	return 0;error_destroy:	device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));error:	return_i2c_dev(i2c_dev);	return res;}static int i2cdev_detach_adapter(struct i2c_adapter *adap){	struct i2c_dev *i2c_dev;	i2c_dev = i2c_dev_get_by_minor(adap->nr);	if (!i2c_dev) /* attach_adapter must have failed */		return 0;	device_remove_file(i2c_dev->dev, &dev_attr_name);	return_i2c_dev(i2c_dev);	device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));	pr_debug("i2c-dev: adapter [%s] unregistered\n", adap->name);	return 0;}static int i2cdev_detach_client(struct i2c_client *client){	return 0;}static struct i2c_driver i2cdev_driver = {	.driver = {		.name	= "dev_driver",	},	.id		= I2C_DRIVERID_I2CDEV,	.attach_adapter	= i2cdev_attach_adapter,	.detach_adapter	= i2cdev_detach_adapter,	.detach_client	= i2cdev_detach_client,};/* ------------------------------------------------------------------------- *//* * 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))		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 void __exit i2c_dev_exit(void){	i2c_del_driver(&i2cdev_driver);	class_destroy(i2c_dev_class);	unregister_chrdev(I2C_MAJOR,"i2c");}MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "		"Simon G. Vogl <simon@tk.uni-linz.ac.at>");MODULE_DESCRIPTION("I2C /dev entries driver");MODULE_LICENSE("GPL");module_init(i2c_dev_init);module_exit(i2c_dev_exit);