[linux-2.6-block.git] / drivers / i2c / i2c-dev.c

/*
    i2c-dev.c - i2c-bus driver, char device interface

    Copyright (C) 1995-97 Simon G. Vogl
    Copyright (C) 1998-99 Frodo Looijaard <frodol@dds.nl>
    Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com>

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/

/* Note that this is a complete rewrite of Simon Vogl's i2c-dev module.
   But I have used so much of his original code and ideas that it seems
   only fair to recognize him as co-author -- Frodo */

/* The I2C_RDWR ioctl code is written by Kolja Waschk <waschk@telos.de> */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/slab.h>
#include <linux/init.h>
#include <linux/list.h>
#include <linux/i2c.h>
#include <linux/i2c-dev.h>
#include <linux/jiffies.h>
#include <asm/uaccess.h>

static struct i2c_driver i2cdev_driver;

/*
 * 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
 * with a character special file which is accessed by user mode drivers.
 *
 * The list of i2c_dev structures is parallel to the i2c_adapter lists
 * maintained by the driver model, and is updated using notifications
 * delivered to the i2cdev_driver.
 */
struct i2c_dev {
	struct list_head list;
	struct i2c_adapter *adap;
	struct device *dev;
};

#define I2C_MINORS	256
static LIST_HEAD(i2c_dev_list);
static DEFINE_SPINLOCK(i2c_dev_list_lock);

static struct i2c_dev *i2c_dev_get_by_minor(unsigned index)
{
	struct i2c_dev *i2c_dev;

	spin_lock(&i2c_dev_list_lock);
	list_for_each_entry(i2c_dev, &i2c_dev_list, list) {
		if (i2c_dev->adap->nr == index)
			goto found;
	}
	i2c_dev = NULL;
found:
	spin_unlock(&i2c_dev_list_lock);
	return i2c_dev;
}

static struct i2c_dev *get_free_i2c_dev(struct i2c_adapter *adap)
{
	struct i2c_dev *i2c_dev;

	if (adap->nr >= I2C_MINORS) {
		printk(KERN_ERR "i2c-dev: Out of device minors (%d)\n",
		       adap->nr);
		return ERR_PTR(-ENODEV);
	}

	i2c_dev = kzalloc(sizeof(*i2c_dev), GFP_KERNEL);
	if (!i2c_dev)
		return ERR_PTR(-ENOMEM);
	i2c_dev->adap = adap;

	spin_lock(&i2c_dev_list_lock);
	list_add_tail(&i2c_dev->list, &i2c_dev_list);
	spin_unlock(&i2c_dev_list_lock);
	return i2c_dev;
}

static void return_i2c_dev(struct i2c_dev *i2c_dev)
{
	spin_lock(&i2c_dev_list_lock);
	list_del(&i2c_dev->list);
	spin_unlock(&i2c_dev_list_lock);
	kfree(i2c_dev);
}

static ssize_t show_adapter_name(struct device *dev,
				 struct device_attribute *attr, char *buf)
{
	struct i2c_dev *i2c_dev = i2c_dev_get_by_minor(MINOR(dev->devt));

	if (!i2c_dev)
		return -ENODEV;
	return sprintf(buf, "%s\n", i2c_dev->adap->name);
}
static DEVICE_ATTR(name, S_IRUGO, show_adapter_name, NULL);

/* ------------------------------------------------------------------------- */

