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
) {
289 msgs
[i
].len
= msgs
[i
].buf
[0];
294 for (j
= 0; j
< i
; ++j
)
301 res
= i2c_transfer(client
->adapter
, msgs
, nmsgs
);
303 if (res
>= 0 && (msgs
[i
].flags
& I2C_M_RD
)) {
304 if (copy_to_user(data_ptrs
[i
], msgs
[i
].buf
,
315 static noinline
int i2cdev_ioctl_smbus(struct i2c_client
*client
,
316 u8 read_write
, u8 command
, u32 size
,
317 union i2c_smbus_data __user
*data
)
319 union i2c_smbus_data temp
= {};
322 if ((size
!= I2C_SMBUS_BYTE
) &&
323 (size
!= I2C_SMBUS_QUICK
) &&
324 (size
!= I2C_SMBUS_BYTE_DATA
) &&
325 (size
!= I2C_SMBUS_WORD_DATA
) &&
326 (size
!= I2C_SMBUS_PROC_CALL
) &&
327 (size
!= I2C_SMBUS_BLOCK_DATA
) &&
328 (size
!= I2C_SMBUS_I2C_BLOCK_BROKEN
) &&
329 (size
!= I2C_SMBUS_I2C_BLOCK_DATA
) &&
330 (size
!= I2C_SMBUS_BLOCK_PROC_CALL
)) {
331 dev_dbg(&client
->adapter
->dev
,
332 "size out of range (%x) in ioctl I2C_SMBUS.\n",
336 /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
337 so the check is valid if size==I2C_SMBUS_QUICK too. */
338 if ((read_write
!= I2C_SMBUS_READ
) &&
339 (read_write
!= I2C_SMBUS_WRITE
)) {
340 dev_dbg(&client
->adapter
->dev
,
341 "read_write out of range (%x) in ioctl I2C_SMBUS.\n",
346 /* Note that command values are always valid! */
348 if ((size
== I2C_SMBUS_QUICK
) ||
349 ((size
== I2C_SMBUS_BYTE
) &&
350 (read_write
== I2C_SMBUS_WRITE
)))
351 /* These are special: we do not use data */
352 return i2c_smbus_xfer(client
->adapter
, client
->addr
,
353 client
->flags
, read_write
,
354 command
, size
, NULL
);
357 dev_dbg(&client
->adapter
->dev
,
358 "data is NULL pointer in ioctl I2C_SMBUS.\n");
362 if ((size
== I2C_SMBUS_BYTE_DATA
) ||
363 (size
== I2C_SMBUS_BYTE
))
364 datasize
= sizeof(data
->byte
);
365 else if ((size
== I2C_SMBUS_WORD_DATA
) ||
366 (size
== I2C_SMBUS_PROC_CALL
))
367 datasize
= sizeof(data
->word
);
368 else /* size == smbus block, i2c block, or block proc. call */
369 datasize
= sizeof(data
->block
);
371 if ((size
== I2C_SMBUS_PROC_CALL
) ||
372 (size
== I2C_SMBUS_BLOCK_PROC_CALL
) ||
373 (size
== I2C_SMBUS_I2C_BLOCK_DATA
) ||
374 (read_write
== I2C_SMBUS_WRITE
)) {
375 if (copy_from_user(&temp
, data
, datasize
))
378 if (size
== I2C_SMBUS_I2C_BLOCK_BROKEN
) {
379 /* Convert old I2C block commands to the new
380 convention. This preserves binary compatibility. */
381 size
= I2C_SMBUS_I2C_BLOCK_DATA
;
382 if (read_write
== I2C_SMBUS_READ
)
383 temp
.block
[0] = I2C_SMBUS_BLOCK_MAX
;
385 res
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
386 read_write
, command
, size
, &temp
);
387 if (!res
&& ((size
== I2C_SMBUS_PROC_CALL
) ||
388 (size
== I2C_SMBUS_BLOCK_PROC_CALL
) ||
389 (read_write
== I2C_SMBUS_READ
))) {
390 if (copy_to_user(data
, &temp
, datasize
))
396 static long i2cdev_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
398 struct i2c_client
*client
= file
->private_data
;
401 dev_dbg(&client
->adapter
->dev
, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
406 case I2C_SLAVE_FORCE
:
408 (((client
->flags
& I2C_M_TEN
) == 0) && arg
> 0x7f))
410 if (cmd
== I2C_SLAVE
&& i2cdev_check_addr(client
->adapter
, arg
))
412 /* REVISIT: address could become busy later */
417 client
->flags
|= I2C_M_TEN
;
419 client
->flags
&= ~I2C_M_TEN
;
423 * Setting the PEC flag here won't affect kernel drivers,
424 * which will be using the i2c_client node registered with
425 * the driver model core. Likewise, when that client has
426 * the PEC flag already set, the i2c-dev driver won't see
427 * (or use) this setting.
430 client
->flags
|= I2C_CLIENT_PEC
;
432 client
->flags
&= ~I2C_CLIENT_PEC
;
435 funcs
= i2c_get_functionality(client
->adapter
);
436 return put_user(funcs
, (unsigned long __user
*)arg
);
439 struct i2c_rdwr_ioctl_data rdwr_arg
;
440 struct i2c_msg
*rdwr_pa
;
442 if (copy_from_user(&rdwr_arg
,
443 (struct i2c_rdwr_ioctl_data __user
*)arg
,
447 /* Put an arbitrary limit on the number of messages that can
449 if (rdwr_arg
.nmsgs
> I2C_RDWR_IOCTL_MAX_MSGS
)
452 rdwr_pa
= memdup_user(rdwr_arg
.msgs
,
453 rdwr_arg
.nmsgs
* sizeof(struct i2c_msg
));
455 return PTR_ERR(rdwr_pa
);
457 return i2cdev_ioctl_rdwr(client
, rdwr_arg
.nmsgs
, rdwr_pa
);
461 struct i2c_smbus_ioctl_data data_arg
;
462 if (copy_from_user(&data_arg
,
463 (struct i2c_smbus_ioctl_data __user
*) arg
,
464 sizeof(struct i2c_smbus_ioctl_data
)))
466 return i2cdev_ioctl_smbus(client
, data_arg
.read_write
,
475 client
->adapter
->retries
= arg
;
481 /* For historical reasons, user-space sets the timeout
482 * value in units of 10 ms.
484 client
->adapter
->timeout
= msecs_to_jiffies(arg
* 10);
487 /* NOTE: returning a fault code here could cause trouble
488 * in buggy userspace code. Some old kernel bugs returned
489 * zero in this case, and userspace code might accidentally
490 * have depended on that bug.
499 struct i2c_smbus_ioctl_data32
{
503 compat_caddr_t data
; /* union i2c_smbus_data *data */
513 struct i2c_rdwr_ioctl_data32
{
514 compat_caddr_t msgs
; /* struct i2c_msg __user *msgs */
518 static long compat_i2cdev_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
520 struct i2c_client
*client
= file
->private_data
;
524 funcs
= i2c_get_functionality(client
->adapter
);
525 return put_user(funcs
, (compat_ulong_t __user
*)arg
);
527 struct i2c_rdwr_ioctl_data32 rdwr_arg
;
529 struct i2c_msg
*rdwr_pa
;
532 if (copy_from_user(&rdwr_arg
,
533 (struct i2c_rdwr_ioctl_data32 __user
*)arg
,
537 if (rdwr_arg
.nmsgs
> I2C_RDWR_IOCTL_MAX_MSGS
)
540 rdwr_pa
= kmalloc_array(rdwr_arg
.nmsgs
, sizeof(struct i2c_msg
),
545 p
= compat_ptr(rdwr_arg
.msgs
);
546 for (i
= 0; i
< rdwr_arg
.nmsgs
; i
++) {
547 struct i2c_msg32 umsg
;
548 if (copy_from_user(&umsg
, p
+ i
, sizeof(umsg
))) {
552 rdwr_pa
[i
] = (struct i2c_msg
) {
556 .buf
= compat_ptr(umsg
.buf
)
560 return i2cdev_ioctl_rdwr(client
, rdwr_arg
.nmsgs
, rdwr_pa
);
563 struct i2c_smbus_ioctl_data32 data32
;
564 if (copy_from_user(&data32
,
568 return i2cdev_ioctl_smbus(client
, data32
.read_write
,
571 compat_ptr(data32
.data
));
574 return i2cdev_ioctl(file
, cmd
, arg
);
578 #define compat_i2cdev_ioctl NULL
581 static int i2cdev_open(struct inode
*inode
, struct file
*file
)
583 unsigned int minor
= iminor(inode
);
584 struct i2c_client
*client
;
585 struct i2c_adapter
*adap
;
587 adap
= i2c_get_adapter(minor
);
591 /* This creates an anonymous i2c_client, which may later be
592 * pointed to some address using I2C_SLAVE or I2C_SLAVE_FORCE.
594 * This client is ** NEVER REGISTERED ** with the driver model
595 * or I2C core code!! It just holds private copies of addressing
596 * information and maybe a PEC flag.
598 client
= kzalloc(sizeof(*client
), GFP_KERNEL
);
600 i2c_put_adapter(adap
);
603 snprintf(client
->name
, I2C_NAME_SIZE
, "i2c-dev %d", adap
->nr
);
605 client
->adapter
= adap
;
606 file
->private_data
= client
;
611 static int i2cdev_release(struct inode
*inode
, struct file
*file
)
613 struct i2c_client
*client
= file
->private_data
;
615 i2c_put_adapter(client
->adapter
);
617 file
->private_data
= NULL
;
622 static const struct file_operations i2cdev_fops
= {
623 .owner
= THIS_MODULE
,
626 .write
= i2cdev_write
,
627 .unlocked_ioctl
= i2cdev_ioctl
,
628 .compat_ioctl
= compat_i2cdev_ioctl
,
630 .release
= i2cdev_release
,
633 /* ------------------------------------------------------------------------- */
635 static struct class *i2c_dev_class
;
637 static int i2cdev_attach_adapter(struct device
*dev
, void *dummy
)
639 struct i2c_adapter
*adap
;
640 struct i2c_dev
*i2c_dev
;
643 if (dev
->type
!= &i2c_adapter_type
)
645 adap
= to_i2c_adapter(dev
);
647 i2c_dev
= get_free_i2c_dev(adap
);
649 return PTR_ERR(i2c_dev
);
651 cdev_init(&i2c_dev
->cdev
, &i2cdev_fops
);
652 i2c_dev
->cdev
.owner
= THIS_MODULE
;
653 res
= cdev_add(&i2c_dev
->cdev
, MKDEV(I2C_MAJOR
, adap
->nr
), 1);
657 /* register this i2c device with the driver core */
658 i2c_dev
->dev
= device_create(i2c_dev_class
, &adap
->dev
,
659 MKDEV(I2C_MAJOR
, adap
->nr
), NULL
,
661 if (IS_ERR(i2c_dev
->dev
)) {
662 res
= PTR_ERR(i2c_dev
->dev
);
666 pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",
667 adap
->name
, adap
->nr
);
670 cdev_del(&i2c_dev
->cdev
);
672 put_i2c_dev(i2c_dev
);
676 static int i2cdev_detach_adapter(struct device
*dev
, void *dummy
)
678 struct i2c_adapter
*adap
;
679 struct i2c_dev
*i2c_dev
;
681 if (dev
->type
!= &i2c_adapter_type
)
683 adap
= to_i2c_adapter(dev
);
685 i2c_dev
= i2c_dev_get_by_minor(adap
->nr
);
686 if (!i2c_dev
) /* attach_adapter must have failed */
689 cdev_del(&i2c_dev
->cdev
);
690 put_i2c_dev(i2c_dev
);
691 device_destroy(i2c_dev_class
, MKDEV(I2C_MAJOR
, adap
->nr
));
693 pr_debug("i2c-dev: adapter [%s] unregistered\n", adap
->name
);
697 static int i2cdev_notifier_call(struct notifier_block
*nb
, unsigned long action
,
700 struct device
*dev
= data
;
703 case BUS_NOTIFY_ADD_DEVICE
:
704 return i2cdev_attach_adapter(dev
, NULL
);
705 case BUS_NOTIFY_DEL_DEVICE
:
706 return i2cdev_detach_adapter(dev
, NULL
);
712 static struct notifier_block i2cdev_notifier
= {
713 .notifier_call
= i2cdev_notifier_call
,
716 /* ------------------------------------------------------------------------- */
719 * module load/unload record keeping
722 static int __init
i2c_dev_init(void)
726 printk(KERN_INFO
"i2c /dev entries driver\n");
728 res
= register_chrdev_region(MKDEV(I2C_MAJOR
, 0), I2C_MINORS
, "i2c");
732 i2c_dev_class
= class_create(THIS_MODULE
, "i2c-dev");
733 if (IS_ERR(i2c_dev_class
)) {
734 res
= PTR_ERR(i2c_dev_class
);
735 goto out_unreg_chrdev
;
737 i2c_dev_class
->dev_groups
= i2c_groups
;
739 /* Keep track of adapters which will be added or removed later */
740 res
= bus_register_notifier(&i2c_bus_type
, &i2cdev_notifier
);
742 goto out_unreg_class
;
744 /* Bind to already existing adapters right away */
745 i2c_for_each_dev(NULL
, i2cdev_attach_adapter
);
750 class_destroy(i2c_dev_class
);
752 unregister_chrdev_region(MKDEV(I2C_MAJOR
, 0), I2C_MINORS
);
754 printk(KERN_ERR
"%s: Driver Initialisation failed\n", __FILE__
);
758 static void __exit
i2c_dev_exit(void)
760 bus_unregister_notifier(&i2c_bus_type
, &i2cdev_notifier
);
761 i2c_for_each_dev(NULL
, i2cdev_detach_adapter
);
762 class_destroy(i2c_dev_class
);
763 unregister_chrdev_region(MKDEV(I2C_MAJOR
, 0), I2C_MINORS
);
766 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
767 "Simon G. Vogl <simon@tk.uni-linz.ac.at>");
768 MODULE_DESCRIPTION("I2C /dev entries driver");
769 MODULE_LICENSE("GPL");
771 module_init(i2c_dev_init
);
772 module_exit(i2c_dev_exit
);