blob: 3f869033ed70cd212c6a99a6d54f4b615abfbed1 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 i2c-dev.c - i2c-bus driver, char device interface
3
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>
7
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.
12
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.
17
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.
21*/
22
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 */
26
27/* The I2C_RDWR ioctl code is written by Kolja Waschk <waschk@telos.de> */
28
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include <linux/kernel.h>
30#include <linux/module.h>
31#include <linux/fs.h>
32#include <linux/slab.h>
33#include <linux/smp_lock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/init.h>
Jean Delvaref3b3aad2006-07-01 17:17:38 +020035#include <linux/list.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/i2c.h>
37#include <linux/i2c-dev.h>
38#include <asm/uaccess.h>
39
Jean Delvare22f76e72006-07-01 17:20:57 +020040static struct i2c_driver i2cdev_driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -070041
42struct i2c_dev {
Jean Delvaref3b3aad2006-07-01 17:17:38 +020043 struct list_head list;
Linus Torvalds1da177e2005-04-16 15:20:36 -070044 struct i2c_adapter *adap;
Greg Kroah-Hartman794721322005-12-06 15:33:15 -080045 struct class_device *class_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070046};
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
48#define I2C_MINORS 256
Jean Delvaref3b3aad2006-07-01 17:17:38 +020049static LIST_HEAD(i2c_dev_list);
50static DEFINE_SPINLOCK(i2c_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
52static struct i2c_dev *i2c_dev_get_by_minor(unsigned index)
53{
54 struct i2c_dev *i2c_dev;
55
Jean Delvaref3b3aad2006-07-01 17:17:38 +020056 spin_lock(&i2c_dev_list_lock);
57 list_for_each_entry(i2c_dev, &i2c_dev_list, list) {
58 if (i2c_dev->adap->nr == index)
59 goto found;
60 }
61 i2c_dev = NULL;
62found:
63 spin_unlock(&i2c_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 return i2c_dev;
65}
66
Linus Torvalds1da177e2005-04-16 15:20:36 -070067static struct i2c_dev *get_free_i2c_dev(struct i2c_adapter *adap)
68{
69 struct i2c_dev *i2c_dev;
70
Jean Delvaref3b3aad2006-07-01 17:17:38 +020071 if (adap->nr >= I2C_MINORS) {
72 printk(KERN_ERR "i2c-dev: Out of device minors (%d)\n",
73 adap->nr);
74 return ERR_PTR(-ENODEV);
75 }
76
Deepak Saxena5263ebb2005-10-17 23:09:43 +020077 i2c_dev = kzalloc(sizeof(*i2c_dev), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -070078 if (!i2c_dev)
79 return ERR_PTR(-ENOMEM);
Jean Delvare9455e4c2006-07-01 17:16:57 +020080 i2c_dev->adap = adap;
Jean Delvaref3b3aad2006-07-01 17:17:38 +020081
82 spin_lock(&i2c_dev_list_lock);
83 list_add_tail(&i2c_dev->list, &i2c_dev_list);
84 spin_unlock(&i2c_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070085 return i2c_dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -070086}
87
88static void return_i2c_dev(struct i2c_dev *i2c_dev)
89{
Jean Delvaref3b3aad2006-07-01 17:17:38 +020090 spin_lock(&i2c_dev_list_lock);
91 list_del(&i2c_dev->list);
92 spin_unlock(&i2c_dev_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -070093}
94
95static ssize_t show_adapter_name(struct class_device *class_dev, char *buf)
96{
Greg Kroah-Hartman794721322005-12-06 15:33:15 -080097 struct i2c_dev *i2c_dev = i2c_dev_get_by_minor(MINOR(class_dev->devt));
98
99 if (!i2c_dev)
100 return -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700101 return sprintf(buf, "%s\n", i2c_dev->adap->name);
102}
103static CLASS_DEVICE_ATTR(name, S_IRUGO, show_adapter_name, NULL);
104
105static ssize_t i2cdev_read (struct file *file, char __user *buf, size_t count,
106 loff_t *offset)
107{
108 char *tmp;
109 int ret;
110
111 struct i2c_client *client = (struct i2c_client *)file->private_data;
112
113 if (count > 8192)
114 count = 8192;
115
116 tmp = kmalloc(count,GFP_KERNEL);
117 if (tmp==NULL)
118 return -ENOMEM;
119
120 pr_debug("i2c-dev: i2c-%d reading %zd bytes.\n",
121 iminor(file->f_dentry->d_inode), count);
122
123 ret = i2c_master_recv(client,tmp,count);
124 if (ret >= 0)
125 ret = copy_to_user(buf,tmp,count)?-EFAULT:ret;
126 kfree(tmp);
127 return ret;
128}
129
130static ssize_t i2cdev_write (struct file *file, const char __user *buf, size_t count,
131 loff_t *offset)
132{
133 int ret;
134 char *tmp;
135 struct i2c_client *client = (struct i2c_client *)file->private_data;
136
137 if (count > 8192)
138 count = 8192;
139
140 tmp = kmalloc(count,GFP_KERNEL);
141 if (tmp==NULL)
142 return -ENOMEM;
143 if (copy_from_user(tmp,buf,count)) {
144 kfree(tmp);
145 return -EFAULT;
146 }
147
148 pr_debug("i2c-dev: i2c-%d writing %zd bytes.\n",
149 iminor(file->f_dentry->d_inode), count);
150
151 ret = i2c_master_send(client,tmp,count);
152 kfree(tmp);
153 return ret;
154}
155
156static int i2cdev_ioctl(struct inode *inode, struct file *file,
157 unsigned int cmd, unsigned long arg)
158{
159 struct i2c_client *client = (struct i2c_client *)file->private_data;
160 struct i2c_rdwr_ioctl_data rdwr_arg;
161 struct i2c_smbus_ioctl_data data_arg;
162 union i2c_smbus_data temp;
163 struct i2c_msg *rdwr_pa;
164 u8 __user **data_ptrs;
165 int i,datasize,res;
166 unsigned long funcs;
167
Jean Delvaree8aafcb2005-10-07 23:06:27 +0200168 dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
169 cmd, arg);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700170
171 switch ( cmd ) {
172 case I2C_SLAVE:
173 case I2C_SLAVE_FORCE:
174 if ((arg > 0x3ff) ||
175 (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
176 return -EINVAL;
177 if ((cmd == I2C_SLAVE) && i2c_check_addr(client->adapter,arg))
178 return -EBUSY;
179 client->addr = arg;
180 return 0;
181 case I2C_TENBIT:
182 if (arg)
183 client->flags |= I2C_M_TEN;
184 else
185 client->flags &= ~I2C_M_TEN;
186 return 0;
187 case I2C_PEC:
188 if (arg)
189 client->flags |= I2C_CLIENT_PEC;
190 else
191 client->flags &= ~I2C_CLIENT_PEC;
192 return 0;
193 case I2C_FUNCS:
194 funcs = i2c_get_functionality(client->adapter);
195 return (copy_to_user((unsigned long __user *)arg, &funcs,
196 sizeof(unsigned long)))?-EFAULT:0;
197
198 case I2C_RDWR:
199 if (copy_from_user(&rdwr_arg,
200 (struct i2c_rdwr_ioctl_data __user *)arg,
201 sizeof(rdwr_arg)))
202 return -EFAULT;
203
Tobias Klauserd68a8612005-05-19 21:41:47 +0200204 /* Put an arbitrary limit on the number of messages that can
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 * be sent at once */
206 if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
207 return -EINVAL;
208
209 rdwr_pa = (struct i2c_msg *)
210 kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg),
211 GFP_KERNEL);
212
213 if (rdwr_pa == NULL) return -ENOMEM;
214
215 if (copy_from_user(rdwr_pa, rdwr_arg.msgs,
216 rdwr_arg.nmsgs * sizeof(struct i2c_msg))) {
217 kfree(rdwr_pa);
218 return -EFAULT;
219 }
220
221 data_ptrs = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL);
222 if (data_ptrs == NULL) {
223 kfree(rdwr_pa);
224 return -ENOMEM;
225 }
226
227 res = 0;
228 for( i=0; i<rdwr_arg.nmsgs; i++ ) {
229 /* Limit the size of the message to a sane amount */
230 if (rdwr_pa[i].len > 8192) {
231 res = -EINVAL;
232 break;
233 }
234 data_ptrs[i] = (u8 __user *)rdwr_pa[i].buf;
235 rdwr_pa[i].buf = kmalloc(rdwr_pa[i].len, GFP_KERNEL);
236 if(rdwr_pa[i].buf == NULL) {
237 res = -ENOMEM;
238 break;
239 }
240 if(copy_from_user(rdwr_pa[i].buf,
241 data_ptrs[i],
242 rdwr_pa[i].len)) {
243 ++i; /* Needs to be kfreed too */
244 res = -EFAULT;
245 break;
246 }
247 }
248 if (res < 0) {
249 int j;
250 for (j = 0; j < i; ++j)
251 kfree(rdwr_pa[j].buf);
252 kfree(data_ptrs);
253 kfree(rdwr_pa);
254 return res;
255 }
256
257 res = i2c_transfer(client->adapter,
258 rdwr_pa,
259 rdwr_arg.nmsgs);
260 while(i-- > 0) {
261 if( res>=0 && (rdwr_pa[i].flags & I2C_M_RD)) {
262 if(copy_to_user(
263 data_ptrs[i],
264 rdwr_pa[i].buf,
265 rdwr_pa[i].len)) {
266 res = -EFAULT;
267 }
268 }
269 kfree(rdwr_pa[i].buf);
270 }
271 kfree(data_ptrs);
272 kfree(rdwr_pa);
273 return res;
274
275 case I2C_SMBUS:
276 if (copy_from_user(&data_arg,
277 (struct i2c_smbus_ioctl_data __user *) arg,
278 sizeof(struct i2c_smbus_ioctl_data)))
279 return -EFAULT;
280 if ((data_arg.size != I2C_SMBUS_BYTE) &&
281 (data_arg.size != I2C_SMBUS_QUICK) &&
282 (data_arg.size != I2C_SMBUS_BYTE_DATA) &&
283 (data_arg.size != I2C_SMBUS_WORD_DATA) &&
284 (data_arg.size != I2C_SMBUS_PROC_CALL) &&
285 (data_arg.size != I2C_SMBUS_BLOCK_DATA) &&
286 (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA) &&
287 (data_arg.size != I2C_SMBUS_BLOCK_PROC_CALL)) {
288 dev_dbg(&client->adapter->dev,
289 "size out of range (%x) in ioctl I2C_SMBUS.\n",
290 data_arg.size);
291 return -EINVAL;
292 }
293 /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
294 so the check is valid if size==I2C_SMBUS_QUICK too. */
295 if ((data_arg.read_write != I2C_SMBUS_READ) &&
296 (data_arg.read_write != I2C_SMBUS_WRITE)) {
297 dev_dbg(&client->adapter->dev,
298 "read_write out of range (%x) in ioctl I2C_SMBUS.\n",
299 data_arg.read_write);
300 return -EINVAL;
301 }
302
303 /* Note that command values are always valid! */
304
305 if ((data_arg.size == I2C_SMBUS_QUICK) ||
306 ((data_arg.size == I2C_SMBUS_BYTE) &&
307 (data_arg.read_write == I2C_SMBUS_WRITE)))
308 /* These are special: we do not use data */
309 return i2c_smbus_xfer(client->adapter, client->addr,
310 client->flags,
311 data_arg.read_write,
312 data_arg.command,
313 data_arg.size, NULL);
314
315 if (data_arg.data == NULL) {
316 dev_dbg(&client->adapter->dev,
317 "data is NULL pointer in ioctl I2C_SMBUS.\n");
318 return -EINVAL;
319 }
320
321 if ((data_arg.size == I2C_SMBUS_BYTE_DATA) ||
322 (data_arg.size == I2C_SMBUS_BYTE))
323 datasize = sizeof(data_arg.data->byte);
324 else if ((data_arg.size == I2C_SMBUS_WORD_DATA) ||
325 (data_arg.size == I2C_SMBUS_PROC_CALL))
326 datasize = sizeof(data_arg.data->word);
327 else /* size == smbus block, i2c block, or block proc. call */
328 datasize = sizeof(data_arg.data->block);
329
330 if ((data_arg.size == I2C_SMBUS_PROC_CALL) ||
331 (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) ||
332 (data_arg.read_write == I2C_SMBUS_WRITE)) {
333 if (copy_from_user(&temp, data_arg.data, datasize))
334 return -EFAULT;
335 }
336 res = i2c_smbus_xfer(client->adapter,client->addr,client->flags,
337 data_arg.read_write,
338 data_arg.command,data_arg.size,&temp);
339 if (! res && ((data_arg.size == I2C_SMBUS_PROC_CALL) ||
340 (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) ||
341 (data_arg.read_write == I2C_SMBUS_READ))) {
342 if (copy_to_user(data_arg.data, &temp, datasize))
343 return -EFAULT;
344 }
345 return res;
346
347 default:
348 return i2c_control(client,cmd,arg);
349 }
350 return 0;
351}
352
353static int i2cdev_open(struct inode *inode, struct file *file)
354{
355 unsigned int minor = iminor(inode);
356 struct i2c_client *client;
357 struct i2c_adapter *adap;
358 struct i2c_dev *i2c_dev;
359
360 i2c_dev = i2c_dev_get_by_minor(minor);
361 if (!i2c_dev)
362 return -ENODEV;
363
364 adap = i2c_get_adapter(i2c_dev->adap->nr);
365 if (!adap)
366 return -ENODEV;
367
Jean Delvare22f76e72006-07-01 17:20:57 +0200368 client = kzalloc(sizeof(*client), GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 if (!client) {
370 i2c_put_adapter(adap);
371 return -ENOMEM;
372 }
Jean Delvare22f76e72006-07-01 17:20:57 +0200373 snprintf(client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr);
374 client->driver = &i2cdev_driver;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375
376 /* registered with adapter, passed as client to user */
377 client->adapter = adap;
378 file->private_data = client;
379
380 return 0;
381}
382
383static int i2cdev_release(struct inode *inode, struct file *file)
384{
385 struct i2c_client *client = file->private_data;
386
387 i2c_put_adapter(client->adapter);
388 kfree(client);
389 file->private_data = NULL;
390
391 return 0;
392}
393
394static struct file_operations i2cdev_fops = {
395 .owner = THIS_MODULE,
396 .llseek = no_llseek,
397 .read = i2cdev_read,
398 .write = i2cdev_write,
399 .ioctl = i2cdev_ioctl,
400 .open = i2cdev_open,
401 .release = i2cdev_release,
402};
403
Greg Kroah-Hartman794721322005-12-06 15:33:15 -0800404static struct class *i2c_dev_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405
406static int i2cdev_attach_adapter(struct i2c_adapter *adap)
407{
408 struct i2c_dev *i2c_dev;
Jean Delvaredefcb462006-08-15 18:30:24 +0200409 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410
411 i2c_dev = get_free_i2c_dev(adap);
412 if (IS_ERR(i2c_dev))
413 return PTR_ERR(i2c_dev);
414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 /* register this i2c device with the driver core */
Greg Kroah-Hartman794721322005-12-06 15:33:15 -0800416 i2c_dev->class_dev = class_device_create(i2c_dev_class, NULL,
Jean Delvare9455e4c2006-07-01 17:16:57 +0200417 MKDEV(I2C_MAJOR, adap->nr),
418 &adap->dev, "i2c-%d",
419 adap->nr);
Jean Delvaredefcb462006-08-15 18:30:24 +0200420 if (!i2c_dev->class_dev) {
421 res = -ENODEV;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700422 goto error;
Jean Delvaredefcb462006-08-15 18:30:24 +0200423 }
424 res = class_device_create_file(i2c_dev->class_dev, &class_device_attr_name);
425 if (res)
426 goto error_destroy;
Jean Delvareb32d20d2006-09-03 22:19:25 +0200427
428 pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",
429 adap->name, adap->nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430 return 0;
Jean Delvaredefcb462006-08-15 18:30:24 +0200431error_destroy:
432 class_device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433error:
434 return_i2c_dev(i2c_dev);
435 kfree(i2c_dev);
Jean Delvaredefcb462006-08-15 18:30:24 +0200436 return res;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437}
438
439static int i2cdev_detach_adapter(struct i2c_adapter *adap)
440{
441 struct i2c_dev *i2c_dev;
442
Jean Delvare9455e4c2006-07-01 17:16:57 +0200443 i2c_dev = i2c_dev_get_by_minor(adap->nr);
Jean Delvareb32d20d2006-09-03 22:19:25 +0200444 if (!i2c_dev) /* attach_adapter must have failed */
445 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446
Jean Delvaredefcb462006-08-15 18:30:24 +0200447 class_device_remove_file(i2c_dev->class_dev, &class_device_attr_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 return_i2c_dev(i2c_dev);
Jean Delvare9455e4c2006-07-01 17:16:57 +0200449 class_device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 kfree(i2c_dev);
451
Jean Delvareb6d7b3d2005-07-31 19:02:53 +0200452 pr_debug("i2c-dev: adapter [%s] unregistered\n", adap->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700453 return 0;
454}
455
456static int i2cdev_detach_client(struct i2c_client *client)
457{
458 return 0;
459}
460
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461static struct i2c_driver i2cdev_driver = {
Laurent Riffard35d8b2e2005-11-26 20:34:05 +0100462 .driver = {
Laurent Riffard35d8b2e2005-11-26 20:34:05 +0100463 .name = "dev_driver",
464 },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 .id = I2C_DRIVERID_I2CDEV,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 .attach_adapter = i2cdev_attach_adapter,
467 .detach_adapter = i2cdev_detach_adapter,
468 .detach_client = i2cdev_detach_client,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469};
470
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471static int __init i2c_dev_init(void)
472{
473 int res;
474
475 printk(KERN_INFO "i2c /dev entries driver\n");
476
477 res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);
478 if (res)
479 goto out;
480
Greg Kroah-Hartman794721322005-12-06 15:33:15 -0800481 i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");
482 if (IS_ERR(i2c_dev_class))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 goto out_unreg_chrdev;
484
485 res = i2c_add_driver(&i2cdev_driver);
486 if (res)
487 goto out_unreg_class;
488
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 return 0;
490
491out_unreg_class:
Greg Kroah-Hartman794721322005-12-06 15:33:15 -0800492 class_destroy(i2c_dev_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493out_unreg_chrdev:
494 unregister_chrdev(I2C_MAJOR, "i2c");
495out:
496 printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
497 return res;
498}
499
500static void __exit i2c_dev_exit(void)
501{
502 i2c_del_driver(&i2cdev_driver);
Greg Kroah-Hartman794721322005-12-06 15:33:15 -0800503 class_destroy(i2c_dev_class);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 unregister_chrdev(I2C_MAJOR,"i2c");
505}
506
507MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
508 "Simon G. Vogl <simon@tk.uni-linz.ac.at>");
509MODULE_DESCRIPTION("I2C /dev entries driver");
510MODULE_LICENSE("GPL");
511
512module_init(i2c_dev_init);
513module_exit(i2c_dev_exit);