/*
 * 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 ssize_t i2cdev_read (struct file *file, char __user *buf, size_t count,
                            loff_t *offset)
{
	char *tmp;
	int ret;

	struct i2c_client *client = (struct i2c_client *)file->private_data;

	if (count > 8192)
		count = 8192;

	tmp = kmalloc(count,GFP_KERNEL);
	if (tmp==NULL)
		return -ENOMEM;

	pr_debug("i2c-dev: i2c-%d reading %zu bytes.\n",
		iminor(file->f_path.dentry->d_inode), count);

	ret = i2c_master_recv(client,tmp,count);
	if (ret >= 0)
		ret = copy_to_user(buf,tmp,count)?-EFAULT:ret;
	kfree(tmp);
	return ret;
}

static ssize_t i2cdev_write (struct file *file, const char __user *buf, size_t count,
                             loff_t *offset)
{
	int ret;
	char *tmp;
	struct i2c_client *client = (struct i2c_client *)file->private_data;

	if (count > 8192)
		count = 8192;

	tmp = kmalloc(count,GFP_KERNEL);
	if (tmp==NULL)
		return -ENOMEM;
	if (copy_from_user(tmp,buf,count)) {
		kfree(tmp);
		return -EFAULT;
	}

	pr_debug("i2c-dev: i2c-%d writing %zu bytes.\n",
		iminor(file->f_path.dentry->d_inode), count);

	ret = i2c_master_send(client,tmp,count);
	kfree(tmp);
	return ret;
}

static int i2cdev_check(struct device *dev, void *addrp)
{
	struct i2c_client *client = i2c_verify_client(dev);

	if (!client || client->addr != *(unsigned int *)addrp)
		return 0;

	return dev->driver ? -EBUSY : 0;
}

/* This address checking function differs from the one in i2c-core
   in that it considers an address with a registered device, but no
   driver bound to it, as NOT busy. */
static int i2cdev_check_addr(struct i2c_adapter *adapter, unsigned int addr)
{
	return device_for_each_child(&adapter->dev, &addr, i2cdev_check);
}

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

static noinline int i2cdev_ioctl_smbus(struct i2c_client *client,
		unsigned long arg)
{
	struct i2c_smbus_ioctl_data data_arg;
	union i2c_smbus_data temp;
	int datasize, res;

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

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

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,
	.unlocked_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), NULL,
				     "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 struct i2c_driver i2cdev_driver = {
	.driver = {
		.name	= "dev_driver",
	},
	.attach_adapter	= i2cdev_attach_adapter,
	.detach_adapter	= i2cdev_detach_adapter,
};

/* ------------------------------------------------------------------------- */

/*
 * 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 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);
Commit	Line	Data
1da177e4	1	/*
438d6c2c	2	i2c-dev.c - i2c-bus driver, char device interface
1da177e4 LT	3
	4	Copyright (C) 1995-97 Simon G. Vogl
	5	Copyright (C) 1998-99 Frodo Looijaard <frodol@dds.nl>
	6	Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com>
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
	21	*/
	22
	23	/* Note that this is a complete rewrite of Simon Vogl's i2c-dev module.
	24	But I have used so much of his original code and ideas that it seems
	25	only fair to recognize him as co-author -- Frodo */
	26
	27	/* The I2C_RDWR ioctl code is written by Kolja Waschk <waschk@telos.de> */
	28
1da177e4 LT	29	#include <linux/kernel.h>
	30	#include <linux/module.h>
	31	#include <linux/fs.h>
	32	#include <linux/slab.h>
1da177e4	33	#include <linux/init.h>
f3b3aadb	34	#include <linux/list.h>
1da177e4 LT	35	#include <linux/i2c.h>
1da177e4 LT	36	#include <linux/i2c-dev.h>
cd97f39b	37	#include <linux/jiffies.h>
1da177e4 LT	38	#include <asm/uaccess.h>
1da177e4 LT	39
22f76e74	40	static struct i2c_driver i2cdev_driver;
1da177e4	41
907135aa DB	42	/*
	43	* An i2c_dev represents an i2c_adapter ... an I2C or SMBus master, not a
	44	* slave (i2c_client) with which messages will be exchanged. It's coupled
	45	* with a character special file which is accessed by user mode drivers.
	46	*
	47	* The list of i2c_dev structures is parallel to the i2c_adapter lists
	48	* maintained by the driver model, and is updated using notifications
	49	* delivered to the i2cdev_driver.
	50	*/
