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.
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.
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 */
27 /* The I2C_RDWR ioctl code is written by Kolja Waschk <waschk@telos.de> */
29 #include <linux/kernel.h>
30 #include <linux/module.h>
32 #include <linux/slab.h>
33 #include <linux/init.h>
34 #include <linux/list.h>
35 #include <linux/i2c.h>
36 #include <linux/i2c-dev.h>
37 #include <linux/jiffies.h>
38 #include <linux/uaccess.h>
40 static struct i2c_driver i2cdev_driver
;
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.
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.
52 struct list_head list
;
53 struct i2c_adapter
*adap
;
57 #define I2C_MINORS 256
58 static LIST_HEAD(i2c_dev_list
);
59 static DEFINE_SPINLOCK(i2c_dev_list_lock
);
61 static struct i2c_dev
*i2c_dev_get_by_minor(unsigned index
)
63 struct i2c_dev
*i2c_dev
;
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
)
72 spin_unlock(&i2c_dev_list_lock
);
76 static struct i2c_dev
*get_free_i2c_dev(struct i2c_adapter
*adap
)
78 struct i2c_dev
*i2c_dev
;
80 if (adap
->nr
>= I2C_MINORS
) {
81 printk(KERN_ERR
"i2c-dev: Out of device minors (%d)\n",
83 return ERR_PTR(-ENODEV
);
86 i2c_dev
= kzalloc(sizeof(*i2c_dev
), GFP_KERNEL
);
88 return ERR_PTR(-ENOMEM
);
91 spin_lock(&i2c_dev_list_lock
);
92 list_add_tail(&i2c_dev
->list
, &i2c_dev_list
);
93 spin_unlock(&i2c_dev_list_lock
);
97 static void return_i2c_dev(struct i2c_dev
*i2c_dev
)
99 spin_lock(&i2c_dev_list_lock
);
100 list_del(&i2c_dev
->list
);
101 spin_unlock(&i2c_dev_list_lock
);
105 static ssize_t
show_adapter_name(struct device
*dev
,
106 struct device_attribute
*attr
, char *buf
)
108 struct i2c_dev
*i2c_dev
= i2c_dev_get_by_minor(MINOR(dev
->devt
));
112 return sprintf(buf
, "%s\n", i2c_dev
->adap
->name
);
114 static DEVICE_ATTR(name
, S_IRUGO
, show_adapter_name
, NULL
);
116 /* ------------------------------------------------------------------------- */
119 * After opening an instance of this character special file, a file
120 * descriptor starts out associated only with an i2c_adapter (and bus).
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.
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.
135 static ssize_t
i2cdev_read(struct file
*file
, char __user
*buf
, size_t count
,
141 struct i2c_client
*client
= file
->private_data
;
146 tmp
= kmalloc(count
, GFP_KERNEL
);
150 pr_debug("i2c-dev: i2c-%d reading %zu bytes.\n",
151 iminor(file
->f_path
.dentry
->d_inode
), count
);
153 ret
= i2c_master_recv(client
, tmp
, count
);
155 ret
= copy_to_user(buf
, tmp
, count
) ? -EFAULT
: ret
;
160 static ssize_t
i2cdev_write(struct file
*file
, const char __user
*buf
,
161 size_t count
, loff_t
*offset
)
165 struct i2c_client
*client
= file
->private_data
;
170 tmp
= memdup_user(buf
, count
);
174 pr_debug("i2c-dev: i2c-%d writing %zu bytes.\n",
175 iminor(file
->f_path
.dentry
->d_inode
), count
);
177 ret
= i2c_master_send(client
, tmp
, count
);
182 static int i2cdev_check(struct device
*dev
, void *addrp
)
184 struct i2c_client
*client
= i2c_verify_client(dev
);
186 if (!client
|| client
->addr
!= *(unsigned int *)addrp
)
189 return dev
->driver
? -EBUSY
: 0;
192 /* walk up mux tree */
193 static int i2cdev_check_mux_parents(struct i2c_adapter
*adapter
, int addr
)
197 result
= device_for_each_child(&adapter
->dev
, &addr
, i2cdev_check
);
199 if (!result
&& i2c_parent_is_i2c_adapter(adapter
))
200 result
= i2cdev_check_mux_parents(
201 to_i2c_adapter(adapter
->dev
.parent
), addr
);
206 /* recurse down mux tree */
207 static int i2cdev_check_mux_children(struct device
*dev
, void *addrp
)
211 if (dev
->type
== &i2c_adapter_type
)
212 result
= device_for_each_child(dev
, addrp
,
213 i2cdev_check_mux_children
);
215 result
= i2cdev_check(dev
, addrp
);
220 /* This address checking function differs from the one in i2c-core
221 in that it considers an address with a registered device, but no
222 driver bound to it, as NOT busy. */
223 static int i2cdev_check_addr(struct i2c_adapter
*adapter
, unsigned int addr
)
227 if (i2c_parent_is_i2c_adapter(adapter
))
228 result
= i2cdev_check_mux_parents(
229 to_i2c_adapter(adapter
->dev
.parent
), addr
);
232 result
= device_for_each_child(&adapter
->dev
, &addr
,
233 i2cdev_check_mux_children
);
238 static noinline
int i2cdev_ioctl_rdrw(struct i2c_client
*client
,
241 struct i2c_rdwr_ioctl_data rdwr_arg
;
242 struct i2c_msg
*rdwr_pa
;
243 u8 __user
**data_ptrs
;
246 if (copy_from_user(&rdwr_arg
,
247 (struct i2c_rdwr_ioctl_data __user
*)arg
,
251 /* Put an arbitrary limit on the number of messages that can
253 if (rdwr_arg
.nmsgs
> I2C_RDRW_IOCTL_MAX_MSGS
)
256 rdwr_pa
= kmalloc(rdwr_arg
.nmsgs
* sizeof(struct i2c_msg
), GFP_KERNEL
);
260 if (copy_from_user(rdwr_pa
, rdwr_arg
.msgs
,
261 rdwr_arg
.nmsgs
* sizeof(struct i2c_msg
))) {
266 data_ptrs
= kmalloc(rdwr_arg
.nmsgs
* sizeof(u8 __user
*), GFP_KERNEL
);
267 if (data_ptrs
== NULL
) {
273 for (i
= 0; i
< rdwr_arg
.nmsgs
; i
++) {
274 /* Limit the size of the message to a sane amount;
275 * and don't let length change either. */
276 if ((rdwr_pa
[i
].len
> 8192) ||
277 (rdwr_pa
[i
].flags
& I2C_M_RECV_LEN
)) {
281 data_ptrs
[i
] = (u8 __user
*)rdwr_pa
[i
].buf
;
282 rdwr_pa
[i
].buf
= memdup_user(data_ptrs
[i
], rdwr_pa
[i
].len
);
283 if (IS_ERR(rdwr_pa
[i
].buf
)) {
284 res
= PTR_ERR(rdwr_pa
[i
].buf
);
290 for (j
= 0; j
< i
; ++j
)
291 kfree(rdwr_pa
[j
].buf
);
297 res
= i2c_transfer(client
->adapter
, rdwr_pa
, rdwr_arg
.nmsgs
);
299 if (res
>= 0 && (rdwr_pa
[i
].flags
& I2C_M_RD
)) {
300 if (copy_to_user(data_ptrs
[i
], rdwr_pa
[i
].buf
,
304 kfree(rdwr_pa
[i
].buf
);
311 static noinline
int i2cdev_ioctl_smbus(struct i2c_client
*client
,
314 struct i2c_smbus_ioctl_data data_arg
;
315 union i2c_smbus_data temp
;
318 if (copy_from_user(&data_arg
,
319 (struct i2c_smbus_ioctl_data __user
*) arg
,
320 sizeof(struct i2c_smbus_ioctl_data
)))
322 if ((data_arg
.size
!= I2C_SMBUS_BYTE
) &&
323 (data_arg
.size
!= I2C_SMBUS_QUICK
) &&
324 (data_arg
.size
!= I2C_SMBUS_BYTE_DATA
) &&
325 (data_arg
.size
!= I2C_SMBUS_WORD_DATA
) &&
326 (data_arg
.size
!= I2C_SMBUS_PROC_CALL
) &&
327 (data_arg
.size
!= I2C_SMBUS_BLOCK_DATA
) &&
328 (data_arg
.size
!= I2C_SMBUS_I2C_BLOCK_BROKEN
) &&
329 (data_arg
.size
!= I2C_SMBUS_I2C_BLOCK_DATA
) &&
330 (data_arg
.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 ((data_arg
.read_write
!= I2C_SMBUS_READ
) &&
339 (data_arg
.read_write
!= I2C_SMBUS_WRITE
)) {
340 dev_dbg(&client
->adapter
->dev
,
341 "read_write out of range (%x) in ioctl I2C_SMBUS.\n",
342 data_arg
.read_write
);
346 /* Note that command values are always valid! */
348 if ((data_arg
.size
== I2C_SMBUS_QUICK
) ||
349 ((data_arg
.size
== I2C_SMBUS_BYTE
) &&
350 (data_arg
.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
, data_arg
.read_write
,
354 data_arg
.command
, data_arg
.size
, NULL
);
356 if (data_arg
.data
== NULL
) {
357 dev_dbg(&client
->adapter
->dev
,
358 "data is NULL pointer in ioctl I2C_SMBUS.\n");
362 if ((data_arg
.size
== I2C_SMBUS_BYTE_DATA
) ||
363 (data_arg
.size
== I2C_SMBUS_BYTE
))
364 datasize
= sizeof(data_arg
.data
->byte
);
365 else if ((data_arg
.size
== I2C_SMBUS_WORD_DATA
) ||
366 (data_arg
.size
== I2C_SMBUS_PROC_CALL
))
367 datasize
= sizeof(data_arg
.data
->word
);
368 else /* size == smbus block, i2c block, or block proc. call */
369 datasize
= sizeof(data_arg
.data
->block
);
371 if ((data_arg
.size
== I2C_SMBUS_PROC_CALL
) ||
372 (data_arg
.size
== I2C_SMBUS_BLOCK_PROC_CALL
) ||
373 (data_arg
.size
== I2C_SMBUS_I2C_BLOCK_DATA
) ||
374 (data_arg
.read_write
== I2C_SMBUS_WRITE
)) {
375 if (copy_from_user(&temp
, data_arg
.data
, datasize
))
378 if (data_arg
.size
== I2C_SMBUS_I2C_BLOCK_BROKEN
) {
379 /* Convert old I2C block commands to the new
380 convention. This preserves binary compatibility. */
381 data_arg
.size
= I2C_SMBUS_I2C_BLOCK_DATA
;
382 if (data_arg
.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 data_arg
.read_write
, data_arg
.command
, data_arg
.size
, &temp
);
387 if (!res
&& ((data_arg
.size
== I2C_SMBUS_PROC_CALL
) ||
388 (data_arg
.size
== I2C_SMBUS_BLOCK_PROC_CALL
) ||
389 (data_arg
.read_write
== I2C_SMBUS_READ
))) {
390 if (copy_to_user(data_arg
.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
:
407 /* NOTE: devices set up to work with "new style" drivers
408 * can't use I2C_SLAVE, even when the device node is not
409 * bound to a driver. Only I2C_SLAVE_FORCE will work.
411 * Setting the PEC flag here won't affect kernel drivers,
412 * which will be using the i2c_client node registered with
413 * the driver model core. Likewise, when that client has
414 * the PEC flag already set, the i2c-dev driver won't see
415 * (or use) this setting.
418 (((client
->flags
& I2C_M_TEN
) == 0) && arg
> 0x7f))
420 if (cmd
== I2C_SLAVE
&& i2cdev_check_addr(client
->adapter
, arg
))
422 /* REVISIT: address could become busy later */
427 client
->flags
|= I2C_M_TEN
;
429 client
->flags
&= ~I2C_M_TEN
;
433 client
->flags
|= I2C_CLIENT_PEC
;
435 client
->flags
&= ~I2C_CLIENT_PEC
;
438 funcs
= i2c_get_functionality(client
->adapter
);
439 return put_user(funcs
, (unsigned long __user
*)arg
);
442 return i2cdev_ioctl_rdrw(client
, arg
);
445 return i2cdev_ioctl_smbus(client
, arg
);
448 client
->adapter
->retries
= arg
;
451 /* For historical reasons, user-space sets the timeout
452 * value in units of 10 ms.
454 client
->adapter
->timeout
= msecs_to_jiffies(arg
* 10);
457 /* NOTE: returning a fault code here could cause trouble
458 * in buggy userspace code. Some old kernel bugs returned
459 * zero in this case, and userspace code might accidentally
460 * have depended on that bug.
467 static int i2cdev_open(struct inode
*inode
, struct file
*file
)
469 unsigned int minor
= iminor(inode
);
470 struct i2c_client
*client
;
471 struct i2c_adapter
*adap
;
472 struct i2c_dev
*i2c_dev
;
474 i2c_dev
= i2c_dev_get_by_minor(minor
);
478 adap
= i2c_get_adapter(i2c_dev
->adap
->nr
);
482 /* This creates an anonymous i2c_client, which may later be
483 * pointed to some address using I2C_SLAVE or I2C_SLAVE_FORCE.
485 * This client is ** NEVER REGISTERED ** with the driver model
486 * or I2C core code!! It just holds private copies of addressing
487 * information and maybe a PEC flag.
489 client
= kzalloc(sizeof(*client
), GFP_KERNEL
);
491 i2c_put_adapter(adap
);
494 snprintf(client
->name
, I2C_NAME_SIZE
, "i2c-dev %d", adap
->nr
);
495 client
->driver
= &i2cdev_driver
;
497 client
->adapter
= adap
;
498 file
->private_data
= client
;
503 static int i2cdev_release(struct inode
*inode
, struct file
*file
)
505 struct i2c_client
*client
= file
->private_data
;
507 i2c_put_adapter(client
->adapter
);
509 file
->private_data
= NULL
;
514 static const struct file_operations i2cdev_fops
= {
515 .owner
= THIS_MODULE
,
518 .write
= i2cdev_write
,
519 .unlocked_ioctl
= i2cdev_ioctl
,
521 .release
= i2cdev_release
,
524 /* ------------------------------------------------------------------------- */
527 * The legacy "i2cdev_driver" is used primarily to get notifications when
528 * I2C adapters are added or removed, so that each one gets an i2c_dev
529 * and is thus made available to userspace driver code.
532 static struct class *i2c_dev_class
;
534 static int i2cdev_attach_adapter(struct i2c_adapter
*adap
)
536 struct i2c_dev
*i2c_dev
;
539 i2c_dev
= get_free_i2c_dev(adap
);
541 return PTR_ERR(i2c_dev
);
543 /* register this i2c device with the driver core */
544 i2c_dev
->dev
= device_create(i2c_dev_class
, &adap
->dev
,
545 MKDEV(I2C_MAJOR
, adap
->nr
), NULL
,
547 if (IS_ERR(i2c_dev
->dev
)) {
548 res
= PTR_ERR(i2c_dev
->dev
);
551 res
= device_create_file(i2c_dev
->dev
, &dev_attr_name
);
555 pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",
556 adap
->name
, adap
->nr
);
559 device_destroy(i2c_dev_class
, MKDEV(I2C_MAJOR
, adap
->nr
));
561 return_i2c_dev(i2c_dev
);
565 static int i2cdev_detach_adapter(struct i2c_adapter
*adap
)
567 struct i2c_dev
*i2c_dev
;
569 i2c_dev
= i2c_dev_get_by_minor(adap
->nr
);
570 if (!i2c_dev
) /* attach_adapter must have failed */
573 device_remove_file(i2c_dev
->dev
, &dev_attr_name
);
574 return_i2c_dev(i2c_dev
);
575 device_destroy(i2c_dev_class
, MKDEV(I2C_MAJOR
, adap
->nr
));
577 pr_debug("i2c-dev: adapter [%s] unregistered\n", adap
->name
);
581 static struct i2c_driver i2cdev_driver
= {
583 .name
= "dev_driver",
585 .attach_adapter
= i2cdev_attach_adapter
,
586 .detach_adapter
= i2cdev_detach_adapter
,
589 /* ------------------------------------------------------------------------- */
592 * module load/unload record keeping
595 static int __init
i2c_dev_init(void)
599 printk(KERN_INFO
"i2c /dev entries driver\n");
601 res
= register_chrdev(I2C_MAJOR
, "i2c", &i2cdev_fops
);
605 i2c_dev_class
= class_create(THIS_MODULE
, "i2c-dev");
606 if (IS_ERR(i2c_dev_class
)) {
607 res
= PTR_ERR(i2c_dev_class
);
608 goto out_unreg_chrdev
;
611 res
= i2c_add_driver(&i2cdev_driver
);
613 goto out_unreg_class
;
618 class_destroy(i2c_dev_class
);
620 unregister_chrdev(I2C_MAJOR
, "i2c");
622 printk(KERN_ERR
"%s: Driver Initialisation failed\n", __FILE__
);
626 static void __exit
i2c_dev_exit(void)
628 i2c_del_driver(&i2cdev_driver
);
629 class_destroy(i2c_dev_class
);
630 unregister_chrdev(I2C_MAJOR
, "i2c");
633 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
634 "Simon G. Vogl <simon@tk.uni-linz.ac.at>");
635 MODULE_DESCRIPTION("I2C /dev entries driver");
636 MODULE_LICENSE("GPL");
638 module_init(i2c_dev_init
);
639 module_exit(i2c_dev_exit
);