Linux Audio

Check our new training course

Loading...
v4.17
 
  1/*
  2    i2c-dev.c - i2c-bus driver, char device interface
  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
 19/* Note that this is a complete rewrite of Simon Vogl's i2c-dev module.
 20   But I have used so much of his original code and ideas that it seems
 21   only fair to recognize him as co-author -- Frodo */
 22
 23/* The I2C_RDWR ioctl code is written by Kolja Waschk <waschk@telos.de> */
 24
 25#include <linux/cdev.h>
 
 26#include <linux/device.h>
 27#include <linux/fs.h>
 28#include <linux/i2c-dev.h>
 29#include <linux/i2c.h>
 30#include <linux/init.h>
 31#include <linux/jiffies.h>
 32#include <linux/kernel.h>
 33#include <linux/list.h>
 34#include <linux/module.h>
 35#include <linux/notifier.h>
 36#include <linux/slab.h>
 37#include <linux/uaccess.h>
 38#include <linux/compat.h>
 39
 40/*
 41 * An i2c_dev represents an i2c_adapter ... an I2C or SMBus master, not a
 42 * slave (i2c_client) with which messages will be exchanged.  It's coupled
 43 * with a character special file which is accessed by user mode drivers.
 44 *
 45 * The list of i2c_dev structures is parallel to the i2c_adapter lists
 46 * maintained by the driver model, and is updated using bus notifications.
 47 */
 48struct i2c_dev {
 49	struct list_head list;
 50	struct i2c_adapter *adap;
 51	struct device *dev;
 52	struct cdev cdev;
 53};
 54
 55#define I2C_MINORS	MINORMASK
 56static LIST_HEAD(i2c_dev_list);
 57static DEFINE_SPINLOCK(i2c_dev_list_lock);
 58
 59static struct i2c_dev *i2c_dev_get_by_minor(unsigned index)
 60{
 61	struct i2c_dev *i2c_dev;
 62
 63	spin_lock(&i2c_dev_list_lock);
 64	list_for_each_entry(i2c_dev, &i2c_dev_list, list) {
 65		if (i2c_dev->adap->nr == index)
 66			goto found;
 67	}
 68	i2c_dev = NULL;
 69found:
 70	spin_unlock(&i2c_dev_list_lock);
 71	return i2c_dev;
 72}
 73
 74static struct i2c_dev *get_free_i2c_dev(struct i2c_adapter *adap)
 75{
 76	struct i2c_dev *i2c_dev;
 77
 78	if (adap->nr >= I2C_MINORS) {
 79		printk(KERN_ERR "i2c-dev: Out of device minors (%d)\n",
 80		       adap->nr);
 81		return ERR_PTR(-ENODEV);
 82	}
 83
 84	i2c_dev = kzalloc(sizeof(*i2c_dev), GFP_KERNEL);
 85	if (!i2c_dev)
 86		return ERR_PTR(-ENOMEM);
 87	i2c_dev->adap = adap;
 88
 89	spin_lock(&i2c_dev_list_lock);
 90	list_add_tail(&i2c_dev->list, &i2c_dev_list);
 91	spin_unlock(&i2c_dev_list_lock);
 92	return i2c_dev;
 93}
 94
 95static void put_i2c_dev(struct i2c_dev *i2c_dev)
 96{
 97	spin_lock(&i2c_dev_list_lock);
 98	list_del(&i2c_dev->list);
 99	spin_unlock(&i2c_dev_list_lock);
100	kfree(i2c_dev);
 
 
101}
102
103static ssize_t name_show(struct device *dev,
104			 struct device_attribute *attr, char *buf)
105{
106	struct i2c_dev *i2c_dev = i2c_dev_get_by_minor(MINOR(dev->devt));
107
108	if (!i2c_dev)
109		return -ENODEV;
110	return sprintf(buf, "%s\n", i2c_dev->adap->name);
111}
112static DEVICE_ATTR_RO(name);
113
114static struct attribute *i2c_attrs[] = {
115	&dev_attr_name.attr,
116	NULL,
117};
118ATTRIBUTE_GROUPS(i2c);
119
120/* ------------------------------------------------------------------------- */
121
122/*
123 * After opening an instance of this character special file, a file
124 * descriptor starts out associated only with an i2c_adapter (and bus).
125 *
126 * Using the I2C_RDWR ioctl(), you can then *immediately* issue i2c_msg
127 * traffic to any devices on the bus used by that adapter.  That's because
128 * the i2c_msg vectors embed all the addressing information they need, and
129 * are submitted directly to an i2c_adapter.  However, SMBus-only adapters
130 * don't support that interface.
131 *
132 * To use read()/write() system calls on that file descriptor, or to use
133 * SMBus interfaces (and work with SMBus-only hosts!), you must first issue
134 * an I2C_SLAVE (or I2C_SLAVE_FORCE) ioctl.  That configures an anonymous
135 * (never registered) i2c_client so it holds the addressing information
136 * needed by those system calls and by this SMBus interface.
137 */
138
139static ssize_t i2cdev_read(struct file *file, char __user *buf, size_t count,
140		loff_t *offset)
141{
142	char *tmp;
143	int ret;
144
145	struct i2c_client *client = file->private_data;
146
147	if (count > 8192)
148		count = 8192;
149
150	tmp = kmalloc(count, GFP_KERNEL);
151	if (tmp == NULL)
152		return -ENOMEM;
153
154	pr_debug("i2c-dev: i2c-%d reading %zu bytes.\n",
155		iminor(file_inode(file)), count);
156
157	ret = i2c_master_recv(client, tmp, count);
158	if (ret >= 0)
159		ret = copy_to_user(buf, tmp, count) ? -EFAULT : ret;
 
160	kfree(tmp);
161	return ret;
162}
163
164static ssize_t i2cdev_write(struct file *file, const char __user *buf,
165		size_t count, loff_t *offset)
166{
167	int ret;
168	char *tmp;
169	struct i2c_client *client = file->private_data;
170
171	if (count > 8192)
172		count = 8192;
173
174	tmp = memdup_user(buf, count);
175	if (IS_ERR(tmp))
176		return PTR_ERR(tmp);
177
178	pr_debug("i2c-dev: i2c-%d writing %zu bytes.\n",
179		iminor(file_inode(file)), count);
180
181	ret = i2c_master_send(client, tmp, count);
182	kfree(tmp);
183	return ret;
184}
185
186static 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
196/* walk up mux tree */
197static int i2cdev_check_mux_parents(struct i2c_adapter *adapter, int addr)
198{
199	struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
200	int result;
201
202	result = device_for_each_child(&adapter->dev, &addr, i2cdev_check);
203	if (!result && parent)
204		result = i2cdev_check_mux_parents(parent, addr);
205
206	return result;
207}
208
209/* recurse down mux tree */
210static int i2cdev_check_mux_children(struct device *dev, void *addrp)
211{
212	int result;
213
214	if (dev->type == &i2c_adapter_type)
215		result = device_for_each_child(dev, addrp,
216						i2cdev_check_mux_children);
217	else
218		result = i2cdev_check(dev, addrp);
219
220	return result;
221}
222
223/* This address checking function differs from the one in i2c-core
224   in that it considers an address with a registered device, but no
225   driver bound to it, as NOT busy. */
226static int i2cdev_check_addr(struct i2c_adapter *adapter, unsigned int addr)
227{
228	struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
229	int result = 0;
230
231	if (parent)
232		result = i2cdev_check_mux_parents(parent, addr);
233
234	if (!result)
235		result = device_for_each_child(&adapter->dev, &addr,
236						i2cdev_check_mux_children);
237
238	return result;
239}
240
241static noinline int i2cdev_ioctl_rdwr(struct i2c_client *client,
242		unsigned nmsgs, struct i2c_msg *msgs)
243{
244	u8 __user **data_ptrs;
245	int i, res;
246
247	data_ptrs = kmalloc(nmsgs * sizeof(u8 __user *), GFP_KERNEL);
248	if (data_ptrs == NULL) {
249		kfree(msgs);
250		return -ENOMEM;
251	}
252
253	res = 0;
254	for (i = 0; i < nmsgs; i++) {
255		/* Limit the size of the message to a sane amount */
256		if (msgs[i].len > 8192) {
257			res = -EINVAL;
258			break;
259		}
260
261		data_ptrs[i] = (u8 __user *)msgs[i].buf;
262		msgs[i].buf = memdup_user(data_ptrs[i], msgs[i].len);
263		if (IS_ERR(msgs[i].buf)) {
264			res = PTR_ERR(msgs[i].buf);
265			break;
266		}
267		/* memdup_user allocates with GFP_KERNEL, so DMA is ok */
268		msgs[i].flags |= I2C_M_DMA_SAFE;
269
270		/*
271		 * If the message length is received from the slave (similar
272		 * to SMBus block read), we must ensure that the buffer will
273		 * be large enough to cope with a message length of
274		 * I2C_SMBUS_BLOCK_MAX as this is the maximum underlying bus
275		 * drivers allow. The first byte in the buffer must be
276		 * pre-filled with the number of extra bytes, which must be
277		 * at least one to hold the message length, but can be
278		 * greater (for example to account for a checksum byte at
279		 * the end of the message.)
280		 */
281		if (msgs[i].flags & I2C_M_RECV_LEN) {
282			if (!(msgs[i].flags & I2C_M_RD) ||
283			    msgs[i].len < 1 || msgs[i].buf[0] < 1 ||
284			    msgs[i].len < msgs[i].buf[0] +
285					     I2C_SMBUS_BLOCK_MAX) {
 
286				res = -EINVAL;
287				break;
288			}
289
290			msgs[i].len = msgs[i].buf[0];
291		}
292	}
293	if (res < 0) {
294		int j;
295		for (j = 0; j < i; ++j)
296			kfree(msgs[j].buf);
297		kfree(data_ptrs);
298		kfree(msgs);
299		return res;
300	}
301
302	res = i2c_transfer(client->adapter, msgs, nmsgs);
303	while (i-- > 0) {
304		if (res >= 0 && (msgs[i].flags & I2C_M_RD)) {
305			if (copy_to_user(data_ptrs[i], msgs[i].buf,
306					 msgs[i].len))
307				res = -EFAULT;
308		}
309		kfree(msgs[i].buf);
310	}
311	kfree(data_ptrs);
312	kfree(msgs);
313	return res;
314}
315
316static noinline int i2cdev_ioctl_smbus(struct i2c_client *client,
317		u8 read_write, u8 command, u32 size,
318		union i2c_smbus_data __user *data)
319{
320	union i2c_smbus_data temp = {};
321	int datasize, res;
322
323	if ((size != I2C_SMBUS_BYTE) &&
324	    (size != I2C_SMBUS_QUICK) &&
325	    (size != I2C_SMBUS_BYTE_DATA) &&
326	    (size != I2C_SMBUS_WORD_DATA) &&
327	    (size != I2C_SMBUS_PROC_CALL) &&
328	    (size != I2C_SMBUS_BLOCK_DATA) &&
329	    (size != I2C_SMBUS_I2C_BLOCK_BROKEN) &&
330	    (size != I2C_SMBUS_I2C_BLOCK_DATA) &&
331	    (size != I2C_SMBUS_BLOCK_PROC_CALL)) {
332		dev_dbg(&client->adapter->dev,
333			"size out of range (%x) in ioctl I2C_SMBUS.\n",
334			size);
335		return -EINVAL;
336	}
337	/* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
338	   so the check is valid if size==I2C_SMBUS_QUICK too. */
339	if ((read_write != I2C_SMBUS_READ) &&
340	    (read_write != I2C_SMBUS_WRITE)) {
341		dev_dbg(&client->adapter->dev,
342			"read_write out of range (%x) in ioctl I2C_SMBUS.\n",
343			read_write);
344		return -EINVAL;
345	}
346
347	/* Note that command values are always valid! */
348
349	if ((size == I2C_SMBUS_QUICK) ||
350	    ((size == I2C_SMBUS_BYTE) &&
351	    (read_write == I2C_SMBUS_WRITE)))
352		/* These are special: we do not use data */
353		return i2c_smbus_xfer(client->adapter, client->addr,
354				      client->flags, read_write,
355				      command, size, NULL);
356
357	if (data == NULL) {
358		dev_dbg(&client->adapter->dev,
359			"data is NULL pointer in ioctl I2C_SMBUS.\n");
360		return -EINVAL;
361	}
362
363	if ((size == I2C_SMBUS_BYTE_DATA) ||
364	    (size == I2C_SMBUS_BYTE))
365		datasize = sizeof(data->byte);
366	else if ((size == I2C_SMBUS_WORD_DATA) ||
367		 (size == I2C_SMBUS_PROC_CALL))
368		datasize = sizeof(data->word);
369	else /* size == smbus block, i2c block, or block proc. call */
370		datasize = sizeof(data->block);
371
372	if ((size == I2C_SMBUS_PROC_CALL) ||
373	    (size == I2C_SMBUS_BLOCK_PROC_CALL) ||
374	    (size == I2C_SMBUS_I2C_BLOCK_DATA) ||
375	    (read_write == I2C_SMBUS_WRITE)) {
376		if (copy_from_user(&temp, data, datasize))
377			return -EFAULT;
378	}
379	if (size == I2C_SMBUS_I2C_BLOCK_BROKEN) {
380		/* Convert old I2C block commands to the new
381		   convention. This preserves binary compatibility. */
382		size = I2C_SMBUS_I2C_BLOCK_DATA;
383		if (read_write == I2C_SMBUS_READ)
384			temp.block[0] = I2C_SMBUS_BLOCK_MAX;
385	}
386	res = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
387	      read_write, command, size, &temp);
388	if (!res && ((size == I2C_SMBUS_PROC_CALL) ||
389		     (size == I2C_SMBUS_BLOCK_PROC_CALL) ||
390		     (read_write == I2C_SMBUS_READ))) {
391		if (copy_to_user(data, &temp, datasize))
392			return -EFAULT;
393	}
394	return res;
395}
396
397static long i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
398{
399	struct i2c_client *client = file->private_data;
400	unsigned long funcs;
401
402	dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
403		cmd, arg);
404
405	switch (cmd) {
406	case I2C_SLAVE:
407	case I2C_SLAVE_FORCE:
408		if ((arg > 0x3ff) ||
409		    (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
410			return -EINVAL;
411		if (cmd == I2C_SLAVE && i2cdev_check_addr(client->adapter, arg))
412			return -EBUSY;
413		/* REVISIT: address could become busy later */
414		client->addr = arg;
415		return 0;
416	case I2C_TENBIT:
417		if (arg)
418			client->flags |= I2C_M_TEN;
419		else
420			client->flags &= ~I2C_M_TEN;
421		return 0;
422	case I2C_PEC:
423		/*
424		 * Setting the PEC flag here won't affect kernel drivers,
425		 * which will be using the i2c_client node registered with
426		 * the driver model core.  Likewise, when that client has
427		 * the PEC flag already set, the i2c-dev driver won't see
428		 * (or use) this setting.
429		 */
430		if (arg)
431			client->flags |= I2C_CLIENT_PEC;
432		else
433			client->flags &= ~I2C_CLIENT_PEC;
434		return 0;
435	case I2C_FUNCS:
436		funcs = i2c_get_functionality(client->adapter);
437		return put_user(funcs, (unsigned long __user *)arg);
438
439	case I2C_RDWR: {
440		struct i2c_rdwr_ioctl_data rdwr_arg;
441		struct i2c_msg *rdwr_pa;
442
443		if (copy_from_user(&rdwr_arg,
444				   (struct i2c_rdwr_ioctl_data __user *)arg,
445				   sizeof(rdwr_arg)))
446			return -EFAULT;
447
448		/* Put an arbitrary limit on the number of messages that can
449		 * be sent at once */
 
 
 
 
 
450		if (rdwr_arg.nmsgs > I2C_RDWR_IOCTL_MAX_MSGS)
451			return -EINVAL;
452
453		rdwr_pa = memdup_user(rdwr_arg.msgs,
454				      rdwr_arg.nmsgs * sizeof(struct i2c_msg));
455		if (IS_ERR(rdwr_pa))
456			return PTR_ERR(rdwr_pa);
457
458		return i2cdev_ioctl_rdwr(client, rdwr_arg.nmsgs, rdwr_pa);
459	}
460
461	case I2C_SMBUS: {
462		struct i2c_smbus_ioctl_data data_arg;
463		if (copy_from_user(&data_arg,
464				   (struct i2c_smbus_ioctl_data __user *) arg,
465				   sizeof(struct i2c_smbus_ioctl_data)))
466			return -EFAULT;
467		return i2cdev_ioctl_smbus(client, data_arg.read_write,
468					  data_arg.command,
469					  data_arg.size,
470					  data_arg.data);
471	}
472	case I2C_RETRIES:
 
 
 
473		client->adapter->retries = arg;
474		break;
475	case I2C_TIMEOUT:
 
 
 
476		/* For historical reasons, user-space sets the timeout
477		 * value in units of 10 ms.
478		 */
479		client->adapter->timeout = msecs_to_jiffies(arg * 10);
480		break;
481	default:
482		/* NOTE:  returning a fault code here could cause trouble
483		 * in buggy userspace code.  Some old kernel bugs returned
484		 * zero in this case, and userspace code might accidentally
485		 * have depended on that bug.
486		 */
487		return -ENOTTY;
488	}
489	return 0;
490}
491
492#ifdef CONFIG_COMPAT
493
494struct i2c_smbus_ioctl_data32 {
495	u8 read_write;
496	u8 command;
497	u32 size;
498	compat_caddr_t data; /* union i2c_smbus_data *data */
499};
500
501struct i2c_msg32 {
502	u16 addr;
503	u16 flags;
504	u16 len;
505	compat_caddr_t buf;
506};
507
508struct i2c_rdwr_ioctl_data32 {
509	compat_caddr_t msgs; /* struct i2c_msg __user *msgs */
510	u32 nmsgs;
511};
512
513static long compat_i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
514{
515	struct i2c_client *client = file->private_data;
516	unsigned long funcs;
517	switch (cmd) {
518	case I2C_FUNCS:
519		funcs = i2c_get_functionality(client->adapter);
520		return put_user(funcs, (compat_ulong_t __user *)arg);
521	case I2C_RDWR: {
522		struct i2c_rdwr_ioctl_data32 rdwr_arg;
523		struct i2c_msg32 *p;
524		struct i2c_msg *rdwr_pa;
525		int i;
526
527		if (copy_from_user(&rdwr_arg,
528				   (struct i2c_rdwr_ioctl_data32 __user *)arg,
529				   sizeof(rdwr_arg)))
530			return -EFAULT;
531
532		if (rdwr_arg.nmsgs > I2C_RDWR_IOCTL_MAX_MSGS)
533			return -EINVAL;
534
535		rdwr_pa = kmalloc_array(rdwr_arg.nmsgs, sizeof(struct i2c_msg),
536				      GFP_KERNEL);
537		if (!rdwr_pa)
538			return -ENOMEM;
539
540		p = compat_ptr(rdwr_arg.msgs);
541		for (i = 0; i < rdwr_arg.nmsgs; i++) {
542			struct i2c_msg32 umsg;
543			if (copy_from_user(&umsg, p + i, sizeof(umsg))) {
544				kfree(rdwr_pa);
545				return -EFAULT;
546			}
547			rdwr_pa[i] = (struct i2c_msg) {
548				.addr = umsg.addr,
549				.flags = umsg.flags,
550				.len = umsg.len,
551				.buf = compat_ptr(umsg.buf)
552			};
553		}
554
555		return i2cdev_ioctl_rdwr(client, rdwr_arg.nmsgs, rdwr_pa);
556	}
557	case I2C_SMBUS: {
558		struct i2c_smbus_ioctl_data32	data32;
559		if (copy_from_user(&data32,
560				   (void __user *) arg,
561				   sizeof(data32)))
562			return -EFAULT;
563		return i2cdev_ioctl_smbus(client, data32.read_write,
564					  data32.command,
565					  data32.size,
566					  compat_ptr(data32.data));
567	}
568	default:
569		return i2cdev_ioctl(file, cmd, arg);
570	}
571}
572#else
573#define compat_i2cdev_ioctl NULL
574#endif
575
576static int i2cdev_open(struct inode *inode, struct file *file)
577{
578	unsigned int minor = iminor(inode);
579	struct i2c_client *client;
580	struct i2c_adapter *adap;
581
582	adap = i2c_get_adapter(minor);
583	if (!adap)
584		return -ENODEV;
585
586	/* This creates an anonymous i2c_client, which may later be
587	 * pointed to some address using I2C_SLAVE or I2C_SLAVE_FORCE.
588	 *
589	 * This client is ** NEVER REGISTERED ** with the driver model
590	 * or I2C core code!!  It just holds private copies of addressing
591	 * information and maybe a PEC flag.
592	 */
593	client = kzalloc(sizeof(*client), GFP_KERNEL);
594	if (!client) {
595		i2c_put_adapter(adap);
596		return -ENOMEM;
597	}
598	snprintf(client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr);
599
600	client->adapter = adap;
601	file->private_data = client;
602
603	return 0;
604}
605
606static int i2cdev_release(struct inode *inode, struct file *file)
607{
608	struct i2c_client *client = file->private_data;
609
610	i2c_put_adapter(client->adapter);
611	kfree(client);
612	file->private_data = NULL;
613
614	return 0;
615}
616
617static const struct file_operations i2cdev_fops = {
618	.owner		= THIS_MODULE,
619	.llseek		= no_llseek,
620	.read		= i2cdev_read,
621	.write		= i2cdev_write,
622	.unlocked_ioctl	= i2cdev_ioctl,
623	.compat_ioctl	= compat_i2cdev_ioctl,
624	.open		= i2cdev_open,
625	.release	= i2cdev_release,
626};
627
628/* ------------------------------------------------------------------------- */
629
630static struct class *i2c_dev_class;
631
 
 
 
 
 
 
 
 
632static int i2cdev_attach_adapter(struct device *dev, void *dummy)
633{
634	struct i2c_adapter *adap;
635	struct i2c_dev *i2c_dev;
636	int res;
637
638	if (dev->type != &i2c_adapter_type)
639		return 0;
640	adap = to_i2c_adapter(dev);
641
642	i2c_dev = get_free_i2c_dev(adap);
643	if (IS_ERR(i2c_dev))
644		return PTR_ERR(i2c_dev);
645
646	cdev_init(&i2c_dev->cdev, &i2cdev_fops);
647	i2c_dev->cdev.owner = THIS_MODULE;
648	res = cdev_add(&i2c_dev->cdev, MKDEV(I2C_MAJOR, adap->nr), 1);
649	if (res)
650		goto error_cdev;
651
652	/* register this i2c device with the driver core */
653	i2c_dev->dev = device_create(i2c_dev_class, &adap->dev,
654				     MKDEV(I2C_MAJOR, adap->nr), NULL,
655				     "i2c-%d", adap->nr);
656	if (IS_ERR(i2c_dev->dev)) {
657		res = PTR_ERR(i2c_dev->dev);
658		goto error;
 
 
 
 
659	}
660
661	pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",
662		 adap->name, adap->nr);
663	return 0;
664error:
665	cdev_del(&i2c_dev->cdev);
666error_cdev:
667	put_i2c_dev(i2c_dev);
668	return res;
669}
670
671static int i2cdev_detach_adapter(struct device *dev, void *dummy)
672{
673	struct i2c_adapter *adap;
674	struct i2c_dev *i2c_dev;
675
676	if (dev->type != &i2c_adapter_type)
677		return 0;
678	adap = to_i2c_adapter(dev);
679
680	i2c_dev = i2c_dev_get_by_minor(adap->nr);
681	if (!i2c_dev) /* attach_adapter must have failed */
682		return 0;
683
684	cdev_del(&i2c_dev->cdev);
685	put_i2c_dev(i2c_dev);
686	device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));
687
688	pr_debug("i2c-dev: adapter [%s] unregistered\n", adap->name);
689	return 0;
690}
691
692static int i2cdev_notifier_call(struct notifier_block *nb, unsigned long action,
693			 void *data)
694{
695	struct device *dev = data;
696
697	switch (action) {
698	case BUS_NOTIFY_ADD_DEVICE:
699		return i2cdev_attach_adapter(dev, NULL);
700	case BUS_NOTIFY_DEL_DEVICE:
701		return i2cdev_detach_adapter(dev, NULL);
702	}
703
704	return 0;
705}
706
707static struct notifier_block i2cdev_notifier = {
708	.notifier_call = i2cdev_notifier_call,
709};
710
711/* ------------------------------------------------------------------------- */
712
713/*
714 * module load/unload record keeping
715 */
716
717static int __init i2c_dev_init(void)
718{
719	int res;
720
721	printk(KERN_INFO "i2c /dev entries driver\n");
722
723	res = register_chrdev_region(MKDEV(I2C_MAJOR, 0), I2C_MINORS, "i2c");
724	if (res)
725		goto out;
726
727	i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");
728	if (IS_ERR(i2c_dev_class)) {
729		res = PTR_ERR(i2c_dev_class);
730		goto out_unreg_chrdev;
731	}
732	i2c_dev_class->dev_groups = i2c_groups;
733
734	/* Keep track of adapters which will be added or removed later */
735	res = bus_register_notifier(&i2c_bus_type, &i2cdev_notifier);
736	if (res)
737		goto out_unreg_class;
738
739	/* Bind to already existing adapters right away */
740	i2c_for_each_dev(NULL, i2cdev_attach_adapter);
741
742	return 0;
743
744out_unreg_class:
745	class_destroy(i2c_dev_class);
746out_unreg_chrdev:
747	unregister_chrdev_region(MKDEV(I2C_MAJOR, 0), I2C_MINORS);
748out:
749	printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
750	return res;
751}
752
753static void __exit i2c_dev_exit(void)
754{
755	bus_unregister_notifier(&i2c_bus_type, &i2cdev_notifier);
756	i2c_for_each_dev(NULL, i2cdev_detach_adapter);
757	class_destroy(i2c_dev_class);
758	unregister_chrdev_region(MKDEV(I2C_MAJOR, 0), I2C_MINORS);
759}
760
761MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
762		"Simon G. Vogl <simon@tk.uni-linz.ac.at>");
763MODULE_DESCRIPTION("I2C /dev entries driver");
764MODULE_LICENSE("GPL");
765
766module_init(i2c_dev_init);
767module_exit(i2c_dev_exit);
v5.14.15
  1// SPDX-License-Identifier: GPL-2.0-or-later
  2/*
  3    i2c-dev.c - i2c-bus driver, char device interface
  4
  5    Copyright (C) 1995-97 Simon G. Vogl
  6    Copyright (C) 1998-99 Frodo Looijaard <frodol@dds.nl>
  7    Copyright (C) 2003 Greg Kroah-Hartman <greg@kroah.com>
  8
 
 
 
 
 
 
 
 
 
  9*/
 10
 11/* Note that this is a complete rewrite of Simon Vogl's i2c-dev module.
 12   But I have used so much of his original code and ideas that it seems
 13   only fair to recognize him as co-author -- Frodo */
 14
 15/* The I2C_RDWR ioctl code is written by Kolja Waschk <waschk@telos.de> */
 16
 17#include <linux/cdev.h>
 18#include <linux/compat.h>
 19#include <linux/device.h>
 20#include <linux/fs.h>
 21#include <linux/i2c-dev.h>
 22#include <linux/i2c.h>
 23#include <linux/init.h>
 24#include <linux/jiffies.h>
 25#include <linux/kernel.h>
 26#include <linux/list.h>
 27#include <linux/module.h>
 28#include <linux/notifier.h>
 29#include <linux/slab.h>
 30#include <linux/uaccess.h>
 
 31
 32/*
 33 * An i2c_dev represents an i2c_adapter ... an I2C or SMBus master, not a
 34 * slave (i2c_client) with which messages will be exchanged.  It's coupled
 35 * with a character special file which is accessed by user mode drivers.
 36 *
 37 * The list of i2c_dev structures is parallel to the i2c_adapter lists
 38 * maintained by the driver model, and is updated using bus notifications.
 39 */
 40struct i2c_dev {
 41	struct list_head list;
 42	struct i2c_adapter *adap;
 43	struct device dev;
 44	struct cdev cdev;
 45};
 46
 47#define I2C_MINORS	(MINORMASK + 1)
 48static LIST_HEAD(i2c_dev_list);
 49static DEFINE_SPINLOCK(i2c_dev_list_lock);
 50
 51static struct i2c_dev *i2c_dev_get_by_minor(unsigned index)
 52{
 53	struct i2c_dev *i2c_dev;
 54
 55	spin_lock(&i2c_dev_list_lock);
 56	list_for_each_entry(i2c_dev, &i2c_dev_list, list) {
 57		if (i2c_dev->adap->nr == index)
 58			goto found;
 59	}
 60	i2c_dev = NULL;
 61found:
 62	spin_unlock(&i2c_dev_list_lock);
 63	return i2c_dev;
 64}
 65
 66static struct i2c_dev *get_free_i2c_dev(struct i2c_adapter *adap)
 67{
 68	struct i2c_dev *i2c_dev;
 69
 70	if (adap->nr >= I2C_MINORS) {
 71		printk(KERN_ERR "i2c-dev: Out of device minors (%d)\n",
 72		       adap->nr);
 73		return ERR_PTR(-ENODEV);
 74	}
 75
 76	i2c_dev = kzalloc(sizeof(*i2c_dev), GFP_KERNEL);
 77	if (!i2c_dev)
 78		return ERR_PTR(-ENOMEM);
 79	i2c_dev->adap = adap;
 80
 81	spin_lock(&i2c_dev_list_lock);
 82	list_add_tail(&i2c_dev->list, &i2c_dev_list);
 83	spin_unlock(&i2c_dev_list_lock);
 84	return i2c_dev;
 85}
 86
 87static void put_i2c_dev(struct i2c_dev *i2c_dev, bool del_cdev)
 88{
 89	spin_lock(&i2c_dev_list_lock);
 90	list_del(&i2c_dev->list);
 91	spin_unlock(&i2c_dev_list_lock);
 92	if (del_cdev)
 93		cdev_device_del(&i2c_dev->cdev, &i2c_dev->dev);
 94	put_device(&i2c_dev->dev);
 95}
 96
 97static ssize_t name_show(struct device *dev,
 98			 struct device_attribute *attr, char *buf)
 99{
100	struct i2c_dev *i2c_dev = i2c_dev_get_by_minor(MINOR(dev->devt));
101
102	if (!i2c_dev)
103		return -ENODEV;
104	return sprintf(buf, "%s\n", i2c_dev->adap->name);
105}
106static DEVICE_ATTR_RO(name);
107
108static struct attribute *i2c_attrs[] = {
109	&dev_attr_name.attr,
110	NULL,
111};
112ATTRIBUTE_GROUPS(i2c);
113
114/* ------------------------------------------------------------------------- */
115
116/*
117 * After opening an instance of this character special file, a file
118 * descriptor starts out associated only with an i2c_adapter (and bus).
119 *
120 * Using the I2C_RDWR ioctl(), you can then *immediately* issue i2c_msg
121 * traffic to any devices on the bus used by that adapter.  That's because
122 * the i2c_msg vectors embed all the addressing information they need, and
123 * are submitted directly to an i2c_adapter.  However, SMBus-only adapters
124 * don't support that interface.
125 *
126 * To use read()/write() system calls on that file descriptor, or to use
127 * SMBus interfaces (and work with SMBus-only hosts!), you must first issue
128 * an I2C_SLAVE (or I2C_SLAVE_FORCE) ioctl.  That configures an anonymous
129 * (never registered) i2c_client so it holds the addressing information
130 * needed by those system calls and by this SMBus interface.
131 */
132
133static ssize_t i2cdev_read(struct file *file, char __user *buf, size_t count,
134		loff_t *offset)
135{
136	char *tmp;
137	int ret;
138
139	struct i2c_client *client = file->private_data;
140
141	if (count > 8192)
142		count = 8192;
143
144	tmp = kzalloc(count, GFP_KERNEL);
145	if (tmp == NULL)
146		return -ENOMEM;
147
148	pr_debug("i2c-dev: i2c-%d reading %zu bytes.\n",
149		iminor(file_inode(file)), count);
150
151	ret = i2c_master_recv(client, tmp, count);
152	if (ret >= 0)
153		if (copy_to_user(buf, tmp, ret))
154			ret = -EFAULT;
155	kfree(tmp);
156	return ret;
157}
158
159static ssize_t i2cdev_write(struct file *file, const char __user *buf,
160		size_t count, loff_t *offset)
161{
162	int ret;
163	char *tmp;
164	struct i2c_client *client = file->private_data;
165
166	if (count > 8192)
167		count = 8192;
168
169	tmp = memdup_user(buf, count);
170	if (IS_ERR(tmp))
171		return PTR_ERR(tmp);
172
173	pr_debug("i2c-dev: i2c-%d writing %zu bytes.\n",
174		iminor(file_inode(file)), count);
175
176	ret = i2c_master_send(client, tmp, count);
177	kfree(tmp);
178	return ret;
179}
180
181static int i2cdev_check(struct device *dev, void *addrp)
182{
183	struct i2c_client *client = i2c_verify_client(dev);
184
185	if (!client || client->addr != *(unsigned int *)addrp)
186		return 0;
187
188	return dev->driver ? -EBUSY : 0;
189}
190
191/* walk up mux tree */
192static int i2cdev_check_mux_parents(struct i2c_adapter *adapter, int addr)
193{
194	struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
195	int result;
196
197	result = device_for_each_child(&adapter->dev, &addr, i2cdev_check);
198	if (!result && parent)
199		result = i2cdev_check_mux_parents(parent, addr);
200
201	return result;
202}
203
204/* recurse down mux tree */
205static int i2cdev_check_mux_children(struct device *dev, void *addrp)
206{
207	int result;
208
209	if (dev->type == &i2c_adapter_type)
210		result = device_for_each_child(dev, addrp,
211						i2cdev_check_mux_children);
212	else
213		result = i2cdev_check(dev, addrp);
214
215	return result;
216}
217
218/* This address checking function differs from the one in i2c-core
219   in that it considers an address with a registered device, but no
220   driver bound to it, as NOT busy. */
221static int i2cdev_check_addr(struct i2c_adapter *adapter, unsigned int addr)
222{
223	struct i2c_adapter *parent = i2c_parent_is_i2c_adapter(adapter);
224	int result = 0;
225
226	if (parent)
227		result = i2cdev_check_mux_parents(parent, addr);
228
229	if (!result)
230		result = device_for_each_child(&adapter->dev, &addr,
231						i2cdev_check_mux_children);
232
233	return result;
234}
235
236static noinline int i2cdev_ioctl_rdwr(struct i2c_client *client,
237		unsigned nmsgs, struct i2c_msg *msgs)
238{
239	u8 __user **data_ptrs;
240	int i, res;
241
242	data_ptrs = kmalloc_array(nmsgs, sizeof(u8 __user *), GFP_KERNEL);
243	if (data_ptrs == NULL) {
244		kfree(msgs);
245		return -ENOMEM;
246	}
247
248	res = 0;
249	for (i = 0; i < nmsgs; i++) {
250		/* Limit the size of the message to a sane amount */
251		if (msgs[i].len > 8192) {
252			res = -EINVAL;
253			break;
254		}
255
256		data_ptrs[i] = (u8 __user *)msgs[i].buf;
257		msgs[i].buf = memdup_user(data_ptrs[i], msgs[i].len);
258		if (IS_ERR(msgs[i].buf)) {
259			res = PTR_ERR(msgs[i].buf);
260			break;
261		}
262		/* memdup_user allocates with GFP_KERNEL, so DMA is ok */
263		msgs[i].flags |= I2C_M_DMA_SAFE;
264
265		/*
266		 * If the message length is received from the slave (similar
267		 * to SMBus block read), we must ensure that the buffer will
268		 * be large enough to cope with a message length of
269		 * I2C_SMBUS_BLOCK_MAX as this is the maximum underlying bus
270		 * drivers allow. The first byte in the buffer must be
271		 * pre-filled with the number of extra bytes, which must be
272		 * at least one to hold the message length, but can be
273		 * greater (for example to account for a checksum byte at
274		 * the end of the message.)
275		 */
276		if (msgs[i].flags & I2C_M_RECV_LEN) {
277			if (!(msgs[i].flags & I2C_M_RD) ||
278			    msgs[i].len < 1 || msgs[i].buf[0] < 1 ||
279			    msgs[i].len < msgs[i].buf[0] +
280					     I2C_SMBUS_BLOCK_MAX) {
281				i++;
282				res = -EINVAL;
283				break;
284			}
285
286			msgs[i].len = msgs[i].buf[0];
287		}
288	}
289	if (res < 0) {
290		int j;
291		for (j = 0; j < i; ++j)
292			kfree(msgs[j].buf);
293		kfree(data_ptrs);
294		kfree(msgs);
295		return res;
296	}
297
298	res = i2c_transfer(client->adapter, msgs, nmsgs);
299	while (i-- > 0) {
300		if (res >= 0 && (msgs[i].flags & I2C_M_RD)) {
301			if (copy_to_user(data_ptrs[i], msgs[i].buf,
302					 msgs[i].len))
303				res = -EFAULT;
304		}
305		kfree(msgs[i].buf);
306	}
307	kfree(data_ptrs);
308	kfree(msgs);
309	return res;
310}
311
312static noinline int i2cdev_ioctl_smbus(struct i2c_client *client,
313		u8 read_write, u8 command, u32 size,
314		union i2c_smbus_data __user *data)
315{
316	union i2c_smbus_data temp = {};
317	int datasize, res;
318
319	if ((size != I2C_SMBUS_BYTE) &&
320	    (size != I2C_SMBUS_QUICK) &&
321	    (size != I2C_SMBUS_BYTE_DATA) &&
322	    (size != I2C_SMBUS_WORD_DATA) &&
323	    (size != I2C_SMBUS_PROC_CALL) &&
324	    (size != I2C_SMBUS_BLOCK_DATA) &&
325	    (size != I2C_SMBUS_I2C_BLOCK_BROKEN) &&
326	    (size != I2C_SMBUS_I2C_BLOCK_DATA) &&
327	    (size != I2C_SMBUS_BLOCK_PROC_CALL)) {
328		dev_dbg(&client->adapter->dev,
329			"size out of range (%x) in ioctl I2C_SMBUS.\n",
330			size);
331		return -EINVAL;
332	}
333	/* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
334	   so the check is valid if size==I2C_SMBUS_QUICK too. */
335	if ((read_write != I2C_SMBUS_READ) &&
336	    (read_write != I2C_SMBUS_WRITE)) {
337		dev_dbg(&client->adapter->dev,
338			"read_write out of range (%x) in ioctl I2C_SMBUS.\n",
339			read_write);
340		return -EINVAL;
341	}
342
343	/* Note that command values are always valid! */
344
345	if ((size == I2C_SMBUS_QUICK) ||
346	    ((size == I2C_SMBUS_BYTE) &&
347	    (read_write == I2C_SMBUS_WRITE)))
348		/* These are special: we do not use data */
349		return i2c_smbus_xfer(client->adapter, client->addr,
350				      client->flags, read_write,
351				      command, size, NULL);
352
353	if (data == NULL) {
354		dev_dbg(&client->adapter->dev,
355			"data is NULL pointer in ioctl I2C_SMBUS.\n");
356		return -EINVAL;
357	}
358
359	if ((size == I2C_SMBUS_BYTE_DATA) ||
360	    (size == I2C_SMBUS_BYTE))
361		datasize = sizeof(data->byte);
362	else if ((size == I2C_SMBUS_WORD_DATA) ||
363		 (size == I2C_SMBUS_PROC_CALL))
364		datasize = sizeof(data->word);
365	else /* size == smbus block, i2c block, or block proc. call */
366		datasize = sizeof(data->block);
367
368	if ((size == I2C_SMBUS_PROC_CALL) ||
369	    (size == I2C_SMBUS_BLOCK_PROC_CALL) ||
370	    (size == I2C_SMBUS_I2C_BLOCK_DATA) ||
371	    (read_write == I2C_SMBUS_WRITE)) {
372		if (copy_from_user(&temp, data, datasize))
373			return -EFAULT;
374	}
375	if (size == I2C_SMBUS_I2C_BLOCK_BROKEN) {
376		/* Convert old I2C block commands to the new
377		   convention. This preserves binary compatibility. */
378		size = I2C_SMBUS_I2C_BLOCK_DATA;
379		if (read_write == I2C_SMBUS_READ)
380			temp.block[0] = I2C_SMBUS_BLOCK_MAX;
381	}
382	res = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
383	      read_write, command, size, &temp);
384	if (!res && ((size == I2C_SMBUS_PROC_CALL) ||
385		     (size == I2C_SMBUS_BLOCK_PROC_CALL) ||
386		     (read_write == I2C_SMBUS_READ))) {
387		if (copy_to_user(data, &temp, datasize))
388			return -EFAULT;
389	}
390	return res;
391}
392
393static long i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
394{
395	struct i2c_client *client = file->private_data;
396	unsigned long funcs;
397
398	dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
399		cmd, arg);
400
401	switch (cmd) {
402	case I2C_SLAVE:
403	case I2C_SLAVE_FORCE:
404		if ((arg > 0x3ff) ||
405		    (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
406			return -EINVAL;
407		if (cmd == I2C_SLAVE && i2cdev_check_addr(client->adapter, arg))
408			return -EBUSY;
409		/* REVISIT: address could become busy later */
410		client->addr = arg;
411		return 0;
412	case I2C_TENBIT:
413		if (arg)
414			client->flags |= I2C_M_TEN;
415		else
416			client->flags &= ~I2C_M_TEN;
417		return 0;
418	case I2C_PEC:
419		/*
420		 * Setting the PEC flag here won't affect kernel drivers,
421		 * which will be using the i2c_client node registered with
422		 * the driver model core.  Likewise, when that client has
423		 * the PEC flag already set, the i2c-dev driver won't see
424		 * (or use) this setting.
425		 */
426		if (arg)
427			client->flags |= I2C_CLIENT_PEC;
428		else
429			client->flags &= ~I2C_CLIENT_PEC;
430		return 0;
431	case I2C_FUNCS:
432		funcs = i2c_get_functionality(client->adapter);
433		return put_user(funcs, (unsigned long __user *)arg);
434
435	case I2C_RDWR: {
436		struct i2c_rdwr_ioctl_data rdwr_arg;
437		struct i2c_msg *rdwr_pa;
438
439		if (copy_from_user(&rdwr_arg,
440				   (struct i2c_rdwr_ioctl_data __user *)arg,
441				   sizeof(rdwr_arg)))
442			return -EFAULT;
443
444		if (!rdwr_arg.msgs || rdwr_arg.nmsgs == 0)
445			return -EINVAL;
446
447		/*
448		 * Put an arbitrary limit on the number of messages that can
449		 * be sent at once
450		 */
451		if (rdwr_arg.nmsgs > I2C_RDWR_IOCTL_MAX_MSGS)
452			return -EINVAL;
453
454		rdwr_pa = memdup_user(rdwr_arg.msgs,
455				      rdwr_arg.nmsgs * sizeof(struct i2c_msg));
456		if (IS_ERR(rdwr_pa))
457			return PTR_ERR(rdwr_pa);
458
459		return i2cdev_ioctl_rdwr(client, rdwr_arg.nmsgs, rdwr_pa);
460	}
461
462	case I2C_SMBUS: {
463		struct i2c_smbus_ioctl_data data_arg;
464		if (copy_from_user(&data_arg,
465				   (struct i2c_smbus_ioctl_data __user *) arg,
466				   sizeof(struct i2c_smbus_ioctl_data)))
467			return -EFAULT;
468		return i2cdev_ioctl_smbus(client, data_arg.read_write,
469					  data_arg.command,
470					  data_arg.size,
471					  data_arg.data);
472	}
473	case I2C_RETRIES:
474		if (arg > INT_MAX)
475			return -EINVAL;
476
477		client->adapter->retries = arg;
478		break;
479	case I2C_TIMEOUT:
480		if (arg > INT_MAX)
481			return -EINVAL;
482
483		/* For historical reasons, user-space sets the timeout
484		 * value in units of 10 ms.
485		 */
486		client->adapter->timeout = msecs_to_jiffies(arg * 10);
487		break;
488	default:
489		/* NOTE:  returning a fault code here could cause trouble
490		 * in buggy userspace code.  Some old kernel bugs returned
491		 * zero in this case, and userspace code might accidentally
492		 * have depended on that bug.
493		 */
494		return -ENOTTY;
495	}
496	return 0;
497}
498
499#ifdef CONFIG_COMPAT
500
501struct i2c_smbus_ioctl_data32 {
502	u8 read_write;
503	u8 command;
504	u32 size;
505	compat_caddr_t data; /* union i2c_smbus_data *data */
506};
507
508struct i2c_msg32 {
509	u16 addr;
510	u16 flags;
511	u16 len;
512	compat_caddr_t buf;
513};
514
515struct i2c_rdwr_ioctl_data32 {
516	compat_caddr_t msgs; /* struct i2c_msg __user *msgs */
517	u32 nmsgs;
518};
519
520static long compat_i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
521{
522	struct i2c_client *client = file->private_data;
523	unsigned long funcs;
524	switch (cmd) {
525	case I2C_FUNCS:
526		funcs = i2c_get_functionality(client->adapter);
527		return put_user(funcs, (compat_ulong_t __user *)arg);
528	case I2C_RDWR: {
529		struct i2c_rdwr_ioctl_data32 rdwr_arg;
530		struct i2c_msg32 __user *p;
531		struct i2c_msg *rdwr_pa;
532		int i;
533
534		if (copy_from_user(&rdwr_arg,
535				   (struct i2c_rdwr_ioctl_data32 __user *)arg,
536				   sizeof(rdwr_arg)))
537			return -EFAULT;
538
539		if (rdwr_arg.nmsgs > I2C_RDWR_IOCTL_MAX_MSGS)
540			return -EINVAL;
541
542		rdwr_pa = kmalloc_array(rdwr_arg.nmsgs, sizeof(struct i2c_msg),
543				      GFP_KERNEL);
544		if (!rdwr_pa)
545			return -ENOMEM;
546
547		p = compat_ptr(rdwr_arg.msgs);
548		for (i = 0; i < rdwr_arg.nmsgs; i++) {
549			struct i2c_msg32 umsg;
550			if (copy_from_user(&umsg, p + i, sizeof(umsg))) {
551				kfree(rdwr_pa);
552				return -EFAULT;
553			}
554			rdwr_pa[i] = (struct i2c_msg) {
555				.addr = umsg.addr,
556				.flags = umsg.flags,
557				.len = umsg.len,
558				.buf = compat_ptr(umsg.buf)
559			};
560		}
561
562		return i2cdev_ioctl_rdwr(client, rdwr_arg.nmsgs, rdwr_pa);
563	}
564	case I2C_SMBUS: {
565		struct i2c_smbus_ioctl_data32	data32;
566		if (copy_from_user(&data32,
567				   (void __user *) arg,
568				   sizeof(data32)))
569			return -EFAULT;
570		return i2cdev_ioctl_smbus(client, data32.read_write,
571					  data32.command,
572					  data32.size,
573					  compat_ptr(data32.data));
574	}
575	default:
576		return i2cdev_ioctl(file, cmd, arg);
577	}
578}
579#else
580#define compat_i2cdev_ioctl NULL
581#endif
582
583static int i2cdev_open(struct inode *inode, struct file *file)
584{
585	unsigned int minor = iminor(inode);
586	struct i2c_client *client;
587	struct i2c_adapter *adap;
588
589	adap = i2c_get_adapter(minor);
590	if (!adap)
591		return -ENODEV;
592
593	/* This creates an anonymous i2c_client, which may later be
594	 * pointed to some address using I2C_SLAVE or I2C_SLAVE_FORCE.
595	 *
596	 * This client is ** NEVER REGISTERED ** with the driver model
597	 * or I2C core code!!  It just holds private copies of addressing
598	 * information and maybe a PEC flag.
599	 */
600	client = kzalloc(sizeof(*client), GFP_KERNEL);
601	if (!client) {
602		i2c_put_adapter(adap);
603		return -ENOMEM;
604	}
605	snprintf(client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr);
606
607	client->adapter = adap;
608	file->private_data = client;
609
610	return 0;
611}
612
613static int i2cdev_release(struct inode *inode, struct file *file)
614{
615	struct i2c_client *client = file->private_data;
616
617	i2c_put_adapter(client->adapter);
618	kfree(client);
619	file->private_data = NULL;
620
621	return 0;
622}
623
624static const struct file_operations i2cdev_fops = {
625	.owner		= THIS_MODULE,
626	.llseek		= no_llseek,
627	.read		= i2cdev_read,
628	.write		= i2cdev_write,
629	.unlocked_ioctl	= i2cdev_ioctl,
630	.compat_ioctl	= compat_i2cdev_ioctl,
631	.open		= i2cdev_open,
632	.release	= i2cdev_release,
633};
634
635/* ------------------------------------------------------------------------- */
636
637static struct class *i2c_dev_class;
638
639static void i2cdev_dev_release(struct device *dev)
640{
641	struct i2c_dev *i2c_dev;
642
643	i2c_dev = container_of(dev, struct i2c_dev, dev);
644	kfree(i2c_dev);
645}
646
647static int i2cdev_attach_adapter(struct device *dev, void *dummy)
648{
649	struct i2c_adapter *adap;
650	struct i2c_dev *i2c_dev;
651	int res;
652
653	if (dev->type != &i2c_adapter_type)
654		return 0;
655	adap = to_i2c_adapter(dev);
656
657	i2c_dev = get_free_i2c_dev(adap);
658	if (IS_ERR(i2c_dev))
659		return PTR_ERR(i2c_dev);
660
661	cdev_init(&i2c_dev->cdev, &i2cdev_fops);
662	i2c_dev->cdev.owner = THIS_MODULE;
 
 
 
663
664	device_initialize(&i2c_dev->dev);
665	i2c_dev->dev.devt = MKDEV(I2C_MAJOR, adap->nr);
666	i2c_dev->dev.class = i2c_dev_class;
667	i2c_dev->dev.parent = &adap->dev;
668	i2c_dev->dev.release = i2cdev_dev_release;
669	dev_set_name(&i2c_dev->dev, "i2c-%d", adap->nr);
670
671	res = cdev_device_add(&i2c_dev->cdev, &i2c_dev->dev);
672	if (res) {
673		put_i2c_dev(i2c_dev, false);
674		return res;
675	}
676
677	pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",
678		 adap->name, adap->nr);
679	return 0;
 
 
 
 
 
680}
681
682static int i2cdev_detach_adapter(struct device *dev, void *dummy)
683{
684	struct i2c_adapter *adap;
685	struct i2c_dev *i2c_dev;
686
687	if (dev->type != &i2c_adapter_type)
688		return 0;
689	adap = to_i2c_adapter(dev);
690
691	i2c_dev = i2c_dev_get_by_minor(adap->nr);
692	if (!i2c_dev) /* attach_adapter must have failed */
693		return 0;
694
695	put_i2c_dev(i2c_dev, true);
 
 
696
697	pr_debug("i2c-dev: adapter [%s] unregistered\n", adap->name);
698	return 0;
699}
700
701static int i2cdev_notifier_call(struct notifier_block *nb, unsigned long action,
702			 void *data)
703{
704	struct device *dev = data;
705
706	switch (action) {
707	case BUS_NOTIFY_ADD_DEVICE:
708		return i2cdev_attach_adapter(dev, NULL);
709	case BUS_NOTIFY_DEL_DEVICE:
710		return i2cdev_detach_adapter(dev, NULL);
711	}
712
713	return 0;
714}
715
716static struct notifier_block i2cdev_notifier = {
717	.notifier_call = i2cdev_notifier_call,
718};
719
720/* ------------------------------------------------------------------------- */
721
722/*
723 * module load/unload record keeping
724 */
725
726static int __init i2c_dev_init(void)
727{
728	int res;
729
730	printk(KERN_INFO "i2c /dev entries driver\n");
731
732	res = register_chrdev_region(MKDEV(I2C_MAJOR, 0), I2C_MINORS, "i2c");
733	if (res)
734		goto out;
735
736	i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");
737	if (IS_ERR(i2c_dev_class)) {
738		res = PTR_ERR(i2c_dev_class);
739		goto out_unreg_chrdev;
740	}
741	i2c_dev_class->dev_groups = i2c_groups;
742
743	/* Keep track of adapters which will be added or removed later */
744	res = bus_register_notifier(&i2c_bus_type, &i2cdev_notifier);
745	if (res)
746		goto out_unreg_class;
747
748	/* Bind to already existing adapters right away */
749	i2c_for_each_dev(NULL, i2cdev_attach_adapter);
750
751	return 0;
752
753out_unreg_class:
754	class_destroy(i2c_dev_class);
755out_unreg_chrdev:
756	unregister_chrdev_region(MKDEV(I2C_MAJOR, 0), I2C_MINORS);
757out:
758	printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
759	return res;
760}
761
762static void __exit i2c_dev_exit(void)
763{
764	bus_unregister_notifier(&i2c_bus_type, &i2cdev_notifier);
765	i2c_for_each_dev(NULL, i2cdev_detach_adapter);
766	class_destroy(i2c_dev_class);
767	unregister_chrdev_region(MKDEV(I2C_MAJOR, 0), I2C_MINORS);
768}
769
770MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl>");
771MODULE_AUTHOR("Simon G. Vogl <simon@tk.uni-linz.ac.at>");
772MODULE_DESCRIPTION("I2C /dev entries driver");
773MODULE_LICENSE("GPL");
774
775module_init(i2c_dev_init);
776module_exit(i2c_dev_exit);