]> pilppa.org Git - linux-2.6-omap-h63xx.git/blob - drivers/i2c/i2c-dev.c
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
[linux-2.6-omap-h63xx.git] / 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 int i2cdev_ioctl(struct inode *inode, struct file *file,
204                 unsigned int cmd, unsigned long arg)
205 {
206         struct i2c_client *client = (struct i2c_client *)file->private_data;
207         struct i2c_rdwr_ioctl_data rdwr_arg;
208         struct i2c_smbus_ioctl_data data_arg;
209         union i2c_smbus_data temp;
210         struct i2c_msg *rdwr_pa;
211         u8 __user **data_ptrs;
212         int i,datasize,res;
213         unsigned long funcs;
214
215         dev_dbg(&client->adapter->dev, "ioctl, cmd=0x%02x, arg=0x%02lx\n",
216                 cmd, arg);
217
218         switch ( cmd ) {
219         case I2C_SLAVE:
220         case I2C_SLAVE_FORCE:
221                 /* NOTE:  devices set up to work with "new style" drivers
222                  * can't use I2C_SLAVE, even when the device node is not
223                  * bound to a driver.  Only I2C_SLAVE_FORCE will work.
224                  *
225                  * Setting the PEC flag here won't affect kernel drivers,
226                  * which will be using the i2c_client node registered with
227                  * the driver model core.  Likewise, when that client has
228                  * the PEC flag already set, the i2c-dev driver won't see
229                  * (or use) this setting.
230                  */
231                 if ((arg > 0x3ff) ||
232                     (((client->flags & I2C_M_TEN) == 0) && arg > 0x7f))
233                         return -EINVAL;
234                 if (cmd == I2C_SLAVE && i2cdev_check_addr(client->adapter, arg))
235                         return -EBUSY;
236                 /* REVISIT: address could become busy later */
237                 client->addr = arg;
238                 return 0;
239         case I2C_TENBIT:
240                 if (arg)
241                         client->flags |= I2C_M_TEN;
242                 else
243                         client->flags &= ~I2C_M_TEN;
244                 return 0;
245         case I2C_PEC:
246                 if (arg)
247                         client->flags |= I2C_CLIENT_PEC;
248                 else
249                         client->flags &= ~I2C_CLIENT_PEC;
250                 return 0;
251         case I2C_FUNCS:
252                 funcs = i2c_get_functionality(client->adapter);
253                 return put_user(funcs, (unsigned long __user *)arg);
254
255         case I2C_RDWR:
256                 if (copy_from_user(&rdwr_arg,
257                                    (struct i2c_rdwr_ioctl_data __user *)arg,
258                                    sizeof(rdwr_arg)))
259                         return -EFAULT;
260
261                 /* Put an arbitrary limit on the number of messages that can
262                  * be sent at once */
263                 if (rdwr_arg.nmsgs > I2C_RDRW_IOCTL_MAX_MSGS)
264                         return -EINVAL;
265
266                 rdwr_pa = (struct i2c_msg *)
267                         kmalloc(rdwr_arg.nmsgs * sizeof(struct i2c_msg),
268                         GFP_KERNEL);
269
270                 if (rdwr_pa == NULL) return -ENOMEM;
271
272                 if (copy_from_user(rdwr_pa, rdwr_arg.msgs,
273                                    rdwr_arg.nmsgs * sizeof(struct i2c_msg))) {
274                         kfree(rdwr_pa);
275                         return -EFAULT;
276                 }
277
278                 data_ptrs = kmalloc(rdwr_arg.nmsgs * sizeof(u8 __user *), GFP_KERNEL);
279                 if (data_ptrs == NULL) {
280                         kfree(rdwr_pa);
281                         return -ENOMEM;
282                 }
283
284                 res = 0;
285                 for( i=0; i<rdwr_arg.nmsgs; i++ ) {
286                         /* Limit the size of the message to a sane amount;
287                          * and don't let length change either. */
288                         if ((rdwr_pa[i].len > 8192) ||
289                             (rdwr_pa[i].flags & I2C_M_RECV_LEN)) {
290                                 res = -EINVAL;
291                                 break;
292                         }
293                         data_ptrs[i] = (u8 __user *)rdwr_pa[i].buf;
294                         rdwr_pa[i].buf = kmalloc(rdwr_pa[i].len, GFP_KERNEL);
295                         if(rdwr_pa[i].buf == NULL) {
296                                 res = -ENOMEM;
297                                 break;
298                         }
299                         if(copy_from_user(rdwr_pa[i].buf,
300                                 data_ptrs[i],
301                                 rdwr_pa[i].len)) {
302                                         ++i; /* Needs to be kfreed too */
303                                         res = -EFAULT;
304                                 break;
305                         }
306                 }
307                 if (res < 0) {
308                         int j;
309                         for (j = 0; j < i; ++j)
310                                 kfree(rdwr_pa[j].buf);
311                         kfree(data_ptrs);
312                         kfree(rdwr_pa);
313                         return res;
314                 }
315
316                 res = i2c_transfer(client->adapter,
317                         rdwr_pa,
318                         rdwr_arg.nmsgs);
319                 while(i-- > 0) {
320                         if( res>=0 && (rdwr_pa[i].flags & I2C_M_RD)) {
321                                 if(copy_to_user(
322                                         data_ptrs[i],
323                                         rdwr_pa[i].buf,
324                                         rdwr_pa[i].len)) {
325                                         res = -EFAULT;
326                                 }
327                         }
328                         kfree(rdwr_pa[i].buf);
329                 }
330                 kfree(data_ptrs);
331                 kfree(rdwr_pa);
332                 return res;
333
334         case I2C_SMBUS:
335                 if (copy_from_user(&data_arg,
336                                    (struct i2c_smbus_ioctl_data __user *) arg,
337                                    sizeof(struct i2c_smbus_ioctl_data)))
338                         return -EFAULT;
339                 if ((data_arg.size != I2C_SMBUS_BYTE) &&
340                     (data_arg.size != I2C_SMBUS_QUICK) &&
341                     (data_arg.size != I2C_SMBUS_BYTE_DATA) &&
342                     (data_arg.size != I2C_SMBUS_WORD_DATA) &&
343                     (data_arg.size != I2C_SMBUS_PROC_CALL) &&
344                     (data_arg.size != I2C_SMBUS_BLOCK_DATA) &&
345                     (data_arg.size != I2C_SMBUS_I2C_BLOCK_BROKEN) &&
346                     (data_arg.size != I2C_SMBUS_I2C_BLOCK_DATA) &&
347                     (data_arg.size != I2C_SMBUS_BLOCK_PROC_CALL)) {
348                         dev_dbg(&client->adapter->dev,
349                                 "size out of range (%x) in ioctl I2C_SMBUS.\n",
350                                 data_arg.size);
351                         return -EINVAL;
352                 }
353                 /* Note that I2C_SMBUS_READ and I2C_SMBUS_WRITE are 0 and 1,
354                    so the check is valid if size==I2C_SMBUS_QUICK too. */
355                 if ((data_arg.read_write != I2C_SMBUS_READ) &&
356                     (data_arg.read_write != I2C_SMBUS_WRITE)) {
357                         dev_dbg(&client->adapter->dev,
358                                 "read_write out of range (%x) in ioctl I2C_SMBUS.\n",
359                                 data_arg.read_write);
360                         return -EINVAL;
361                 }
362
363                 /* Note that command values are always valid! */
364
365                 if ((data_arg.size == I2C_SMBUS_QUICK) ||
366                     ((data_arg.size == I2C_SMBUS_BYTE) &&
367                     (data_arg.read_write == I2C_SMBUS_WRITE)))
368                         /* These are special: we do not use data */
369                         return i2c_smbus_xfer(client->adapter, client->addr,
370                                               client->flags,
371                                               data_arg.read_write,
372                                               data_arg.command,
373                                               data_arg.size, NULL);
374
375                 if (data_arg.data == NULL) {
376                         dev_dbg(&client->adapter->dev,
377                                 "data is NULL pointer in ioctl I2C_SMBUS.\n");
378                         return -EINVAL;
379                 }
380
381                 if ((data_arg.size == I2C_SMBUS_BYTE_DATA) ||
382                     (data_arg.size == I2C_SMBUS_BYTE))
383                         datasize = sizeof(data_arg.data->byte);
384                 else if ((data_arg.size == I2C_SMBUS_WORD_DATA) ||
385                          (data_arg.size == I2C_SMBUS_PROC_CALL))
386                         datasize = sizeof(data_arg.data->word);
387                 else /* size == smbus block, i2c block, or block proc. call */
388                         datasize = sizeof(data_arg.data->block);
389
390                 if ((data_arg.size == I2C_SMBUS_PROC_CALL) ||
391                     (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) ||
392                     (data_arg.size == I2C_SMBUS_I2C_BLOCK_DATA) ||
393                     (data_arg.read_write == I2C_SMBUS_WRITE)) {
394                         if (copy_from_user(&temp, data_arg.data, datasize))
395                                 return -EFAULT;
396                 }
397                 if (data_arg.size == I2C_SMBUS_I2C_BLOCK_BROKEN) {
398                         /* Convert old I2C block commands to the new
399                            convention. This preserves binary compatibility. */
400                         data_arg.size = I2C_SMBUS_I2C_BLOCK_DATA;
401                         if (data_arg.read_write == I2C_SMBUS_READ)
402                                 temp.block[0] = I2C_SMBUS_BLOCK_MAX;
403                 }
404                 res = i2c_smbus_xfer(client->adapter,client->addr,client->flags,
405                       data_arg.read_write,
406                       data_arg.command,data_arg.size,&temp);
407                 if (! res && ((data_arg.size == I2C_SMBUS_PROC_CALL) ||
408                               (data_arg.size == I2C_SMBUS_BLOCK_PROC_CALL) ||
409                               (data_arg.read_write == I2C_SMBUS_READ))) {
410                         if (copy_to_user(data_arg.data, &temp, datasize))
411                                 return -EFAULT;
412                 }
413                 return res;
414         case I2C_RETRIES:
415                 client->adapter->retries = arg;
416                 break;
417         case I2C_TIMEOUT:
418                 client->adapter->timeout = arg;
419                 break;
420         default:
421                 /* NOTE:  returning a fault code here could cause trouble
422                  * in buggy userspace code.  Some old kernel bugs returned
423                  * zero in this case, and userspace code might accidentally
424                  * have depended on that bug.
425                  */
426                 return -ENOTTY;
427         }
428         return 0;
429 }
430
431 static int i2cdev_open(struct inode *inode, struct file *file)
432 {
433         unsigned int minor = iminor(inode);
434         struct i2c_client *client;
435         struct i2c_adapter *adap;
436         struct i2c_dev *i2c_dev;
437
438         i2c_dev = i2c_dev_get_by_minor(minor);
439         if (!i2c_dev)
440                 return -ENODEV;
441
442         adap = i2c_get_adapter(i2c_dev->adap->nr);
443         if (!adap)
444                 return -ENODEV;
445
446         /* This creates an anonymous i2c_client, which may later be
447          * pointed to some address using I2C_SLAVE or I2C_SLAVE_FORCE.
448          *
449          * This client is ** NEVER REGISTERED ** with the driver model
450          * or I2C core code!!  It just holds private copies of addressing
451          * information and maybe a PEC flag.
452          */
453         client = kzalloc(sizeof(*client), GFP_KERNEL);
454         if (!client) {
455                 i2c_put_adapter(adap);
456                 return -ENOMEM;
457         }
458         snprintf(client->name, I2C_NAME_SIZE, "i2c-dev %d", adap->nr);
459         client->driver = &i2cdev_driver;
460
461         client->adapter = adap;
462         file->private_data = client;
463
464         return 0;
465 }
466
467 static int i2cdev_release(struct inode *inode, struct file *file)
468 {
469         struct i2c_client *client = file->private_data;
470
471         i2c_put_adapter(client->adapter);
472         kfree(client);
473         file->private_data = NULL;
474
475         return 0;
476 }
477
478 static const struct file_operations i2cdev_fops = {
479         .owner          = THIS_MODULE,
480         .llseek         = no_llseek,
481         .read           = i2cdev_read,
482         .write          = i2cdev_write,
483         .ioctl          = i2cdev_ioctl,
484         .open           = i2cdev_open,
485         .release        = i2cdev_release,
486 };
487
488 /* ------------------------------------------------------------------------- */
489
490 /*
491  * The legacy "i2cdev_driver" is used primarily to get notifications when
492  * I2C adapters are added or removed, so that each one gets an i2c_dev
493  * and is thus made available to userspace driver code.
494  */
495
496 static struct class *i2c_dev_class;
497
498 static int i2cdev_attach_adapter(struct i2c_adapter *adap)
499 {
500         struct i2c_dev *i2c_dev;
501         int res;
502
503         i2c_dev = get_free_i2c_dev(adap);
504         if (IS_ERR(i2c_dev))
505                 return PTR_ERR(i2c_dev);
506
507         /* register this i2c device with the driver core */
508         i2c_dev->dev = device_create(i2c_dev_class, &adap->dev,
509                                      MKDEV(I2C_MAJOR, adap->nr),
510                                      "i2c-%d", adap->nr);
511         if (IS_ERR(i2c_dev->dev)) {
512                 res = PTR_ERR(i2c_dev->dev);
513                 goto error;
514         }
515         res = device_create_file(i2c_dev->dev, &dev_attr_name);
516         if (res)
517                 goto error_destroy;
518
519         pr_debug("i2c-dev: adapter [%s] registered as minor %d\n",
520                  adap->name, adap->nr);
521         return 0;
522 error_destroy:
523         device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));
524 error:
525         return_i2c_dev(i2c_dev);
526         return res;
527 }
528
529 static int i2cdev_detach_adapter(struct i2c_adapter *adap)
530 {
531         struct i2c_dev *i2c_dev;
532
533         i2c_dev = i2c_dev_get_by_minor(adap->nr);
534         if (!i2c_dev) /* attach_adapter must have failed */
535                 return 0;
536
537         device_remove_file(i2c_dev->dev, &dev_attr_name);
538         return_i2c_dev(i2c_dev);
539         device_destroy(i2c_dev_class, MKDEV(I2C_MAJOR, adap->nr));
540
541         pr_debug("i2c-dev: adapter [%s] unregistered\n", adap->name);
542         return 0;
543 }
544
545 static int i2cdev_detach_client(struct i2c_client *client)
546 {
547         return 0;
548 }
549
550 static struct i2c_driver i2cdev_driver = {
551         .driver = {
552                 .name   = "dev_driver",
553         },
554         .id             = I2C_DRIVERID_I2CDEV,
555         .attach_adapter = i2cdev_attach_adapter,
556         .detach_adapter = i2cdev_detach_adapter,
557         .detach_client  = i2cdev_detach_client,
558 };
559
560 /* ------------------------------------------------------------------------- */
561
562 /*
563  * module load/unload record keeping
564  */
565
566 static int __init i2c_dev_init(void)
567 {
568         int res;
569
570         printk(KERN_INFO "i2c /dev entries driver\n");
571
572         res = register_chrdev(I2C_MAJOR, "i2c", &i2cdev_fops);
573         if (res)
574                 goto out;
575
576         i2c_dev_class = class_create(THIS_MODULE, "i2c-dev");
577         if (IS_ERR(i2c_dev_class))
578                 goto out_unreg_chrdev;
579
580         res = i2c_add_driver(&i2cdev_driver);
581         if (res)
582                 goto out_unreg_class;
583
584         return 0;
585
586 out_unreg_class:
587         class_destroy(i2c_dev_class);
588 out_unreg_chrdev:
589         unregister_chrdev(I2C_MAJOR, "i2c");
590 out:
591         printk(KERN_ERR "%s: Driver Initialisation failed\n", __FILE__);
592         return res;
593 }
594
595 static void __exit i2c_dev_exit(void)
596 {
597         i2c_del_driver(&i2cdev_driver);
598         class_destroy(i2c_dev_class);
599         unregister_chrdev(I2C_MAJOR,"i2c");
600 }
601
602 MODULE_AUTHOR("Frodo Looijaard <frodol@dds.nl> and "
603                 "Simon G. Vogl <simon@tk.uni-linz.ac.at>");
604 MODULE_DESCRIPTION("I2C /dev entries driver");
605 MODULE_LICENSE("GPL");
606
607 module_init(i2c_dev_init);
608 module_exit(i2c_dev_exit);