1da177e4	51	struct i2c_dev {
f3b3aadb	52	struct list_head list;
1da177e4	53	struct i2c_adapter *adap;
ac11d060	54	struct device *dev;
1da177e4	55	};
1da177e4 LT	56
1da177e4 LT	57	#define I2C_MINORS 256
f3b3aadb JD	58	static LIST_HEAD(i2c_dev_list);
f3b3aadb JD	59	static DEFINE_SPINLOCK(i2c_dev_list_lock);
1da177e4 LT	60
	61	static struct i2c_dev *i2c_dev_get_by_minor(unsigned index)
	62	{
	63	struct i2c_dev *i2c_dev;
	64
f3b3aadb JD	65	spin_lock(&i2c_dev_list_lock);
	66	list_for_each_entry(i2c_dev, &i2c_dev_list, list) {
	67	if (i2c_dev->adap->nr == index)
	68	goto found;
	69	}
	70	i2c_dev = NULL;
	71	found:
	72	spin_unlock(&i2c_dev_list_lock);
1da177e4 LT	73	return i2c_dev;
	74	}
	75
1da177e4 LT	76	static struct i2c_dev get_free_i2c_dev(struct i2c_adapter adap)
	77	{
	78	struct i2c_dev *i2c_dev;
	79
f3b3aadb JD	80	if (adap->nr >= I2C_MINORS) {
	81	printk(KERN_ERR "i2c-dev: Out of device minors (%d)\n",
	82	adap->nr);
	83	return ERR_PTR(-ENODEV);
	84	}
	85
5263ebb5	86	i2c_dev = kzalloc(sizeof(*i2c_dev), GFP_KERNEL);
1da177e4 LT	87	if (!i2c_dev)
1da177e4 LT	88	return ERR_PTR(-ENOMEM);
9455e4c9	89	i2c_dev->adap = adap;
f3b3aadb JD	90
	91	spin_lock(&i2c_dev_list_lock);
	92	list_add_tail(&i2c_dev->list, &i2c_dev_list);
	93	spin_unlock(&i2c_dev_list_lock);
1da177e4	94	return i2c_dev;
1da177e4 LT	95	}
	96
	97	static void return_i2c_dev(struct i2c_dev *i2c_dev)
	98	{
f3b3aadb JD	99	spin_lock(&i2c_dev_list_lock);
	100	list_del(&i2c_dev->list);
	101	spin_unlock(&i2c_dev_list_lock);
07125ab2	102	kfree(i2c_dev);
1da177e4 LT	103	}
1da177e4 LT	104
ac11d060 GKH	105	static ssize_t show_adapter_name(struct device *dev,
ac11d060 GKH	106	struct device_attribute attr, char buf)
1da177e4	107	{
ac11d060	108	struct i2c_dev *i2c_dev = i2c_dev_get_by_minor(MINOR(dev->devt));
79472132 GKH	109
	110	if (!i2c_dev)
	111	return -ENODEV;
1da177e4 LT	112	return sprintf(buf, "%s\n", i2c_dev->adap->name);
1da177e4 LT	113	}
ac11d060	114	static DEVICE_ATTR(name, S_IRUGO, show_adapter_name, NULL);
1da177e4	115
907135aa DB	116	/* ------------------------------------------------------------------------- */
	117
	118	/*
	119	* After opening an instance of this character special file, a file
	120	* descriptor starts out associated only with an i2c_adapter (and bus).
	121	*
	122	* Using the I2C_RDWR ioctl(), you can then immediately issue i2c_msg
	123	* traffic to any devices on the bus used by that adapter. That's because
	124	* the i2c_msg vectors embed all the addressing information they need, and
	125	* are submitted directly to an i2c_adapter. However, SMBus-only adapters
	126	* don't support that interface.
	127	*
	128	* To use read()/write() system calls on that file descriptor, or to use
	129	* SMBus interfaces (and work with SMBus-only hosts!), you must first issue
	130	* an I2C_SLAVE (or I2C_SLAVE_FORCE) ioctl. That configures an anonymous
	131	* (never registered) i2c_client so it holds the addressing information
	132	* needed by those system calls and by this SMBus interface.
	133	*/
	134
