2 i2c-dev.c - i2c-bus driver, char device interface
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>
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.
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.
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 */
23 /* The I2C_RDWR ioctl code is written by Kolja Waschk <waschk@telos.de> */
25 #include <linux/cdev.h>
26 #include <linux/device.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>
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.
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.
49 struct list_head list
;
50 struct i2c_adapter
*adap
;
55 #define I2C_MINORS MINORMASK
56 static LIST_HEAD(i2c_dev_list
);
57 static DEFINE_SPINLOCK(i2c_dev_list_lock
);
59 static struct i2c_dev
*i2c_dev_get_by_minor(unsigned index
)
61 struct i2c_dev
*i2c_dev
;
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
)
70 spin_unlock(&i2c_dev_list_lock
);
74 static struct i2c_dev
*get_free_i2c_dev(struct i2c_adapter
*adap
)
76 struct i2c_dev
*i2c_dev
;
78 if (adap
->nr
>= I2C_MINORS
) {
79 printk(KERN_ERR
"i2c-dev: Out of device minors (%d)\n",
81 return ERR_PTR(-ENODEV
);
84 i2c_dev
= kzalloc(sizeof(*i2c_dev
), GFP_KERNEL
);
86 return ERR_PTR(-ENOMEM
);
89 spin_lock(&i2c_dev_list_lock
);
90 list_add_tail(&i2c_dev
->list
, &i2c_dev_list
);
91 spin_unlock(&i2c_dev_list_lock
);
95 static void put_i2c_dev(struct i2c_dev
*i2c_dev
)
97 spin_lock(&i2c_dev_list_lock
);
98 list_del(&i2c_dev
->list
);
99 spin_unlock(&i2c_dev_list_lock
);
103 static ssize_t
name_show(struct device
*dev
,
104 struct device_attribute
*attr
, char *buf
)
106 struct i2c_dev
*i2c_dev
= i2c_dev_get_by_minor(MINOR(dev
->devt
));
110 return sprintf(buf
, "%s\n", i2c_dev
->adap
->name
);
112 static DEVICE_ATTR_RO(name
);
114 static struct attribute
*i2c_attrs
[] = {
118 ATTRIBUTE_GROUPS(i2c
);
120 /* ------------------------------------------------------------------------- */
123 * After opening an instance of this character special file, a file
124 * descriptor starts out associated only with an i2c_adapter (and bus).
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.
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.
139 static ssize_t
i2cdev_read(struct file
*file
, char __user
*buf
, size_t count
,
145 struct i2c_client
*client
= file
->private_data
;
150 tmp
= kmalloc(count
, GFP_KERNEL
);
154 pr_debug("i2c-dev: i2c-%d reading %zu bytes.\n",
155 iminor(file_inode(file
)), count
);
157 ret
= i2c_master_recv(client
, tmp
, count
);
159 ret
= copy_to_user(buf
, tmp
, count
) ? -EFAULT
: ret
;
164 static ssize_t
i2cdev_write(struct file
*file
, const char __user
*buf
,
165 size_t count
, loff_t
*offset
)
169 struct i2c_client
*client
= file
->private_data
;
174 tmp
= memdup_user(buf
, count
);
178 pr_debug("i2c-dev: i2c-%d writing %zu bytes.\n",
179 iminor(file_inode(file
)), count
);
181 ret
= i2c_master_send(client
, tmp
, count
);
186 static int i2cdev_check(struct device
*dev
, void *addrp
)
188 struct i2c_client
*client
= i2c_verify_client(dev
);
190 if (!client
|| client
->addr
!= *(unsigned int *)addrp
)
193 return dev
->driver
? -EBUSY
: 0;
196 /* walk up mux tree */
197 static int i2cdev_check_mux_parents(struct i2c_adapter
*adapter
, int addr
)
199 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
202 result
= device_for_each_child(&adapter
->dev
, &addr
, i2cdev_check
);
203 if (!result
&& parent
)
204 result
= i2cdev_check_mux_parents(parent
, addr
);
209 /* recurse down mux tree */
210 static int i2cdev_check_mux_children(struct device
*dev
, void *addrp
)
214 if (dev
->type
== &i2c_adapter_type
)
215 result
= device_for_each_child(dev
, addrp
,
216 i2cdev_check_mux_children
);
218 result
= i2cdev_check(dev
, addrp
);
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. */
226 static int i2cdev_check_addr(struct i2c_adapter
*adapter
, unsigned int addr
)
228 struct i2c_adapter
*parent
= i2c_parent_is_i2c_adapter(adapter
);
232 result
= i2cdev_check_mux_parents(parent
, addr
);
235 result
= device_for_each_child(&adapter
->dev
, &addr
,
236 i2cdev_check_mux_children
);
241 static noinline
int i2cdev_ioctl_rdwr(struct i2c_client
*client
,
242 unsigned nmsgs
, struct i2c_msg
*msgs
)
244 u8 __user
**data_ptrs
;
247 data_ptrs
= kmalloc(nmsgs
* sizeof(u8 __user
*), GFP_KERNEL
);
248 if (data_ptrs
== NULL
) {
254 for (i
= 0; i
< nmsgs
; i
++) {
255 /* Limit the size of the message to a sane amount */
256 if (msgs
[i
].len
> 8192) {
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
);
269 * If the message length is received from the slave (similar
270 * to SMBus block read), we must ensure that the buffer will
271 * be large enough to cope with a message length of
272 * I2C_SMBUS_BLOCK_MAX as this is the maximum underlying bus
273 * drivers allow. The first byte in the buffer must be
274 * pre-filled with the number of extra bytes, which must be
275 * at least one to hold the message length, but can be
276 * greater (for example to account for a checksum byte at
277 * the end of the message.)
279 if (msgs
[i
].flags
& I2C_M_RECV_LEN
) {
280 if (!(msgs
[i
].flags
& I2C_M_RD
) ||
281 msgs
[i
].len
< 1 || msgs
[i
].buf
[0] < 1 ||
282 msgs
[i
].len
< msgs
[i
].buf
[0] +
283 I2C_SMBUS_BLOCK_MAX
) {
288 msgs
[i
].len
= msgs
[i
].buf
[0];
293 for (j
= 0; j
< i
; ++j
)
300 res
= i2c_transfer(client
->adapter
, msgs
, nmsgs
);
302 if (res
>= 0 && (msgs
[i
].flags
& I2C_M_RD
)) {
303 if (copy_to_user(data_ptrs
[i
], msgs
[i
].buf
,
314 static noinline
int i2cdev_ioctl_smbus(struct i2c_client
*client
,
315 u8 read_write
, u8 command
, u32 size
,
316 union i2c_smbus_data __user
*data
)
318 union i2c_smbus_data temp
= {};
321 if ((size
!= I2C_SMBUS_BYTE
) &&
322 (size
!= I2C_SMBUS_QUICK
) &&
323 (size
!= I2C_SMBUS_BYTE_DATA
) &&
324 (size
!= I2C_SMBUS_WORD_DATA
) &&
325 (size
!= I2C_SMBUS_PROC_CALL
) &&
326 (size
!= I2C_SMBUS_BLOCK_DATA
) &&
327 (size
!= I2C_SMBUS_I2C_BLOCK_BROKEN
) &&
328 (size
!= I2C_SMBUS_I2C_BLOCK_DATA
) &&
329 (size
!= I2C_SMBUS_BLOCK_PROC_CALL
)) {
330 dev_dbg(&client
->adapter
->dev
,
331 "size out of range (%x) in ioctl I2C_SMBUS.\n",
335 /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
336 so the check is valid if size==I2C_SMBUS_QUICK too. */
337 if ((read_write
!= I2C_SMBUS_READ
) &&
338 (read_write
!= I2C_SMBUS_WRITE
)) {
339 dev_dbg(&client
->adapter
->dev
,
340 "read_write out of range (%x) in ioctl I2C_SMBUS.\n",
345 /* Note that command values are always valid! */
347 if ((size
== I2C_SMBUS_QUICK
) ||
348 ((size
== I2C_SMBUS_BYTE
) &&
349 (read_write
== I2C_SMBUS_WRITE
)))
350 /* These are special: we do not use data */
351 return i2c_smbus_xfer(client
->adapter
, client
->addr
,
352 client
->flags
, read_write
,
353 command
, size
, NULL
);
356 dev_dbg(&client
->adapter
->dev
,
357 "data is NULL pointer in ioctl I2C_SMBUS.\n");
361 if ((size
== I2C_SMBUS_BYTE_DATA
) ||
362 (size
== I2C_SMBUS_BYTE
))
363 datasize
= sizeof(data
->byte
);
364 else if ((size
== I2C_SMBUS_WORD_DATA
) ||
365 (size
== I2C_SMBUS_PROC_CALL
))
366 datasize
= sizeof(data
->word
);
367 else /* size == smbus block, i2c block, or block proc. call */
368 datasize
= sizeof(data
->block
);
370 if ((size
== I2C_SMBUS_PROC_CALL
) ||
371 (size
== I2C_SMBUS_BLOCK_PROC_CALL
) ||
372 (size
== I2C_SMBUS_I2C_BLOCK_DATA
) ||
373 (read_write
== I2C_SMBUS_WRITE
)) {
374 if (copy_from_user(&temp
, data
, datasize
))
377 if (size
== I2C_SMBUS_I2C_BLOCK_BROKEN
) {
378 /* Convert old I2C block commands to the new
379 convention. This preserves binary compatibility. */
380 size
= I2C_SMBUS_I2C_BLOCK_DATA
;
381 if (read_write
== I2C_SMBUS_READ
)
382 temp
.block
[0] = I2C_SMBUS_BLOCK_MAX
;
384 res
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
385 read_write
, command
, size
, &temp
);
386 if (!res
&& ((size
== I2C_SMBUS_PROC_CALL
) ||
387 (size
== I2C_SMBUS_BLOCK_PROC_CALL
) ||
388 (read_write
== I2C_SMBUS_READ
))) {
389 if (copy_to_user(data
, &temp
, datasize
))
395 static long i2cdev_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
397 struct i2c_client
*client
= file
->private_data
;
400 dev_dbg(&client
->adapter
->dev
, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
405 case I2C_SLAVE_FORCE
:
407 (((client
->flags
& I2C_M_TEN
) == 0) && arg
> 0x7f))
409 if (cmd
== I2C_SLAVE
&& i2cdev_check_addr(client
->adapter
, arg
))
411 /* REVISIT: address could become busy later */
416 client
->flags
|= I2C_M_TEN
;
418 client
->flags
&= ~I2C_M_TEN
;
422 * Setting the PEC flag here won't affect kernel drivers,
423 * which will be using the i2c_client node registered with
424 * the driver model core. Likewise, when that client has
425 * the PEC flag already set, the i2c-dev driver won't see
426 * (or use) this setting.
429 client
->flags
|= I2C_CLIENT_PEC
;
431 client
->flags
&= ~I2C_CLIENT_PEC
;
434 funcs
= i2c_get_functionality(client
->adapter
);
435 return put_user(funcs
, (unsigned long __user
*)arg
);
438 struct i2c_rdwr_ioctl_data rdwr_arg
;
439 struct i2c_msg
*rdwr_pa
;
441 if (copy_from_user(&rdwr_arg
,
442 (struct i2c_rdwr_ioctl_data __user
*)arg
,
446 /* Put an arbitrary limit on the number of messages that can
448 if (rdwr_arg
.nmsgs
> I2C_RDWR_IOCTL_MAX_MSGS
)
451 rdwr_pa
= memdup_user(rdwr_arg
.msgs
,
452 rdwr_arg
.nmsgs
* sizeof(struct i2c_msg
));
454 return PTR_ERR(rdwr_pa
);
456 return i2cdev_ioctl_rdwr(client
, rdwr_arg
.nmsgs
, rdwr_pa
);
460 struct i2c_smbus_ioctl_data data_arg
;
461 if (copy_from_user(&data_arg
,
462 (struct i2c_smbus_ioctl_data __user
*) arg
,
463 sizeof(struct i2c_smbus_ioctl_data
)))
465 return i2cdev_ioctl_smbus(client
, data_arg
.read_write
,
471 client
->adapter
->retries
= arg
;
474 /* For historical reasons, user-space sets the timeout
475 * value in units of 10 ms.
477 client
->adapter
->timeout
= msecs_to_jiffies(arg
* 10);
480 /* NOTE: returning a fault code here could cause trouble
481 * in buggy userspace code. Some old kernel bugs returned
482 * zero in this case, and userspace code might accidentally
483 * have depended on that bug.
492 struct i2c_smbus_ioctl_data32
{
496 compat_caddr_t data
; /* union i2c_smbus_data *data */
506 struct i2c_rdwr_ioctl_data32
{
507 compat_caddr_t msgs
; /* struct i2c_msg __user *msgs */
511 static long compat_i2cdev_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
513 struct i2c_client
*client
= file
->private_data
;
517 funcs
= i2c_get_functionality(client
->adapter
);
518 return put_user(funcs
, (compat_ulong_t __user
*)arg
);
520 struct i2c_rdwr_ioctl_data32 rdwr_arg
;
522 struct i2c_msg
*rdwr_pa
;
525 if (copy_from_user(&rdwr_arg
,
526 (struct i2c_rdwr_ioctl_data32 __user
*)arg
,
530 if (rdwr_arg
.nmsgs
> I2C_RDWR_IOCTL_MAX_MSGS
)
533 rdwr_pa
= kmalloc_array(rdwr_arg
.nmsgs
, sizeof(struct i2c_msg
),
538 p
= compat_ptr(rdwr_arg
.msgs
);
539 for (i
= 0; i
< rdwr_arg
.nmsgs
; i
++) {
540 struct i2c_msg32 umsg
;
541 if (copy_from_user(&umsg
, p
+ i
, sizeof(umsg
))) {
545 rdwr_pa
[i
] = (struct i2c_msg
) {
549 .buf
= compat_ptr(umsg
.buf
)
553 return i2cdev_ioctl_rdwr(client
, rdwr_arg
.nmsgs
, rdwr_pa
);
556 struct i2c_smbus_ioctl_data32 data32
;
557 if (copy_from_user(&data32
,
561 return i2cdev_ioctl_smbus(client
, data32
.read_write
,
564 compat_ptr(data32
.data
));
567 return i2cdev_ioctl(file
, cmd
, arg
);
571 #define compat_i2cdev_ioctl NULL
574 static int i2cdev_open(struct inode
*inode
, struct file
*file
)
576 unsigned int minor
= iminor(inode
);
577 struct i2c_client
*client
;
578 struct i2c_adapter
*adap
;
580 adap
= i2c_get_adapter(minor
);
584 /* This creates an anonymous i2c_client, which may later be
585 * pointed to some address using I2C_SLAVE or I2C_SLAVE_FORCE.
587 * This client is ** NEVER REGISTERED ** with the driver model
588 * or I2C core code!! It just holds private copies of addressing
589 * information and maybe a PEC flag.
591 client
= kzalloc(sizeof(*client
), GFP_KERNEL
);
593 i2c_put_adapter(adap
);
596 snprintf(client
->name
, I2C_NAME_SIZE
, "i2c-dev %d", adap
->nr
);
598 client
->adapter
= adap
;
599 file
->private_data
= client
;
604 static int i2cdev_release(struct inode
*inode
, struct file
*file
)
606 struct i2c_client
*client
= file
->private_data
;
608 i2c_put_adapter(client
->adapter
);
610 file
->private_data
= NULL
;
615 static const struct file_operations i2cdev_fops
= {
616 .owner
= THIS_MODULE
,
619 .write
= i2cdev_write
,
620 .unlocked_ioctl
= i2cdev_ioctl
,
621 .compat_ioctl
= compat_i2cdev_ioctl
,
623 .release
= i2cdev_release
,
626 /* ------------------------------------------------------------------------- */
628 static struct class *i2c_dev_class
;
630 static int i2cdev_attach_adapter(struct device
*dev
, void *dummy
)
632 struct i2c_adapter
*adap
;
633 struct i2c_dev
*i2c_dev
;
636 if (dev
->type
!= &i2c_adapter_type
)
638 adap
= to_i2c_adapter(dev
);
640 i2c_dev
= get_free_i2c_dev(adap
);
642 return PTR_ERR(i2c_dev
);
644 cdev_init(&i2c_dev
->cdev
, &i2cdev_fops
);
645 i2c_dev
->cdev
.owner
= THIS_MODULE
;
646 res
= cdev_add(&i2c_dev
->cdev
, MKDEV(I2C_MAJOR
, adap
->nr
), 1);
650 /* register this i2c device with the driver core */
651 i2c_dev
->dev
= device_create(i2c_dev_class
, &adap
->dev
,
652 MKDEV(I2C_MAJOR
, adap
->nr
), NULL
,
654 if (IS_ERR(i2c_dev
->dev
)) {
655 res
= PTR_ERR(i2c_dev
->dev
);
659 pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",
660 adap
->name
, adap
->nr
);
663 cdev_del(&i2c_dev
->cdev
);
665 put_i2c_dev(i2c_dev
);
669 static int i2cdev_detach_adapter(struct device
*dev
, void *dummy
)
671 struct i2c_adapter
*adap
;
672 struct i2c_dev
*i2c_dev
;
674 if (dev
->type
!= &i2c_adapter_type
)
676 adap
= to_i2c_adapter(dev
);
678 i2c_dev
= i2c_dev_get_by_minor(adap
->nr
);
679 if (!i2c_dev
) /* attach_adapter must have failed */
682 cdev_del(&i2c_dev
->cdev
);
683 put_i2c_dev(i2c_dev
);
684 device_destroy(i2c_dev_class
, MKDEV(I2C_MAJOR
, adap
->nr
));
686 pr_debug("i2c-dev: adapter [%s] unregistered\n", adap
->name
);
690 static int i2cdev_notifier_call(struct notifier_block
*nb
, unsigned long action
,
693 struct device
*dev
= data
;
696 case BUS_NOTIFY_ADD_DEVICE
:
697 return i2cdev_attach_adapter(dev
, NULL
);
698 case BUS_NOTIFY_DEL_DEVICE
:
699 return i2cdev_detach_adapter(dev
, NULL
);
705 static struct notifier_block i2cdev_notifier
= {
706 .notifier_call
= i2cdev_notifier_call
,
709 /* ------------------------------------------------------------------------- */
712 * module load/unload record keeping
715 static int __init
i2c_dev_init(void)
719 printk(KERN_INFO
"i2c /dev entries driver\n");
721 res
= register_chrdev_region(MKDEV(I2C_MAJOR
, 0), I2C_MINORS
, "i2c");
725 i2c_dev_class
= class_create(THIS_MODULE
, "i2c-dev");
726 if (IS_ERR(i2c_dev_class
)) {
727 res
= PTR_ERR(i2c_dev_class
);
728 goto out_unreg_chrdev
;
730 i2c_dev_class
->dev_groups
= i2c_groups
;
732 /* Keep track of adapters which will be added or removed later */
733 res
= bus_register_notifier(&i2c_bus_type
, &i2cdev_notifier
);
735 goto out_unreg_class
;
737 /* Bind to already existing adapters right away */
738 i2c_for_each_dev(NULL
, i2cdev_attach_adapter
);
743 class_destroy(i2c_dev_class
);
745 unregister_chrdev_region(MKDEV(I2C_MAJOR
, 0), I2C_MINORS
);
747 printk(KERN_ERR
"%s: Driver Initialisation failed\n", __FILE__
);
751 static void __exit
i2c_dev_exit(void)
753 bus_unregister_notifier(&i2c_bus_type
, &i2cdev_notifier
);
754 i2c_for_each_dev(NULL
, i2cdev_detach_adapter
);
755 class_destroy(i2c_dev_class
);
756 unregister_chrdev_region(MKDEV(I2C_MAJOR
, 0), I2C_MINORS
);
759 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
760 "Simon G. Vogl <simon@tk.uni-linz.ac.at>");
761 MODULE_DESCRIPTION("I2C /dev entries driver");
762 MODULE_LICENSE("GPL");
764 module_init(i2c_dev_init
);
765 module_exit(i2c_dev_exit
);