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/smp_lock.h>
34 #include <linux/init.h>
35 #include <linux/i2c.h>
36 #include <linux/i2c-dev.h>
37 #include <linux/platform_device.h>
38 #include <asm/uaccess.h>
40 static struct i2c_client i2cdev_client_template
;
44 struct i2c_adapter
*adap
;
45 struct class_device
*class_dev
;
47 #define to_i2c_dev(d) container_of(d, struct i2c_dev, class_dev)
49 #define I2C_MINORS 256
50 static struct i2c_dev
*i2c_dev_array
[I2C_MINORS
];
51 static DEFINE_SPINLOCK(i2c_dev_array_lock
);
53 static struct i2c_dev
*i2c_dev_get_by_minor(unsigned index
)
55 struct i2c_dev
*i2c_dev
;
57 spin_lock(&i2c_dev_array_lock
);
58 i2c_dev
= i2c_dev_array
[index
];
59 spin_unlock(&i2c_dev_array_lock
);
63 static struct i2c_dev
*i2c_dev_get_by_adapter(struct i2c_adapter
*adap
)
65 struct i2c_dev
*i2c_dev
= NULL
;
67 spin_lock(&i2c_dev_array_lock
);
68 if ((i2c_dev_array
[adap
->nr
]) &&
69 (i2c_dev_array
[adap
->nr
]->adap
== adap
))
70 i2c_dev
= i2c_dev_array
[adap
->nr
];
71 spin_unlock(&i2c_dev_array_lock
);
75 static struct i2c_dev
*get_free_i2c_dev(struct i2c_adapter
*adap
)
77 struct i2c_dev
*i2c_dev
;
79 i2c_dev
= kzalloc(sizeof(*i2c_dev
), GFP_KERNEL
);
81 return ERR_PTR(-ENOMEM
);
83 spin_lock(&i2c_dev_array_lock
);
84 if (i2c_dev_array
[adap
->nr
]) {
85 spin_unlock(&i2c_dev_array_lock
);
86 dev_err(&adap
->dev
, "i2c-dev already has a device assigned to this adapter\n");
89 i2c_dev
->minor
= adap
->nr
;
90 i2c_dev_array
[adap
->nr
] = i2c_dev
;
91 spin_unlock(&i2c_dev_array_lock
);
95 return ERR_PTR(-ENODEV
);
98 static void return_i2c_dev(struct i2c_dev
*i2c_dev
)
100 spin_lock(&i2c_dev_array_lock
);
101 i2c_dev_array
[i2c_dev
->minor
] = NULL
;
102 spin_unlock(&i2c_dev_array_lock
);
105 static ssize_t
show_adapter_name(struct class_device
*class_dev
, char *buf
)
107 struct i2c_dev
*i2c_dev
= i2c_dev_get_by_minor(MINOR(class_dev
->devt
));
111 return sprintf(buf
, "%s\n", i2c_dev
->adap
->name
);
113 static CLASS_DEVICE_ATTR(name
, S_IRUGO
, show_adapter_name
, NULL
);
115 static ssize_t
i2cdev_read (struct file
*file
, char __user
*buf
, size_t count
,
121 struct i2c_client
*client
= (struct i2c_client
*)file
->private_data
;
126 tmp
= kmalloc(count
,GFP_KERNEL
);
130 pr_debug("i2c-dev: i2c-%d reading %zd bytes.\n",
131 iminor(file
->f_dentry
->d_inode
), count
);
133 ret
= i2c_master_recv(client
,tmp
,count
);
135 ret
= copy_to_user(buf
,tmp
,count
)?-EFAULT
:ret
;
140 static ssize_t
i2cdev_write (struct file
*file
, const char __user
*buf
, size_t count
,
145 struct i2c_client
*client
= (struct i2c_client
*)file
->private_data
;
150 tmp
= kmalloc(count
,GFP_KERNEL
);
153 if (copy_from_user(tmp
,buf
,count
)) {
158 pr_debug("i2c-dev: i2c-%d writing %zd bytes.\n",
159 iminor(file
->f_dentry
->d_inode
), count
);
161 ret
= i2c_master_send(client
,tmp
,count
);
166 static int i2cdev_ioctl(struct inode
*inode
, struct file
*file
,
167 unsigned int cmd
, unsigned long arg
)
169 struct i2c_client
*client
= (struct i2c_client
*)file
->private_data
;
170 struct i2c_rdwr_ioctl_data rdwr_arg
;
171 struct i2c_smbus_ioctl_data data_arg
;
172 union i2c_smbus_data temp
;
173 struct i2c_msg
*rdwr_pa
;
174 u8 __user
**data_ptrs
;
178 dev_dbg(&client
->adapter
->dev
, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
183 case I2C_SLAVE_FORCE
:
185 (((client
->flags
& I2C_M_TEN
) == 0) && arg
> 0x7f))
187 if ((cmd
== I2C_SLAVE
) && i2c_check_addr(client
->adapter
,arg
))
193 client
->flags
|= I2C_M_TEN
;
195 client
->flags
&= ~I2C_M_TEN
;
199 client
->flags
|= I2C_CLIENT_PEC
;
201 client
->flags
&= ~I2C_CLIENT_PEC
;
204 funcs
= i2c_get_functionality(client
->adapter
);
205 return (copy_to_user((unsigned long __user
*)arg
, &funcs
,
206 sizeof(unsigned long)))?-EFAULT
:0;
209 if (copy_from_user(&rdwr_arg
,
210 (struct i2c_rdwr_ioctl_data __user
*)arg
,
214 /* Put an arbitrary limit on the number of messages that can
216 if (rdwr_arg
.nmsgs
> I2C_RDRW_IOCTL_MAX_MSGS
)
219 rdwr_pa
= (struct i2c_msg
*)
220 kmalloc(rdwr_arg
.nmsgs
* sizeof(struct i2c_msg
),
223 if (rdwr_pa
== NULL
) return -ENOMEM
;
225 if (copy_from_user(rdwr_pa
, rdwr_arg
.msgs
,
226 rdwr_arg
.nmsgs
* sizeof(struct i2c_msg
))) {
231 data_ptrs
= kmalloc(rdwr_arg
.nmsgs
* sizeof(u8 __user
*), GFP_KERNEL
);
232 if (data_ptrs
== NULL
) {
238 for( i
=0; i
<rdwr_arg
.nmsgs
; i
++ ) {
239 /* Limit the size of the message to a sane amount */
240 if (rdwr_pa
[i
].len
> 8192) {
244 data_ptrs
[i
] = (u8 __user
*)rdwr_pa
[i
].buf
;
245 rdwr_pa
[i
].buf
= kmalloc(rdwr_pa
[i
].len
, GFP_KERNEL
);
246 if(rdwr_pa
[i
].buf
== NULL
) {
250 if(copy_from_user(rdwr_pa
[i
].buf
,
253 ++i
; /* Needs to be kfreed too */
260 for (j
= 0; j
< i
; ++j
)
261 kfree(rdwr_pa
[j
].buf
);
267 res
= i2c_transfer(client
->adapter
,
271 if( res
>=0 && (rdwr_pa
[i
].flags
& I2C_M_RD
)) {
279 kfree(rdwr_pa
[i
].buf
);
286 if (copy_from_user(&data_arg
,
287 (struct i2c_smbus_ioctl_data __user
*) arg
,
288 sizeof(struct i2c_smbus_ioctl_data
)))
290 if ((data_arg
.size
!= I2C_SMBUS_BYTE
) &&
291 (data_arg
.size
!= I2C_SMBUS_QUICK
) &&
292 (data_arg
.size
!= I2C_SMBUS_BYTE_DATA
) &&
293 (data_arg
.size
!= I2C_SMBUS_WORD_DATA
) &&
294 (data_arg
.size
!= I2C_SMBUS_PROC_CALL
) &&
295 (data_arg
.size
!= I2C_SMBUS_BLOCK_DATA
) &&
296 (data_arg
.size
!= I2C_SMBUS_I2C_BLOCK_DATA
) &&
297 (data_arg
.size
!= I2C_SMBUS_BLOCK_PROC_CALL
)) {
298 dev_dbg(&client
->adapter
->dev
,
299 "size out of range (%x) in ioctl I2C_SMBUS.\n",
303 /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
304 so the check is valid if size==I2C_SMBUS_QUICK too. */
305 if ((data_arg
.read_write
!= I2C_SMBUS_READ
) &&
306 (data_arg
.read_write
!= I2C_SMBUS_WRITE
)) {
307 dev_dbg(&client
->adapter
->dev
,
308 "read_write out of range (%x) in ioctl I2C_SMBUS.\n",
309 data_arg
.read_write
);
313 /* Note that command values are always valid! */
315 if ((data_arg
.size
== I2C_SMBUS_QUICK
) ||
316 ((data_arg
.size
== I2C_SMBUS_BYTE
) &&
317 (data_arg
.read_write
== I2C_SMBUS_WRITE
)))
318 /* These are special: we do not use data */
319 return i2c_smbus_xfer(client
->adapter
, client
->addr
,
323 data_arg
.size
, NULL
);
325 if (data_arg
.data
== NULL
) {
326 dev_dbg(&client
->adapter
->dev
,
327 "data is NULL pointer in ioctl I2C_SMBUS.\n");
331 if ((data_arg
.size
== I2C_SMBUS_BYTE_DATA
) ||
332 (data_arg
.size
== I2C_SMBUS_BYTE
))
333 datasize
= sizeof(data_arg
.data
->byte
);
334 else if ((data_arg
.size
== I2C_SMBUS_WORD_DATA
) ||
335 (data_arg
.size
== I2C_SMBUS_PROC_CALL
))
336 datasize
= sizeof(data_arg
.data
->word
);
337 else /* size == smbus block, i2c block, or block proc. call */
338 datasize
= sizeof(data_arg
.data
->block
);
340 if ((data_arg
.size
== I2C_SMBUS_PROC_CALL
) ||
341 (data_arg
.size
== I2C_SMBUS_BLOCK_PROC_CALL
) ||
342 (data_arg
.read_write
== I2C_SMBUS_WRITE
)) {
343 if (copy_from_user(&temp
, data_arg
.data
, datasize
))
346 res
= i2c_smbus_xfer(client
->adapter
,client
->addr
,client
->flags
,
348 data_arg
.command
,data_arg
.size
,&temp
);
349 if (! res
&& ((data_arg
.size
== I2C_SMBUS_PROC_CALL
) ||
350 (data_arg
.size
== I2C_SMBUS_BLOCK_PROC_CALL
) ||
351 (data_arg
.read_write
== I2C_SMBUS_READ
))) {
352 if (copy_to_user(data_arg
.data
, &temp
, datasize
))
358 return i2c_control(client
,cmd
,arg
);
363 static int i2cdev_open(struct inode
*inode
, struct file
*file
)
365 unsigned int minor
= iminor(inode
);
366 struct i2c_client
*client
;
367 struct i2c_adapter
*adap
;
368 struct i2c_dev
*i2c_dev
;
370 i2c_dev
= i2c_dev_get_by_minor(minor
);
374 adap
= i2c_get_adapter(i2c_dev
->adap
->nr
);
378 client
= kmalloc(sizeof(*client
), GFP_KERNEL
);
380 i2c_put_adapter(adap
);
383 memcpy(client
, &i2cdev_client_template
, sizeof(*client
));
385 /* registered with adapter, passed as client to user */
386 client
->adapter
= adap
;
387 file
->private_data
= client
;
392 static int i2cdev_release(struct inode
*inode
, struct file
*file
)
394 struct i2c_client
*client
= file
->private_data
;
396 i2c_put_adapter(client
->adapter
);
398 file
->private_data
= NULL
;
403 static struct file_operations i2cdev_fops
= {
404 .owner
= THIS_MODULE
,
407 .write
= i2cdev_write
,
408 .ioctl
= i2cdev_ioctl
,
410 .release
= i2cdev_release
,
413 static struct class *i2c_dev_class
;
415 static int i2cdev_attach_adapter(struct i2c_adapter
*adap
)
417 struct i2c_dev
*i2c_dev
;
420 i2c_dev
= get_free_i2c_dev(adap
);
422 return PTR_ERR(i2c_dev
);
424 pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",
425 adap
->name
, i2c_dev
->minor
);
427 /* register this i2c device with the driver core */
428 i2c_dev
->adap
= adap
;
430 i2c_dev
->class_dev
= class_device_create(i2c_dev_class
, NULL
,
431 MKDEV(I2C_MAJOR
, i2c_dev
->minor
),
432 dev
, "i2c-%d", i2c_dev
->minor
);
433 if (!i2c_dev
->class_dev
)
435 class_device_create_file(i2c_dev
->class_dev
, &class_device_attr_name
);
438 return_i2c_dev(i2c_dev
);
443 static int i2cdev_detach_adapter(struct i2c_adapter
*adap
)
445 struct i2c_dev
*i2c_dev
;
447 i2c_dev
= i2c_dev_get_by_adapter(adap
);
451 return_i2c_dev(i2c_dev
);
452 class_device_destroy(i2c_dev_class
, MKDEV(I2C_MAJOR
, i2c_dev
->minor
));
455 pr_debug("i2c-dev: adapter [%s] unregistered\n", adap
->name
);
459 static int i2cdev_detach_client(struct i2c_client
*client
)
464 static struct i2c_driver i2cdev_driver
= {
466 .name
= "dev_driver",
468 .id
= I2C_DRIVERID_I2CDEV
,
469 .attach_adapter
= i2cdev_attach_adapter
,
470 .detach_adapter
= i2cdev_detach_adapter
,
471 .detach_client
= i2cdev_detach_client
,
474 static struct i2c_client i2cdev_client_template
= {
475 .name
= "I2C /dev entry",
477 .driver
= &i2cdev_driver
,
480 static int __init
i2c_dev_init(void)
484 printk(KERN_INFO
"i2c /dev entries driver\n");
486 res
= register_chrdev(I2C_MAJOR
, "i2c", &i2cdev_fops
);
490 i2c_dev_class
= class_create(THIS_MODULE
, "i2c-dev");
491 if (IS_ERR(i2c_dev_class
))
492 goto out_unreg_chrdev
;
494 res
= i2c_add_driver(&i2cdev_driver
);
496 goto out_unreg_class
;
501 class_destroy(i2c_dev_class
);
503 unregister_chrdev(I2C_MAJOR
, "i2c");
505 printk(KERN_ERR
"%s: Driver Initialisation failed\n", __FILE__
);
509 static void __exit
i2c_dev_exit(void)
511 i2c_del_driver(&i2cdev_driver
);
512 class_destroy(i2c_dev_class
);
513 unregister_chrdev(I2C_MAJOR
,"i2c");
516 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
517 "Simon G. Vogl <simon@tk.uni-linz.ac.at>");
518 MODULE_DESCRIPTION("I2C /dev entries driver");
519 MODULE_LICENSE("GPL");
521 module_init(i2c_dev_init
);
522 module_exit(i2c_dev_exit
);