1da177e4 LT	135	static ssize_t i2cdev_read (struct file file, char __user buf, size_t count,
	136	loff_t *offset)
	137	{
	138	char *tmp;
	139	int ret;
	140
	141	struct i2c_client client = (struct i2c_client )file->private_data;
	142
	143	if (count > 8192)
	144	count = 8192;
	145
	146	tmp = kmalloc(count,GFP_KERNEL);
	147	if (tmp==NULL)
	148	return -ENOMEM;
	149
2ce5b34f	150	pr_debug("i2c-dev: i2c-%d reading %zu bytes.\n",
cba0a128	151	iminor(file->f_path.dentry->d_inode), count);
1da177e4 LT	152
	153	ret = i2c_master_recv(client,tmp,count);
	154	if (ret >= 0)
	155	ret = copy_to_user(buf,tmp,count)?-EFAULT:ret;
	156	kfree(tmp);
	157	return ret;
	158	}
	159
	160	static ssize_t i2cdev_write (struct file file, const char __user buf, size_t count,
	161	loff_t *offset)
	162	{
	163	int ret;
	164	char *tmp;
	165	struct i2c_client client = (struct i2c_client )file->private_data;
	166
	167	if (count > 8192)
	168	count = 8192;
	169
	170	tmp = kmalloc(count,GFP_KERNEL);
	171	if (tmp==NULL)
	172	return -ENOMEM;
	173	if (copy_from_user(tmp,buf,count)) {
	174	kfree(tmp);
	175	return -EFAULT;
	176	}
	177
2ce5b34f	178	pr_debug("i2c-dev: i2c-%d writing %zu bytes.\n",
cba0a128	179	iminor(file->f_path.dentry->d_inode), count);
1da177e4 LT	180
	181	ret = i2c_master_send(client,tmp,count);
	182	kfree(tmp);
	183	return ret;
	184	}
	185
9b766b81 DB	186	static int i2cdev_check(struct device dev, void addrp)
	187	{
	188	struct i2c_client *client = i2c_verify_client(dev);
	189
	190	if (!client \|\| client->addr != (unsigned int )addrp)
	191	return 0;
	192
	193	return dev->driver ? -EBUSY : 0;
	194	}
	195
