Merge branch 'fb' into devel
[linux-2.6] / drivers / i2c / i2c-dev.c
1 /*
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
29 #include <linux/kernel.h>
30 #include <linux/module.h>
31 #include <linux/fs.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 <asm/uaccess.h>
38
39 static struct i2c_driver i2cdev_driver;
40
41 /*
42  * An i2c_dev represents an i2c_adapter ... an I2C or SMBus master, not a
43  * slave (i2c_client) with which messages will be exchanged.  It's coupled
44  * with a character special file which is accessed by user mode drivers.
45  *
46  * The list of i2c_dev structures is parallel to the i2c_adapter lists
47  * maintained by the driver model, and is updated using notifications
48  * delivered to the i2cdev_driver.
49  */
50 struct i2c_dev {
51         struct list_head list;
52         struct i2c_adapter *adap;
53         struct device *dev;
54 };
55
56 #define I2C_MINORS      256
57 static LIST_HEAD(i2c_dev_list);
58 static DEFINE_SPINLOCK(i2c_dev_list_lock);
59
60 static struct i2c_dev *i2c_dev_get_by_minor(unsigned index)
61 {
62         struct i2c_dev *i2c_dev;
63
64         spin_lock(&i2c_dev_list_lock);
65         list_for_each_entry(i2c_dev, &i2c_dev_list, list) {
66                 if (i2c_dev->adap->nr == index)
67                         goto found;
68         }
69         i2c_dev = NULL;
70 found:
71         spin_unlock(&i2c_dev_list_lock);
72         return i2c_dev;
73 }
74
75 static struct i2c_dev *get_free_i2c_dev(struct i2c_adapter *adap)
76 {
77         struct i2c_dev *i2c_dev;
78
79         if (adap->nr >= I2C_MINORS) {
80                 printk(KERN_ERR "i2c-dev: Out of device minors (%d)\n",
81                        adap->nr);
82                 return ERR_PTR(-ENODEV);
83         }
84
85         i2c_dev = kzalloc(sizeof(*i2c_dev), GFP_KERNEL);
86         if (!i2c_dev)
87                 return ERR_PTR(-ENOMEM);
88         i2c_dev->adap = adap;
89
90         spin_lock(&i2c_dev_list_lock);
91         list_add_tail(&i2c_dev->list, &i2c_dev_list);
92         spin_unlock(&i2c_dev_list_lock);
93         return i2c_dev;
94 }
95
96 static void return_i2c_dev(struct i2c_dev *i2c_dev)
97 {
98         spin_lock(&i2c_dev_list_lock);
99         list_del(&i2c_dev->list);
100         spin_unlock(&i2c_dev_list_lock);
101         kfree(i2c_dev);
102 }
103
104 static ssize_t show_adapter_name(struct device *dev,
105                                  struct device_attribute *attr, char *buf)
106 {
107         struct i2c_dev *i2c_dev = i2c_dev_get_by_minor(MINOR(dev->devt));
108
109         if (!i2c_dev)
110                 return -ENODEV;
111         return sprintf(buf, "%s\n", i2c_dev->adap->name);
112 }
113 static DEVICE_ATTR(name, S_IRUGO, show_adapter_name, NULL);
114
115 /* ------------------------------------------------------------------------- */
116
117 /*
118  * After opening an instance of this character special file, a file
119  * descriptor starts out associated only with an i2c_adapter (and bus).
120  *
121  * Using the I2C_RDWR ioctl(), you can then *immediately* issue i2c_msg
122  * traffic to any devices on the bus used by that adapter.  That's because
123  * the i2c_msg vectors embed all the addressing information they need, and
124  * are submitted directly to an i2c_adapter.  However, SMBus-only adapters
125  * don't support that interface.
126  *
127  * To use read()/write() system calls on that file descriptor, or to use
128  * SMBus interfaces (and work with SMBus-only hosts!), you must first issue
129  * an I2C_SLAVE (or I2C_SLAVE_FORCE) ioctl.  That configures an anonymous
130  * (never registered) i2c_client so it holds the addressing information
131  * needed by those system calls and by this SMBus interface.
132  */
133
134 static ssize_t i2cdev_read (struct file *file, char __user *buf, size_t count,
135                             loff_t *offset)
136 {
137         char *tmp;
138         int ret;
139
140         struct i2c_client *client = (struct i2c_client *)file->private_data;
141
142         if (count > 8192)
143                 count = 8192;
144
145         tmp = kmalloc(count,GFP_KERNEL);
146         if (tmp==NULL)
147                 return -ENOMEM;
148
149         pr_debug("i2c-dev: i2c-%d reading %zd bytes.\n",
150                 iminor(file->f_path.dentry->d_inode), count);
151
152         ret = i2c_master_recv(client,tmp,count);
153         if (ret >= 0)
154                 ret = copy_to_user(buf,tmp,count)?-EFAULT:ret;
155         kfree(tmp);
156         return ret;
157 }
158
159 static ssize_t i2cdev_write (struct file *file, const char __user *buf, size_t count,
160                              loff_t *offset)
161 {
162         int ret;
163         char *tmp;
164         struct i2c_client *client = (struct i2c_client *)file->private_data;
165
166         if (count > 8192)
167                 count = 8192;
168
169         tmp = kmalloc(count,GFP_KERNEL);
170         if (tmp==NULL)
171                 return -ENOMEM;
172         if (copy_from_user(tmp,buf,count)) {
173                 kfree(tmp);
174                 return -EFAULT;
175         }
176
177         pr_debug("i2c-dev: i2c-%d writing %zd bytes.\n",
178                 iminor(file->f_path.dentry->d_inode), count);
179
180         ret = i2c_master_send(client,tmp,count);
181         kfree(tmp);
182         return ret;
183 }
184
185 static int i2cdev_check(struct device *dev, void *addrp)
186 {
187         struct i2c_client *client = i2c_verify_client(dev);
188
189         if (!client || client->addr != *(unsigned int *)addrp)
190                 return 0;
191
192         return dev->driver ? -EBUSY : 0;
193 }
194
195 /* This address checking function differs from the one in i2c-core
196    in that it considers an address with a registered device, but no
197    driver bound to it, as NOT busy. */
198 static int i2cdev_check_addr(struct i2c_adapter *adapter, unsigned int addr)
199 {
200         return device_for_each_child(&adapter->dev, &addr, i2cdev_check);
201 }
202
203 static noinline int i2cdev_ioctl_rdrw(struct i2c_client *client,
204                 unsigned long arg)
205 {
206         struct i2c_rdwr_ioctl_data rdwr_arg;
207         struct i2c_msg *rdwr_pa;
208         u8 __user **data_ptrs;
209         int i, res;
210
211         if (copy_from_user(&rdwr_arg,
212                            (struct i2c_rdwr_ioctl_data __user *)arg,
213                            sizeof(rdwr_arg)))
214                 return -EFAULT;
215
216         /* Put an arbitrary limit on the number of messages that can
217          * be sent at once */
218         if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
219                 return -EINVAL;
220
221         rdwr_pa = (struct i2c_msg *)
222                 kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg),
223                 GFP_KERNEL);
224         if (!rdwr_pa)
225                 return -ENOMEM;
226
227         if (copy_from_user(rdwr_pa, rdwr_arg.msgs,
228                            rdwr_arg.nmsgs * sizeof(struct i2c_msg))) {
229                 kfree(rdwr_pa);
230                 return -EFAULT;
231         }
232
233         data_ptrs = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL);
234         if (data_ptrs == NULL) {
235                 kfree(rdwr_pa);
236                 return -ENOMEM;
237         }
238
239         res = 0;
240         for (i = 0; i < rdwr_arg.nmsgs; i++) {
241                 /* Limit the size of the message to a sane amount;
242                  * and don't let length change either. */
243                 if ((rdwr_pa[i].len > 8192) ||
244                     (rdwr_pa[i].flags & I2C_M_RECV_LEN)) {
245                         res = -EINVAL;
246                         break;
247                 }
248                 data_ptrs[i] = (u8 __user *)rdwr_pa[i].buf;
249                 rdwr_pa[i].buf = kmalloc(rdwr_pa[i].len, GFP_KERNEL);
250                 if (rdwr_pa[i].buf == NULL) {
251                         res = -ENOMEM;
252                         break;
253                 }
254                 if (copy_from_user(rdwr_pa[i].buf, data_ptrs[i],
255                                    rdwr_pa[i].len)) {
256                                 ++i; /* Needs to be kfreed too */
257                                 res = -EFAULT;
258                         break;
259                 }
260         }
261         if (res < 0) {
262                 int j;
263                 for (j = 0; j < i; ++j)
264                         kfree(rdwr_pa[j].buf);
265                 kfree(data_ptrs);
266                 kfree(rdwr_pa);
267                 return res;
268         }
269
270         res = i2c_transfer(client->adapter, rdwr_pa, rdwr_arg.nmsgs);
271         while (i-- > 0) {
272                 if (res >= 0 && (rdwr_pa[i].flags & I2C_M_RD)) {
273                         if (copy_to_user(data_ptrs[i], rdwr_pa[i].buf,
274                                          rdwr_pa[i].len))
275                                 res = -EFAULT;
276                 }
277                 kfree(rdwr_pa[i].buf);
278         }
279         kfree(data_ptrs);
280         kfree(rdwr_pa);
281         return res;
282 }
283
284 static noinline int i2cdev_ioctl_smbus(struct i2c_client *client,
285                 unsigned long arg)
286 {
287         struct i2c_smbus_ioctl_data data_arg;
288         union i2c_smbus_data temp;
289         int datasize, res;
290
291         if (copy_from_user(&data_arg,
292                            (struct i2c_smbus_ioctl_data __user *) arg,
293                            sizeof(struct i2c_smbus_ioctl_data)))
294                 return -EFAULT;
295         if ((data_arg.size != I2C_SMBUS_BYTE) &&
296             (data_arg.size != I2C_SMBUS_QUICK) &&
297             (data_arg.size != I2C_SMBUS_BYTE_DATA) &&
298             (data_arg.size != I2C_SMBUS_WORD_DATA) &&
299             (data_arg.size != I2C_SMBUS_PROC_CALL) &&
300             (data_arg.size != I2C_SMBUS_BLOCK_DATA) &&
301             (data_arg.size != I2C_SMBUS_I2C_BLOCK_BROKEN) &&
302             (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA) &&
303             (data_arg.size != I2C_SMBUS_BLOCK_PROC_CALL)) {
304                 dev_dbg(&client->adapter->dev,
305                         "size out of range (%x) in ioctl I2C_SMBUS.\n",
306                         data_arg.size);
307                 return -EINVAL;
308         }
309         /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
310            so the check is valid if size==I2C_SMBUS_QUICK too. */
311         if ((data_arg.read_write != I2C_SMBUS_READ) &&
312             (data_arg.read_write != I2C_SMBUS_WRITE)) {
313                 dev_dbg(&client->adapter->dev,
314                         "read_write out of range (%x) in ioctl I2C_SMBUS.\n",
315                         data_arg.read_write);
316                 return -EINVAL;
317         }
318
319         /* Note that command values are always valid! */
320
321         if ((data_arg.size == I2C_SMBUS_QUICK) ||
322             ((data_arg.size == I2C_SMBUS_BYTE) &&
323             (data_arg.read_write == I2C_SMBUS_WRITE)))
324                 /* These are special: we do not use data */
325                 return i2c_smbus_xfer(client->adapter, client->addr,
326                                       client->flags, data_arg.read_write,
327                                       data_arg.command, data_arg.size, NULL);
328
329         if (data_arg.data == NULL) {
330                 dev_dbg(&client->adapter->dev,
331                         "data is NULL pointer in ioctl I2C_SMBUS.\n");
332                 return -EINVAL;
333         }
334
335         if ((data_arg.size == I2C_SMBUS_BYTE_DATA) ||
336             (data_arg.size == I2C_SMBUS_BYTE))
337                 datasize = sizeof(data_arg.data->byte);
338         else if ((data_arg.size == I2C_SMBUS_WORD_DATA) ||
339                  (data_arg.size == I2C_SMBUS_PROC_CALL))
340                 datasize = sizeof(data_arg.data->word);
341         else /* size == smbus block, i2c block, or block proc. call */
342                 datasize = sizeof(data_arg.data->block);
343
344         if ((data_arg.size == I2C_SMBUS_PROC_CALL) ||
345             (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) ||
346             (data_arg.size == I2C_SMBUS_I2C_BLOCK_DATA) ||
347             (data_arg.read_write == I2C_SMBUS_WRITE)) {
348                 if (copy_from_user(&temp, data_arg.data, datasize))
349                         return -EFAULT;
350         }
351         if (data_arg.size == I2C_SMBUS_I2C_BLOCK_BROKEN) {
352                 /* Convert old I2C block commands to the new
353                    convention. This preserves binary compatibility. */
354                 data_arg.size = I2C_SMBUS_I2C_BLOCK_DATA;
355                 if (data_arg.read_write == I2C_SMBUS_READ)
356                         temp.block[0] = I2C_SMBUS_BLOCK_MAX;
357         }
358         res = i2c_smbus_xfer(client->adapter, client->addr, client->flags,
359               data_arg.read_write, data_arg.command, data_arg.size, &temp);
360         if (!res && ((data_arg.size == I2C_SMBUS_PROC_CALL) ||
361                      (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) ||
362                      (data_arg.read_write == I2C_SMBUS_READ))) {
363                 if (copy_to_user(data_arg.data, &temp, datasize))
364                         return -EFAULT;
365         }
366         return res;
367 }
368
369 static int i2cdev_ioctl(struct inode *inode, struct file *file,
370                 unsigned int cmd, unsigned long arg)
371 {
372         struct i2c_client *client = (struct i2c_client *)file->private_data;
373         unsigned long funcs;
374
375         dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
376                 cmd, arg);
377
378         switch ( cmd ) {
379         case I2C_SLAVE:
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.
384                  *
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.
390                  */
391                 if ((arg > 0x3ff) ||
392                     (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
393                         return -EINVAL;
394                 if (cmd == I2C_SLAVE && i2cdev_check_addr(client->adapter, arg))
395                         return -EBUSY;
396                 /* REVISIT: address could become busy later */
397                 client->addr = arg;
398                 return 0;
399         case I2C_TENBIT:
400                 if (arg)
401                         client->flags |= I2C_M_TEN;
402                 else
403                         client->flags &= ~I2C_M_TEN;
404                 return 0;
405         case I2C_PEC:
406                 if (arg)
407                         client->flags |= I2C_CLIENT_PEC;
408                 else
409                         client->flags &= ~I2C_CLIENT_PEC;
410                 return 0;
411         case I2C_FUNCS:
412                 funcs = i2c_get_functionality(client->adapter);
413                 return put_user(funcs, (unsigned long __user *)arg);
414
415         case I2C_RDWR:
416                 return i2cdev_ioctl_rdrw(client, arg);
417
418         case I2C_SMBUS:
419                 return i2cdev_ioctl_smbus(client, arg);
420
421         case I2C_RETRIES:
422                 client->adapter->retries = arg;
423                 break;
424         case I2C_TIMEOUT:
425                 client->adapter->timeout = arg;
426                 break;
427         default:
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.
432                  */
433                 return -ENOTTY;
434         }
435         return 0;
436 }
437
438 static int i2cdev_open(struct inode *inode, struct file *file)
439 {
440         unsigned int minor = iminor(inode);
441         struct i2c_client *client;
442         struct i2c_adapter *adap;
443         struct i2c_dev *i2c_dev;
444
445         i2c_dev = i2c_dev_get_by_minor(minor);
446         if (!i2c_dev)
447                 return -ENODEV;
448
449         adap = i2c_get_adapter(i2c_dev->adap->nr);
450         if (!adap)
451                 return -ENODEV;
452
453         /* This creates an anonymous i2c_client, which may later be
454          * pointed to some address using I2C_SLAVE or I2C_SLAVE_FORCE.
455          *
456          * This client is ** NEVER REGISTERED ** with the driver model
457          * or I2C core code!!  It just holds private copies of addressing
458          * information and maybe a PEC flag.
459          */
460         client = kzalloc(sizeof(*client), GFP_KERNEL);
461         if (!client) {
462                 i2c_put_adapter(adap);
463                 return -ENOMEM;
464         }
465         snprintf(client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr);
466         client->driver = &i2cdev_driver;
467
468         client->adapter = adap;
469         file->private_data = client;
470
471         return 0;
472 }
473
474 static int i2cdev_release(struct inode *inode, struct file *file)
475 {
476         struct i2c_client *client = file->private_data;
477
478         i2c_put_adapter(client->adapter);
479         kfree(client);
480         file->private_data = NULL;
481
482         return 0;
483 }
484
485 static const struct file_operations i2cdev_fops = {
486         .owner          = THIS_MODULE,
487         .llseek         = no_llseek,
488         .read           = i2cdev_read,
489         .write          = i2cdev_write,
490         .ioctl          = i2cdev_ioctl,
491         .open           = i2cdev_open,
492         .release        = i2cdev_release,
493 };
494
495 /* ------------------------------------------------------------------------- */
496
497 /*
498  * The legacy "i2cdev_driver" is used primarily to get notifications when
499  * I2C adapters are added or removed, so that each one gets an i2c_dev
500  * and is thus made available to userspace driver code.
501  */
502
503 static struct class *i2c_dev_class;
504
505 static int i2cdev_attach_adapter(struct i2c_adapter *adap)
506 {
507         struct i2c_dev *i2c_dev;
508         int res;
509
510         i2c_dev = get_free_i2c_dev(adap);
511         if (IS_ERR(i2c_dev))
512                 return PTR_ERR(i2c_dev);
513
514         /* register this i2c device with the driver core */
515         i2c_dev->dev = device_create(i2c_dev_class, &adap->dev,
516                                      MKDEV(I2C_MAJOR, adap->nr),
517                                      "i2c-%d", adap->nr);
518         if (IS_ERR(i2c_dev->dev)) {
519                 res = PTR_ERR(i2c_dev->dev);
520                 goto error;
521         }
522         res = device_create_file(i2c_dev->dev, &dev_attr_name);
523         if (res)
524                 goto error_destroy;
525
526         pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",
527                  adap->name, adap->nr);
528         return 0;
529 error_destroy:
530         device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));
531 error:
532         return_i2c_dev(i2c_dev);
533         return res;
534 }
535
536 static int i2cdev_detach_adapter(struct i2c_adapter *adap)
537 {
538         struct i2c_dev *i2c_dev;
539
540         i2c_dev = i2c_dev_get_by_minor(adap->nr);
541         if (!i2c_dev) /* attach_adapter must have failed */
542                 return 0;
543
544         device_remove_file(i2c_dev->dev, &dev_attr_name);
545         return_i2c_dev(i2c_dev);
546         device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));
547
548         pr_debug("i2c-dev: adapter [%s] unregistered\n", adap->name);
549         return 0;
550 }
551
552 static int i2cdev_detach_client(struct i2c_client *client)
553 {
554         return 0;
555 }
556
557 static struct i2c_driver i2cdev_driver = {
558         .driver = {
559                 .name   = "dev_driver",
560         },
561         .id             = I2C_DRIVERID_I2CDEV,
562         .attach_adapter = i2cdev_attach_adapter,
563         .detach_adapter = i2cdev_detach_adapter,
564         .detach_client  = i2cdev_detach_client,
565 };
566
567 /* ------------------------------------------------------------------------- */
568
569 /*
570  * module load/unload record keeping
571  */
572
573 static int __init i2c_dev_init(void)
574 {
575         int res;
576
577         printk(KERN_INFO "i2c /dev entries driver\n");
578
579         res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);
580         if (res)
581                 goto out;
582
583         i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");
584         if (IS_ERR(i2c_dev_class))
585                 goto out_unreg_chrdev;
586
587         res = i2c_add_driver(&i2cdev_driver);
588         if (res)
589                 goto out_unreg_class;
590
591         return 0;
592
593 out_unreg_class:
594         class_destroy(i2c_dev_class);
595 out_unreg_chrdev:
596         unregister_chrdev(I2C_MAJOR, "i2c");
597 out:
598         printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
599         return res;
600 }
601
602 static void __exit i2c_dev_exit(void)
603 {
604         i2c_del_driver(&i2cdev_driver);
605         class_destroy(i2c_dev_class);
606         unregister_chrdev(I2C_MAJOR,"i2c");
607 }
608
609 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
610                 "Simon G. Vogl <simon@tk.uni-linz.ac.at>");
611 MODULE_DESCRIPTION("I2C /dev entries driver");
612 MODULE_LICENSE("GPL");
613
614 module_init(i2c_dev_init);
615 module_exit(i2c_dev_exit);