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/smp_lock.h>
38 #include <asm/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
= (struct i2c_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
, size_t count
,
165 struct i2c_client
*client
= (struct i2c_client
*)file
->private_data
;
170 tmp
= kmalloc(count
,GFP_KERNEL
);
173 if (copy_from_user(tmp
,buf
,count
)) {
178 pr_debug("i2c-dev: i2c-%d writing %zu bytes.\n",
179 iminor(file
->f_path
.dentry
->d_inode
), 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 /* This address checking function differs from the one in i2c-core
197 in that it considers an address with a registered device, but no
198 driver bound to it, as NOT busy. */
199 static int i2cdev_check_addr(struct i2c_adapter
*adapter
, unsigned int addr
)
201 return device_for_each_child(&adapter
->dev
, &addr
, i2cdev_check
);
204 static noinline
int i2cdev_ioctl_rdrw(struct i2c_client
*client
,
207 struct i2c_rdwr_ioctl_data rdwr_arg
;
208 struct i2c_msg
*rdwr_pa
;
209 u8 __user
**data_ptrs
;
212 if (copy_from_user(&rdwr_arg
,
213 (struct i2c_rdwr_ioctl_data __user
*)arg
,
217 /* Put an arbitrary limit on the number of messages that can
219 if (rdwr_arg
.nmsgs
> I2C_RDRW_IOCTL_MAX_MSGS
)
222 rdwr_pa
= (struct i2c_msg
*)
223 kmalloc(rdwr_arg
.nmsgs
* sizeof(struct i2c_msg
),
228 if (copy_from_user(rdwr_pa
, rdwr_arg
.msgs
,
229 rdwr_arg
.nmsgs
* sizeof(struct i2c_msg
))) {
234 data_ptrs
= kmalloc(rdwr_arg
.nmsgs
* sizeof(u8 __user
*), GFP_KERNEL
);
235 if (data_ptrs
== NULL
) {
241 for (i
= 0; i
< rdwr_arg
.nmsgs
; i
++) {
242 /* Limit the size of the message to a sane amount;
243 * and don't let length change either. */
244 if ((rdwr_pa
[i
].len
> 8192) ||
245 (rdwr_pa
[i
].flags
& I2C_M_RECV_LEN
)) {
249 data_ptrs
[i
] = (u8 __user
*)rdwr_pa
[i
].buf
;
250 rdwr_pa
[i
].buf
= kmalloc(rdwr_pa
[i
].len
, GFP_KERNEL
);
251 if (rdwr_pa
[i
].buf
== NULL
) {
255 if (copy_from_user(rdwr_pa
[i
].buf
, data_ptrs
[i
],
257 ++i
; /* Needs to be kfreed too */
264 for (j
= 0; j
< i
; ++j
)
265 kfree(rdwr_pa
[j
].buf
);
271 res
= i2c_transfer(client
->adapter
, rdwr_pa
, rdwr_arg
.nmsgs
);
273 if (res
>= 0 && (rdwr_pa
[i
].flags
& I2C_M_RD
)) {
274 if (copy_to_user(data_ptrs
[i
], rdwr_pa
[i
].buf
,
278 kfree(rdwr_pa
[i
].buf
);
285 static noinline
int i2cdev_ioctl_smbus(struct i2c_client
*client
,
288 struct i2c_smbus_ioctl_data data_arg
;
289 union i2c_smbus_data temp
;
292 if (copy_from_user(&data_arg
,
293 (struct i2c_smbus_ioctl_data __user
*) arg
,
294 sizeof(struct i2c_smbus_ioctl_data
)))
296 if ((data_arg
.size
!= I2C_SMBUS_BYTE
) &&
297 (data_arg
.size
!= I2C_SMBUS_QUICK
) &&
298 (data_arg
.size
!= I2C_SMBUS_BYTE_DATA
) &&
299 (data_arg
.size
!= I2C_SMBUS_WORD_DATA
) &&
300 (data_arg
.size
!= I2C_SMBUS_PROC_CALL
) &&
301 (data_arg
.size
!= I2C_SMBUS_BLOCK_DATA
) &&
302 (data_arg
.size
!= I2C_SMBUS_I2C_BLOCK_BROKEN
) &&
303 (data_arg
.size
!= I2C_SMBUS_I2C_BLOCK_DATA
) &&
304 (data_arg
.size
!= I2C_SMBUS_BLOCK_PROC_CALL
)) {
305 dev_dbg(&client
->adapter
->dev
,
306 "size out of range (%x) in ioctl I2C_SMBUS.\n",
310 /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
311 so the check is valid if size==I2C_SMBUS_QUICK too. */
312 if ((data_arg
.read_write
!= I2C_SMBUS_READ
) &&
313 (data_arg
.read_write
!= I2C_SMBUS_WRITE
)) {
314 dev_dbg(&client
->adapter
->dev
,
315 "read_write out of range (%x) in ioctl I2C_SMBUS.\n",
316 data_arg
.read_write
);
320 /* Note that command values are always valid! */
322 if ((data_arg
.size
== I2C_SMBUS_QUICK
) ||
323 ((data_arg
.size
== I2C_SMBUS_BYTE
) &&
324 (data_arg
.read_write
== I2C_SMBUS_WRITE
)))
325 /* These are special: we do not use data */
326 return i2c_smbus_xfer(client
->adapter
, client
->addr
,
327 client
->flags
, data_arg
.read_write
,
328 data_arg
.command
, data_arg
.size
, NULL
);
330 if (data_arg
.data
== NULL
) {
331 dev_dbg(&client
->adapter
->dev
,
332 "data is NULL pointer in ioctl I2C_SMBUS.\n");
336 if ((data_arg
.size
== I2C_SMBUS_BYTE_DATA
) ||
337 (data_arg
.size
== I2C_SMBUS_BYTE
))
338 datasize
= sizeof(data_arg
.data
->byte
);
339 else if ((data_arg
.size
== I2C_SMBUS_WORD_DATA
) ||
340 (data_arg
.size
== I2C_SMBUS_PROC_CALL
))
341 datasize
= sizeof(data_arg
.data
->word
);
342 else /* size == smbus block, i2c block, or block proc. call */
343 datasize
= sizeof(data_arg
.data
->block
);
345 if ((data_arg
.size
== I2C_SMBUS_PROC_CALL
) ||
346 (data_arg
.size
== I2C_SMBUS_BLOCK_PROC_CALL
) ||
347 (data_arg
.size
== I2C_SMBUS_I2C_BLOCK_DATA
) ||
348 (data_arg
.read_write
== I2C_SMBUS_WRITE
)) {
349 if (copy_from_user(&temp
, data_arg
.data
, datasize
))
352 if (data_arg
.size
== I2C_SMBUS_I2C_BLOCK_BROKEN
) {
353 /* Convert old I2C block commands to the new
354 convention. This preserves binary compatibility. */
355 data_arg
.size
= I2C_SMBUS_I2C_BLOCK_DATA
;
356 if (data_arg
.read_write
== I2C_SMBUS_READ
)
357 temp
.block
[0] = I2C_SMBUS_BLOCK_MAX
;
359 res
= i2c_smbus_xfer(client
->adapter
, client
->addr
, client
->flags
,
360 data_arg
.read_write
, data_arg
.command
, data_arg
.size
, &temp
);
361 if (!res
&& ((data_arg
.size
== I2C_SMBUS_PROC_CALL
) ||
362 (data_arg
.size
== I2C_SMBUS_BLOCK_PROC_CALL
) ||
363 (data_arg
.read_write
== I2C_SMBUS_READ
))) {
364 if (copy_to_user(data_arg
.data
, &temp
, datasize
))
370 static long i2cdev_ioctl(struct file
*file
, unsigned int cmd
, unsigned long arg
)
372 struct i2c_client
*client
= (struct i2c_client
*)file
->private_data
;
375 dev_dbg(&client
->adapter
->dev
, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
380 case I2C_SLAVE_FORCE
:
381 /* NOTE: devices set up to work with "new style" drivers
382 * can't use I2C_SLAVE, even when the device node is not
383 * bound to a driver. Only I2C_SLAVE_FORCE will work.
385 * Setting the PEC flag here won't affect kernel drivers,
386 * which will be using the i2c_client node registered with
387 * the driver model core. Likewise, when that client has
388 * the PEC flag already set, the i2c-dev driver won't see
389 * (or use) this setting.
392 (((client
->flags
& I2C_M_TEN
) == 0) && arg
> 0x7f))
394 if (cmd
== I2C_SLAVE
&& i2cdev_check_addr(client
->adapter
, arg
))
396 /* REVISIT: address could become busy later */
401 client
->flags
|= I2C_M_TEN
;
403 client
->flags
&= ~I2C_M_TEN
;
407 client
->flags
|= I2C_CLIENT_PEC
;
409 client
->flags
&= ~I2C_CLIENT_PEC
;
412 funcs
= i2c_get_functionality(client
->adapter
);
413 return put_user(funcs
, (unsigned long __user
*)arg
);
416 return i2cdev_ioctl_rdrw(client
, arg
);
419 return i2cdev_ioctl_smbus(client
, arg
);
422 client
->adapter
->retries
= arg
;
425 client
->adapter
->timeout
= arg
;
428 /* NOTE: returning a fault code here could cause trouble
429 * in buggy userspace code. Some old kernel bugs returned
430 * zero in this case, and userspace code might accidentally
431 * have depended on that bug.
438 static int i2cdev_open(struct inode
*inode
, struct file
*file
)
440 unsigned int minor
= iminor(inode
);
441 struct i2c_client
*client
;
442 struct i2c_adapter
*adap
;
443 struct i2c_dev
*i2c_dev
;
447 i2c_dev
= i2c_dev_get_by_minor(minor
);
453 adap
= i2c_get_adapter(i2c_dev
->adap
->nr
);
459 /* This creates an anonymous i2c_client, which may later be
460 * pointed to some address using I2C_SLAVE or I2C_SLAVE_FORCE.
462 * This client is ** NEVER REGISTERED ** with the driver model
463 * or I2C core code!! It just holds private copies of addressing
464 * information and maybe a PEC flag.
466 client
= kzalloc(sizeof(*client
), GFP_KERNEL
);
468 i2c_put_adapter(adap
);
472 snprintf(client
->name
, I2C_NAME_SIZE
, "i2c-dev %d", adap
->nr
);
473 client
->driver
= &i2cdev_driver
;
475 client
->adapter
= adap
;
476 file
->private_data
= client
;
483 static int i2cdev_release(struct inode
*inode
, struct file
*file
)
485 struct i2c_client
*client
= file
->private_data
;
487 i2c_put_adapter(client
->adapter
);
489 file
->private_data
= NULL
;
494 static const struct file_operations i2cdev_fops
= {
495 .owner
= THIS_MODULE
,
498 .write
= i2cdev_write
,
499 .unlocked_ioctl
= i2cdev_ioctl
,
501 .release
= i2cdev_release
,
504 /* ------------------------------------------------------------------------- */
507 * The legacy "i2cdev_driver" is used primarily to get notifications when
508 * I2C adapters are added or removed, so that each one gets an i2c_dev
509 * and is thus made available to userspace driver code.
512 static struct class *i2c_dev_class
;
514 static int i2cdev_attach_adapter(struct i2c_adapter
*adap
)
516 struct i2c_dev
*i2c_dev
;
519 i2c_dev
= get_free_i2c_dev(adap
);
521 return PTR_ERR(i2c_dev
);
523 /* register this i2c device with the driver core */
524 i2c_dev
->dev
= device_create(i2c_dev_class
, &adap
->dev
,
525 MKDEV(I2C_MAJOR
, adap
->nr
), NULL
,
527 if (IS_ERR(i2c_dev
->dev
)) {
528 res
= PTR_ERR(i2c_dev
->dev
);
531 res
= device_create_file(i2c_dev
->dev
, &dev_attr_name
);
535 pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",
536 adap
->name
, adap
->nr
);
539 device_destroy(i2c_dev_class
, MKDEV(I2C_MAJOR
, adap
->nr
));
541 return_i2c_dev(i2c_dev
);
545 static int i2cdev_detach_adapter(struct i2c_adapter
*adap
)
547 struct i2c_dev
*i2c_dev
;
549 i2c_dev
= i2c_dev_get_by_minor(adap
->nr
);
550 if (!i2c_dev
) /* attach_adapter must have failed */
553 device_remove_file(i2c_dev
->dev
, &dev_attr_name
);
554 return_i2c_dev(i2c_dev
);
555 device_destroy(i2c_dev_class
, MKDEV(I2C_MAJOR
, adap
->nr
));
557 pr_debug("i2c-dev: adapter [%s] unregistered\n", adap
->name
);
561 static struct i2c_driver i2cdev_driver
= {
563 .name
= "dev_driver",
565 .attach_adapter
= i2cdev_attach_adapter
,
566 .detach_adapter
= i2cdev_detach_adapter
,
569 /* ------------------------------------------------------------------------- */
572 * module load/unload record keeping
575 static int __init
i2c_dev_init(void)
579 printk(KERN_INFO
"i2c /dev entries driver\n");
581 res
= register_chrdev(I2C_MAJOR
, "i2c", &i2cdev_fops
);
585 i2c_dev_class
= class_create(THIS_MODULE
, "i2c-dev");
586 if (IS_ERR(i2c_dev_class
)) {
587 res
= PTR_ERR(i2c_dev_class
);
588 goto out_unreg_chrdev
;
591 res
= i2c_add_driver(&i2cdev_driver
);
593 goto out_unreg_class
;
598 class_destroy(i2c_dev_class
);
600 unregister_chrdev(I2C_MAJOR
, "i2c");
602 printk(KERN_ERR
"%s: Driver Initialisation failed\n", __FILE__
);
606 static void __exit
i2c_dev_exit(void)
608 i2c_del_driver(&i2cdev_driver
);
609 class_destroy(i2c_dev_class
);
610 unregister_chrdev(I2C_MAJOR
,"i2c");
613 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
614 "Simon G. Vogl <simon@tk.uni-linz.ac.at>");
615 MODULE_DESCRIPTION("I2C /dev entries driver");
616 MODULE_LICENSE("GPL");
618 module_init(i2c_dev_init
);
619 module_exit(i2c_dev_exit
);