bd4217d8 JD	196	/* This address checking function differs from the one in i2c-core
bd4217d8 JD	197	in that it considers an address with a registered device, but no
9b766b81	198	driver bound to it, as NOT busy. */
bd4217d8 JD	199	static int i2cdev_check_addr(struct i2c_adapter *adapter, unsigned int addr)
bd4217d8 JD	200	{
9b766b81	201	return device_for_each_child(&adapter->dev, &addr, i2cdev_check);
bd4217d8 JD	202	}
bd4217d8 JD	203
dba7997a JD	204	static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client,
dba7997a JD	205	unsigned long arg)
1da177e4	206	{
1da177e4	207	struct i2c_rdwr_ioctl_data rdwr_arg;
1da177e4 LT	208	struct i2c_msg *rdwr_pa;
1da177e4 LT	209	u8 __user **data_ptrs;
dba7997a JD	210	int i, res;
	211
	212	if (copy_from_user(&rdwr_arg,
	213	(struct i2c_rdwr_ioctl_data __user *)arg,
	214	sizeof(rdwr_arg)))
	215	return -EFAULT;
	216
	217	/* Put an arbitrary limit on the number of messages that can
	218	* be sent at once */
	219	if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
	220	return -EINVAL;
	221
	222	rdwr_pa = (struct i2c_msg *)
	223	kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg),
	224	GFP_KERNEL);
	225	if (!rdwr_pa)
	226	return -ENOMEM;
	227
	228	if (copy_from_user(rdwr_pa, rdwr_arg.msgs,
	229	rdwr_arg.nmsgs * sizeof(struct i2c_msg))) {
	230	kfree(rdwr_pa);
	231	return -EFAULT;
	232	}
	233
	234	data_ptrs = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL);
	235	if (data_ptrs == NULL) {
	236	kfree(rdwr_pa);
	237	return -ENOMEM;
	238	}
	239
	240	res = 0;
	241	for (i = 0; i < rdwr_arg.nmsgs; i++) {
	242	/* Limit the size of the message to a sane amount;
	243	* and don't let length change either. */
	244	if ((rdwr_pa[i].len > 8192) \|\|
	245	(rdwr_pa[i].flags & I2C_M_RECV_LEN)) {
	246	res = -EINVAL;
	247	break;
	248	}
	249	data_ptrs[i] = (u8 __user *)rdwr_pa[i].buf;
	250	rdwr_pa[i].buf = kmalloc(rdwr_pa[i].len, GFP_KERNEL);
	251	if (rdwr_pa[i].buf == NULL) {
	252	res = -ENOMEM;
	253	break;
	254	}
	255	if (copy_from_user(rdwr_pa[i].buf, data_ptrs[i],
	256	rdwr_pa[i].len)) {
	257	++i; /* Needs to be kfreed too */
	258	res = -EFAULT;
	259	break;
	260	}
	261	}
	262	if (res < 0) {
	263	int j;
	264	for (j = 0; j < i; ++j)
	265	kfree(rdwr_pa[j].buf);
	266	kfree(data_ptrs);
	267	kfree(rdwr_pa);
	268	return res;
	269	}
	270
	271	res = i2c_transfer(client->adapter, rdwr_pa, rdwr_arg.nmsgs);
	272	while (i-- > 0) {
	273	if (res >= 0 && (rdwr_pa[i].flags & I2C_M_RD)) {
274	if (copy_to_user(data_ptrs[i], rdwr_pa[i].buf,
275	rdwr_pa[i].len))
276	res = -EFAULT;
277	}
278	kfree(rdwr_pa[i].buf);
279	}
280	kfree(data_ptrs);
281	kfree(rdwr_pa);
282	return res;
283	}
284
285	static noinline int i2cdev_ioctl_smbus(struct i2c_client *client,
286	unsigned long arg)
287	{
288	struct i2c_smbus_ioctl_data data_arg;
289	union i2c_smbus_data temp;
290	int datasize, res;
291
292	if (copy_from_user(&data_arg,
293	(struct i2c_smbus_ioctl_data __user *) arg,
294	sizeof(struct i2c_smbus_ioctl_data)))
295	return -EFAULT;
296	if ((data_arg.size != I2C_SMBUS_BYTE) &&
297	(data_arg.size != I2C_SMBUS_QUICK) &&
298	(data_arg.size != I2C_SMBUS_BYTE_DATA) &&
299	(data_arg.size != I2C_SMBUS_WORD_DATA) &&
300	(data_arg.size != I2C_SMBUS_PROC_CALL) &&
301	(data_arg.size != I2C_SMBUS_BLOCK_DATA) &&
302	(data_arg.size != I2C_SMBUS_I2C_BLOCK_BROKEN) &&
303	(data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA) &&
304	(data_arg.size != I2C_SMBUS_BLOCK_PROC_CALL)) {
305	dev_dbg(&client->adapter->dev,
306	"size out of range (%x) in ioctl I2C_SMBUS.\n",
307	data_arg.size);
308	return -EINVAL;
309	}
310	/* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
311	so the check is valid if size==I2C_SMBUS_QUICK too. */
312	if ((data_arg.read_write != I2C_SMBUS_READ) &&
313	(data_arg.read_write != I2C_SMBUS_WRITE)) {
314	dev_dbg(&client->adapter->dev,
315	"read_write out of range (%x) in ioctl I2C_SMBUS.\n",
316	data_arg.read_write);
317	return -EINVAL;
318	}
319
320	/* Note that command values are always valid! */
321
322	if ((data_arg.size == I2C_SMBUS_QUICK) \|\|
323	((data_arg.size == I2C_SMBUS_BYTE) &&
324	(data_arg.read_write == I2C_SMBUS_WRITE)))
325	/* These are special: we do not use data */
326	return i2c_smbus_xfer(client->adapter, client->addr,
327	client->flags, data_arg.read_write,
328	data_arg.command, data_arg.size, NULL);
329
330	if (data_arg.data == NULL) {
331	dev_dbg(&client->adapter->dev,
332	"data is NULL pointer in ioctl I2C_SMBUS.\n");
333	return -EINVAL;
334	}
335
336	if ((data_arg.size == I2C_SMBUS_BYTE_DATA) \|\|
337	(data_arg.size == I2C_SMBUS_BYTE))
338	datasize = sizeof(data_arg.data->byte);
339	else if ((data_arg.size == I2C_SMBUS_WORD_DATA) \|\|
340	(data_arg.size == I2C_SMBUS_PROC_CALL))
341	datasize = sizeof(data_arg.data->word);
342	else /* size == smbus block, i2c block, or block proc. call */
343	datasize = sizeof(data_arg.data->block);
344
345	if ((data_arg.size == I2C_SMBUS_PROC_CALL) \|\|
346	(data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) \|\|
347	(data_arg.size == I2C_SMBUS_I2C_BLOCK_DATA) \|\|
348	(data_arg.read_write == I2C_SMBUS_WRITE)) {
349	if (copy_from_user(&temp, data_arg.data, datasize))
350	return -EFAULT;
351	}
352	if (data_arg.size == I2C_SMBUS_I2C_BLOCK_BROKEN) {
353	/* Convert old I2C block commands to the new
354	convention. This preserves binary compatibility. */
355	data_arg.size = I2C_SMBUS_I2C_BLOCK_DATA;
356	if (data_arg.read_write == I2C_SMBUS_READ)
357	temp.block[0] = I2C_SMBUS_BLOCK_MAX;
358	}
359	res = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
360	data_arg.read_write, data_arg.command, data_arg.size, &temp);
361	if (!res && ((data_arg.size == I2C_SMBUS_PROC_CALL) \|\|
362	(data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) \|\|
363	(data_arg.read_write == I2C_SMBUS_READ))) {
364	if (copy_to_user(data_arg.data, &temp, datasize))
365	return -EFAULT;
366	}
367	return res;
368	}
369
77e38bff	370	static long i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
dba7997a JD	371	{
dba7997a JD	372	struct i2c_client client = (struct i2c_client )file->private_data;
1da177e4 LT	373	unsigned long funcs;
1da177e4 LT	374
e8aafcb2 JD	375	dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
e8aafcb2 JD	376	cmd, arg);
1da177e4 LT	377
	378	switch ( cmd ) {
	379	case I2C_SLAVE:
	380	case I2C_SLAVE_FORCE:
907135aa DB	381	/* NOTE: devices set up to work with "new style" drivers
	382	* can't use I2C_SLAVE, even when the device node is not
	383	* bound to a driver. Only I2C_SLAVE_FORCE will work.
	384	*
	385	* Setting the PEC flag here won't affect kernel drivers,
	386	* which will be using the i2c_client node registered with
	387	* the driver model core. Likewise, when that client has
	388	* the PEC flag already set, the i2c-dev driver won't see
	389	* (or use) this setting.
	390	*/
438d6c2c	391	if ((arg > 0x3ff) \|\|
1da177e4 LT	392	(((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
1da177e4 LT	393	return -EINVAL;
bd4217d8	394	if (cmd == I2C_SLAVE && i2cdev_check_addr(client->adapter, arg))
1da177e4	395	return -EBUSY;
bd4217d8	396	/* REVISIT: address could become busy later */
1da177e4 LT	397	client->addr = arg;
	398	return 0;
	399	case I2C_TENBIT:
	400	if (arg)
	401	client->flags \|= I2C_M_TEN;
	402	else
	403	client->flags &= ~I2C_M_TEN;
	404	return 0;
	405	case I2C_PEC:
	406	if (arg)
	407	client->flags \|= I2C_CLIENT_PEC;
	408	else
	409	client->flags &= ~I2C_CLIENT_PEC;
	410	return 0;
	411	case I2C_FUNCS:
	412	funcs = i2c_get_functionality(client->adapter);
2c003e8e	413	return put_user(funcs, (unsigned long __user *)arg);
1da177e4 LT	414
1da177e4 LT	415	case I2C_RDWR:
dba7997a	416	return i2cdev_ioctl_rdrw(client, arg);
1da177e4 LT	417
1da177e4 LT	418	case I2C_SMBUS:
dba7997a	419	return i2cdev_ioctl_smbus(client, arg);
1da177e4	420
53be7959 DB	421	case I2C_RETRIES:
	422	client->adapter->retries = arg;
	423	break;
	424	case I2C_TIMEOUT:
cd97f39b JD	425	/* For historical reasons, user-space sets the timeout
	426	* value in units of 10 ms.
	427	*/
	428	client->adapter->timeout = msecs_to_jiffies(arg * 10);
53be7959	429	break;
1da177e4	430	default:
53be7959 DB	431	/* NOTE: returning a fault code here could cause trouble
	432	* in buggy userspace code. Some old kernel bugs returned
	433	* zero in this case, and userspace code might accidentally
	434	* have depended on that bug.
	435	*/
	436	return -ENOTTY;
1da177e4 LT	437	}
	438	return 0;
	439	}
	440
	441	static int i2cdev_open(struct inode inode, struct file file)
	442	{
	443	unsigned int minor = iminor(inode);
	444	struct i2c_client *client;
	445	struct i2c_adapter *adap;
	446	struct i2c_dev *i2c_dev;
	447
	448	i2c_dev = i2c_dev_get_by_minor(minor);
9669f541 VS	449	if (!i2c_dev)
9669f541 VS	450	return -ENODEV;
1da177e4 LT	451
1da177e4 LT	452	adap = i2c_get_adapter(i2c_dev->adap->nr);
9669f541 VS	453	if (!adap)
9669f541 VS	454	return -ENODEV;
1da177e4	455
907135aa DB	456	/* This creates an anonymous i2c_client, which may later be
	457	* pointed to some address using I2C_SLAVE or I2C_SLAVE_FORCE.
	458	*
	459	* This client is NEVER REGISTERED with the driver model
	460	* or I2C core code!! It just holds private copies of addressing
	461	* information and maybe a PEC flag.
	462	*/
22f76e74	463	client = kzalloc(sizeof(*client), GFP_KERNEL);
1da177e4 LT	464	if (!client) {
1da177e4 LT	465	i2c_put_adapter(adap);
9669f541	466	return -ENOMEM;
1da177e4	467	}
22f76e74 JD	468	snprintf(client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr);
22f76e74 JD	469	client->driver = &i2cdev_driver;
1da177e4	470
1da177e4 LT	471	client->adapter = adap;
	472	file->private_data = client;
	473
9669f541	474	return 0;
1da177e4 LT	475	}
	476
	477	static int i2cdev_release(struct inode inode, struct file file)
	478	{
	479	struct i2c_client *client = file->private_data;
	480
	481	i2c_put_adapter(client->adapter);
	482	kfree(client);
	483	file->private_data = NULL;
	484
	485	return 0;
	486	}
	487
2b8693c0	488	static const struct file_operations i2cdev_fops = {
1da177e4 LT	489	.owner = THIS_MODULE,
	490	.llseek = no_llseek,
	491	.read = i2cdev_read,
	492	.write = i2cdev_write,
77e38bff	493	.unlocked_ioctl = i2cdev_ioctl,
1da177e4 LT	494	.open = i2cdev_open,
	495	.release = i2cdev_release,
	496	};
	497
907135aa DB	498	/* ------------------------------------------------------------------------- */
	499
	500	/*
	501	* The legacy "i2cdev_driver" is used primarily to get notifications when
	502	* I2C adapters are added or removed, so that each one gets an i2c_dev
	503	* and is thus made available to userspace driver code.
	504	*/
	505
79472132	506	static struct class *i2c_dev_class;
1da177e4 LT	507
	508	static int i2cdev_attach_adapter(struct i2c_adapter *adap)
	509	{
	510	struct i2c_dev *i2c_dev;
defcb46e	511	int res;
1da177e4 LT	512
	513	i2c_dev = get_free_i2c_dev(adap);
	514	if (IS_ERR(i2c_dev))
	515	return PTR_ERR(i2c_dev);
	516
1da177e4	517	/* register this i2c device with the driver core */
a9b12619 GKH	518	i2c_dev->dev = device_create(i2c_dev_class, &adap->dev,
	519	MKDEV(I2C_MAJOR, adap->nr), NULL,
	520	"i2c-%d", adap->nr);
3bacb36d AM	521	if (IS_ERR(i2c_dev->dev)) {
3bacb36d AM	522	res = PTR_ERR(i2c_dev->dev);
1da177e4	523	goto error;
defcb46e	524	}
ac11d060	525	res = device_create_file(i2c_dev->dev, &dev_attr_name);
defcb46e JD	526	if (res)
defcb46e JD	527	goto error_destroy;
b32d20dc JD	528
	529	pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",
	530	adap->name, adap->nr);
1da177e4	531	return 0;
defcb46e	532	error_destroy:
ac11d060	533	device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));
1da177e4 LT	534	error:
1da177e4 LT	535	return_i2c_dev(i2c_dev);
defcb46e	536	return res;
1da177e4 LT	537	}
	538
	539	static int i2cdev_detach_adapter(struct i2c_adapter *adap)
	540	{
	541	struct i2c_dev *i2c_dev;
	542
9455e4c9	543	i2c_dev = i2c_dev_get_by_minor(adap->nr);
b32d20dc JD	544	if (!i2c_dev) /* attach_adapter must have failed */
b32d20dc JD	545	return 0;
1da177e4	546
ac11d060	547	device_remove_file(i2c_dev->dev, &dev_attr_name);
1da177e4	548	return_i2c_dev(i2c_dev);
ac11d060	549	device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));
1da177e4	550
b6d7b3d1	551	pr_debug("i2c-dev: adapter [%s] unregistered\n", adap->name);
1da177e4 LT	552	return 0;
	553	}
	554
