include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit...
[linux-2.6.git] / drivers / hid / hidraw.c
1 /*
2  * HID raw devices, giving access to raw HID events.
3  *
4  * In comparison to hiddev, this device does not process the
5  * hid events at all (no parsing, no lookups). This lets applications
6  * to work on raw hid events as they want to, and avoids a need to
7  * use a transport-specific userspace libhid/libusb libraries.
8  *
9  *  Copyright (c) 2007 Jiri Kosina
10  */
11
12 /*
13  * This program is free software; you can redistribute it and/or modify it
14  * under the terms and conditions of the GNU General Public License,
15  * version 2, as published by the Free Software Foundation.
16  *
17  * You should have received a copy of the GNU General Public License along with
18  * this program; if not, write to the Free Software Foundation, Inc.,
19  * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
20  */
21
22 #include <linux/fs.h>
23 #include <linux/module.h>
24 #include <linux/errno.h>
25 #include <linux/kernel.h>
26 #include <linux/init.h>
27 #include <linux/cdev.h>
28 #include <linux/poll.h>
29 #include <linux/device.h>
30 #include <linux/major.h>
31 #include <linux/slab.h>
32 #include <linux/hid.h>
33 #include <linux/mutex.h>
34 #include <linux/sched.h>
35 #include <linux/smp_lock.h>
36
37 #include <linux/hidraw.h>
38
39 static int hidraw_major;
40 static struct cdev hidraw_cdev;
41 static struct class *hidraw_class;
42 static struct hidraw *hidraw_table[HIDRAW_MAX_DEVICES];
43 static DEFINE_MUTEX(minors_lock);
44
45 static ssize_t hidraw_read(struct file *file, char __user *buffer, size_t count, loff_t *ppos)
46 {
47         struct hidraw_list *list = file->private_data;
48         int ret = 0, len;
49         char *report;
50         DECLARE_WAITQUEUE(wait, current);
51
52         mutex_lock(&list->read_mutex);
53
54         while (ret == 0) {
55                 if (list->head == list->tail) {
56                         add_wait_queue(&list->hidraw->wait, &wait);
57                         set_current_state(TASK_INTERRUPTIBLE);
58
59                         while (list->head == list->tail) {
60                                 if (file->f_flags & O_NONBLOCK) {
61                                         ret = -EAGAIN;
62                                         break;
63                                 }
64                                 if (signal_pending(current)) {
65                                         ret = -ERESTARTSYS;
66                                         break;
67                                 }
68                                 if (!list->hidraw->exist) {
69                                         ret = -EIO;
70                                         break;
71                                 }
72
73                                 /* allow O_NONBLOCK to work well from other threads */
74                                 mutex_unlock(&list->read_mutex);
75                                 schedule();
76                                 mutex_lock(&list->read_mutex);
77                                 set_current_state(TASK_INTERRUPTIBLE);
78                         }
79
80                         set_current_state(TASK_RUNNING);
81                         remove_wait_queue(&list->hidraw->wait, &wait);
82                 }
83
84                 if (ret)
85                         goto out;
86
87                 report = list->buffer[list->tail].value;
88                 len = list->buffer[list->tail].len > count ?
89                         count : list->buffer[list->tail].len;
90
91                 if (copy_to_user(buffer, list->buffer[list->tail].value, len)) {
92                         ret = -EFAULT;
93                         goto out;
94                 }
95                 ret += len;
96
97                 kfree(list->buffer[list->tail].value);
98                 list->tail = (list->tail + 1) & (HIDRAW_BUFFER_SIZE - 1);
99         }
100 out:
101         mutex_unlock(&list->read_mutex);
102         return ret;
103 }
104
105 /* the first byte is expected to be a report number */
106 static ssize_t hidraw_write(struct file *file, const char __user *buffer, size_t count, loff_t *ppos)
107 {
108         unsigned int minor = iminor(file->f_path.dentry->d_inode);
109         /* FIXME: What stops hidraw_table going NULL */
110         struct hid_device *dev = hidraw_table[minor]->hid;
111         __u8 *buf;
112         int ret = 0;
113
114         if (!dev->hid_output_raw_report)
115                 return -ENODEV;
116
117         if (count > HID_MAX_BUFFER_SIZE) {
118                 printk(KERN_WARNING "hidraw: pid %d passed too large report\n",
119                                 task_pid_nr(current));
120                 return -EINVAL;
121         }
122
123         if (count < 2) {
124                 printk(KERN_WARNING "hidraw: pid %d passed too short report\n",
125                                 task_pid_nr(current));
126                 return -EINVAL;
127         }
128
129         buf = kmalloc(count * sizeof(__u8), GFP_KERNEL);
130         if (!buf)
131                 return -ENOMEM;
132
133         if (copy_from_user(buf, buffer, count)) {
134                 ret = -EFAULT;
135                 goto out;
136         }
137
138         ret = dev->hid_output_raw_report(dev, buf, count, HID_OUTPUT_REPORT);
139 out:
140         kfree(buf);
141         return ret;
142 }
143
144 static unsigned int hidraw_poll(struct file *file, poll_table *wait)
145 {
146         struct hidraw_list *list = file->private_data;
147
148         poll_wait(file, &list->hidraw->wait, wait);
149         if (list->head != list->tail)
150                 return POLLIN | POLLRDNORM;
151         if (!list->hidraw->exist)
152                 return POLLERR | POLLHUP;
153         return 0;
154 }
155
156 static int hidraw_open(struct inode *inode, struct file *file)
157 {
158         unsigned int minor = iminor(inode);
159         struct hidraw *dev;
160         struct hidraw_list *list;
161         int err = 0;
162
163         if (!(list = kzalloc(sizeof(struct hidraw_list), GFP_KERNEL))) {
164                 err = -ENOMEM;
165                 goto out;
166         }
167
168         lock_kernel();
169         mutex_lock(&minors_lock);
170         if (!hidraw_table[minor]) {
171                 printk(KERN_EMERG "hidraw device with minor %d doesn't exist\n",
172                                 minor);
173                 kfree(list);
174                 err = -ENODEV;
175                 goto out_unlock;
176         }
177
178         list->hidraw = hidraw_table[minor];
179         mutex_init(&list->read_mutex);
180         list_add_tail(&list->node, &hidraw_table[minor]->list);
181         file->private_data = list;
182
183         dev = hidraw_table[minor];
184         if (!dev->open++) {
185                 if (dev->hid->ll_driver->power) {
186                         err = dev->hid->ll_driver->power(dev->hid, PM_HINT_FULLON);
187                         if (err < 0)
188                                 goto out_unlock;
189                 }
190                 err = dev->hid->ll_driver->open(dev->hid);
191                 if (err < 0) {
192                         if (dev->hid->ll_driver->power)
193                                 dev->hid->ll_driver->power(dev->hid, PM_HINT_NORMAL);
194                         dev->open--;
195                 }
196         }
197
198 out_unlock:
199         mutex_unlock(&minors_lock);
200         unlock_kernel();
201 out:
202         return err;
203
204 }
205
206 static int hidraw_release(struct inode * inode, struct file * file)
207 {
208         unsigned int minor = iminor(inode);
209         struct hidraw *dev;
210         struct hidraw_list *list = file->private_data;
211
212         if (!hidraw_table[minor]) {
213                 printk(KERN_EMERG "hidraw device with minor %d doesn't exist\n",
214                                 minor);
215                 return -ENODEV;
216         }
217
218         list_del(&list->node);
219         dev = hidraw_table[minor];
220         if (!--dev->open) {
221                 if (list->hidraw->exist) {
222                         if (dev->hid->ll_driver->power)
223                                 dev->hid->ll_driver->power(dev->hid, PM_HINT_NORMAL);
224                         dev->hid->ll_driver->close(dev->hid);
225                 } else {
226                         kfree(list->hidraw);
227                 }
228         }
229
230         kfree(list);
231
232         return 0;
233 }
234
235 static long hidraw_ioctl(struct file *file, unsigned int cmd,
236                                                         unsigned long arg)
237 {
238         struct inode *inode = file->f_path.dentry->d_inode;
239         unsigned int minor = iminor(inode);
240         long ret = 0;
241         /* FIXME: What stops hidraw_table going NULL */
242         struct hidraw *dev = hidraw_table[minor];
243         void __user *user_arg = (void __user*) arg;
244
245         lock_kernel();
246         switch (cmd) {
247                 case HIDIOCGRDESCSIZE:
248                         if (put_user(dev->hid->rsize, (int __user *)arg))
249                                 ret = -EFAULT;
250                         break;
251
252                 case HIDIOCGRDESC:
253                         {
254                                 __u32 len;
255
256                                 if (get_user(len, (int __user *)arg))
257                                         ret = -EFAULT;
258                                 else if (len > HID_MAX_DESCRIPTOR_SIZE - 1)
259                                         ret = -EINVAL;
260                                 else if (copy_to_user(user_arg + offsetof(
261                                         struct hidraw_report_descriptor,
262                                         value[0]),
263                                         dev->hid->rdesc,
264                                         min(dev->hid->rsize, len)))
265                                         ret = -EFAULT;
266                                 break;
267                         }
268                 case HIDIOCGRAWINFO:
269                         {
270                                 struct hidraw_devinfo dinfo;
271
272                                 dinfo.bustype = dev->hid->bus;
273                                 dinfo.vendor = dev->hid->vendor;
274                                 dinfo.product = dev->hid->product;
275                                 if (copy_to_user(user_arg, &dinfo, sizeof(dinfo)))
276                                         ret = -EFAULT;
277                                 break;
278                         }
279                 default:
280                         {
281                                 struct hid_device *hid = dev->hid;
282                                 if (_IOC_TYPE(cmd) != 'H' || _IOC_DIR(cmd) != _IOC_READ) {
283                                         ret = -EINVAL;
284                                         break;
285                                 }
286
287                                 if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGRAWNAME(0))) {
288                                         int len;
289                                         if (!hid->name) {
290                                                 ret = 0;
291                                                 break;
292                                         }
293                                         len = strlen(hid->name) + 1;
294                                         if (len > _IOC_SIZE(cmd))
295                                                 len = _IOC_SIZE(cmd);
296                                         ret = copy_to_user(user_arg, hid->name, len) ?
297                                                 -EFAULT : len;
298                                         break;
299                                 }
300
301                                 if (_IOC_NR(cmd) == _IOC_NR(HIDIOCGRAWPHYS(0))) {
302                                         int len;
303                                         if (!hid->phys) {
304                                                 ret = 0;
305                                                 break;
306                                         }
307                                         len = strlen(hid->phys) + 1;
308                                         if (len > _IOC_SIZE(cmd))
309                                                 len = _IOC_SIZE(cmd);
310                                         ret = copy_to_user(user_arg, hid->phys, len) ?
311                                                 -EFAULT : len;
312                                         break;
313                                 }
314                 }
315
316                 ret = -ENOTTY;
317         }
318         unlock_kernel();
319         return ret;
320 }
321
322 static const struct file_operations hidraw_ops = {
323         .owner =        THIS_MODULE,
324         .read =         hidraw_read,
325         .write =        hidraw_write,
326         .poll =         hidraw_poll,
327         .open =         hidraw_open,
328         .release =      hidraw_release,
329         .unlocked_ioctl = hidraw_ioctl,
330 };
331
332 void hidraw_report_event(struct hid_device *hid, u8 *data, int len)
333 {
334         struct hidraw *dev = hid->hidraw;
335         struct hidraw_list *list;
336
337         list_for_each_entry(list, &dev->list, node) {
338                 list->buffer[list->head].value = kmemdup(data, len, GFP_ATOMIC);
339                 list->buffer[list->head].len = len;
340                 list->head = (list->head + 1) & (HIDRAW_BUFFER_SIZE - 1);
341                 kill_fasync(&list->fasync, SIGIO, POLL_IN);
342         }
343
344         wake_up_interruptible(&dev->wait);
345 }
346 EXPORT_SYMBOL_GPL(hidraw_report_event);
347
348 int hidraw_connect(struct hid_device *hid)
349 {
350         int minor, result;
351         struct hidraw *dev;
352
353         /* we accept any HID device, no matter the applications */
354
355         dev = kzalloc(sizeof(struct hidraw), GFP_KERNEL);
356         if (!dev)
357                 return -ENOMEM;
358
359         result = -EINVAL;
360
361         mutex_lock(&minors_lock);
362
363         for (minor = 0; minor < HIDRAW_MAX_DEVICES; minor++) {
364                 if (hidraw_table[minor])
365                         continue;
366                 hidraw_table[minor] = dev;
367                 result = 0;
368                 break;
369         }
370
371         if (result) {
372                 mutex_unlock(&minors_lock);
373                 kfree(dev);
374                 goto out;
375         }
376
377         dev->dev = device_create(hidraw_class, &hid->dev, MKDEV(hidraw_major, minor),
378                                  NULL, "%s%d", "hidraw", minor);
379
380         if (IS_ERR(dev->dev)) {
381                 hidraw_table[minor] = NULL;
382                 mutex_unlock(&minors_lock);
383                 result = PTR_ERR(dev->dev);
384                 kfree(dev);
385                 goto out;
386         }
387
388         mutex_unlock(&minors_lock);
389         init_waitqueue_head(&dev->wait);
390         INIT_LIST_HEAD(&dev->list);
391
392         dev->hid = hid;
393         dev->minor = minor;
394
395         dev->exist = 1;
396         hid->hidraw = dev;
397
398 out:
399         return result;
400
401 }
402 EXPORT_SYMBOL_GPL(hidraw_connect);
403
404 void hidraw_disconnect(struct hid_device *hid)
405 {
406         struct hidraw *hidraw = hid->hidraw;
407
408         hidraw->exist = 0;
409
410         mutex_lock(&minors_lock);
411         hidraw_table[hidraw->minor] = NULL;
412         mutex_unlock(&minors_lock);
413
414         device_destroy(hidraw_class, MKDEV(hidraw_major, hidraw->minor));
415
416         if (hidraw->open) {
417                 hid->ll_driver->close(hid);
418                 wake_up_interruptible(&hidraw->wait);
419         } else {
420                 kfree(hidraw);
421         }
422 }
423 EXPORT_SYMBOL_GPL(hidraw_disconnect);
424
425 int __init hidraw_init(void)
426 {
427         int result;
428         dev_t dev_id;
429
430         result = alloc_chrdev_region(&dev_id, HIDRAW_FIRST_MINOR,
431                         HIDRAW_MAX_DEVICES, "hidraw");
432
433         hidraw_major = MAJOR(dev_id);
434
435         if (result < 0) {
436                 printk(KERN_WARNING "hidraw: can't get major number\n");
437                 result = 0;
438                 goto out;
439         }
440
441         hidraw_class = class_create(THIS_MODULE, "hidraw");
442         if (IS_ERR(hidraw_class)) {
443                 result = PTR_ERR(hidraw_class);
444                 unregister_chrdev(hidraw_major, "hidraw");
445                 goto out;
446         }
447
448         cdev_init(&hidraw_cdev, &hidraw_ops);
449         cdev_add(&hidraw_cdev, dev_id, HIDRAW_MAX_DEVICES);
450 out:
451         return result;
452 }
453
454 void hidraw_exit(void)
455 {
456         dev_t dev_id = MKDEV(hidraw_major, 0);
457
458         cdev_del(&hidraw_cdev);
459         class_destroy(hidraw_class);
460         unregister_chrdev_region(dev_id, HIDRAW_MAX_DEVICES);
461
462 }