1da177e4	555	static struct i2c_driver i2cdev_driver = {
35d8b2e6	556	.driver = {
35d8b2e6 LR	557	.name = "dev_driver",
35d8b2e6 LR	558	},
1da177e4 LT	559	.attach_adapter = i2cdev_attach_adapter,
1da177e4 LT	560	.detach_adapter = i2cdev_detach_adapter,
1da177e4 LT	561	};
1da177e4 LT	562
907135aa DB	563	/* ------------------------------------------------------------------------- */
	564
	565	/*
	566	* module load/unload record keeping
	567	*/
	568
1da177e4 LT	569	static int __init i2c_dev_init(void)
	570	{
	571	int res;
	572
	573	printk(KERN_INFO "i2c /dev entries driver\n");
	574
	575	res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);
	576	if (res)
	577	goto out;
	578
79472132	579	i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");
e74783ec SW	580	if (IS_ERR(i2c_dev_class)) {
e74783ec SW	581	res = PTR_ERR(i2c_dev_class);
1da177e4	582	goto out_unreg_chrdev;
e74783ec	583	}
1da177e4 LT	584
	585	res = i2c_add_driver(&i2cdev_driver);
	586	if (res)
	587	goto out_unreg_class;
	588
1da177e4 LT	589	return 0;
	590
	591	out_unreg_class:
79472132	592	class_destroy(i2c_dev_class);
1da177e4 LT	593	out_unreg_chrdev:
	594	unregister_chrdev(I2C_MAJOR, "i2c");
	595	out:
	596	printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
	597	return res;
	598	}
	599
	600	static void __exit i2c_dev_exit(void)
	601	{
	602	i2c_del_driver(&i2cdev_driver);
79472132	603	class_destroy(i2c_dev_class);
1da177e4 LT	604	unregister_chrdev(I2C_MAJOR,"i2c");
	605	}
	606
	607	MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
	608	"Simon G. Vogl <simon@tk.uni-linz.ac.at>");
	609	MODULE_DESCRIPTION("I2C /dev entries driver");
	610	MODULE_LICENSE("GPL");
	611
	612	module_init(i2c_dev_init);
	613	module_exit(i2c_dev_exit);