Merge tag 'char-misc-4.19-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregk...
[muen/linux.git] / drivers / uio / uio.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * drivers/uio/uio.c
4  *
5  * Copyright(C) 2005, Benedikt Spranger <b.spranger@linutronix.de>
6  * Copyright(C) 2005, Thomas Gleixner <tglx@linutronix.de>
7  * Copyright(C) 2006, Hans J. Koch <hjk@hansjkoch.de>
8  * Copyright(C) 2006, Greg Kroah-Hartman <greg@kroah.com>
9  *
10  * Userspace IO
11  *
12  * Base Functions
13  */
14
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/poll.h>
18 #include <linux/device.h>
19 #include <linux/slab.h>
20 #include <linux/mm.h>
21 #include <linux/idr.h>
22 #include <linux/sched/signal.h>
23 #include <linux/string.h>
24 #include <linux/kobject.h>
25 #include <linux/cdev.h>
26 #include <linux/uio_driver.h>
27
28 #define UIO_MAX_DEVICES         (1U << MINORBITS)
29
30 static int uio_major;
31 static struct cdev *uio_cdev;
32 static DEFINE_IDR(uio_idr);
33 static const struct file_operations uio_fops;
34
35 /* Protect idr accesses */
36 static DEFINE_MUTEX(minor_lock);
37
38 /*
39  * attributes
40  */
41
42 struct uio_map {
43         struct kobject kobj;
44         struct uio_mem *mem;
45 };
46 #define to_map(map) container_of(map, struct uio_map, kobj)
47
48 static ssize_t map_name_show(struct uio_mem *mem, char *buf)
49 {
50         if (unlikely(!mem->name))
51                 mem->name = "";
52
53         return sprintf(buf, "%s\n", mem->name);
54 }
55
56 static ssize_t map_addr_show(struct uio_mem *mem, char *buf)
57 {
58         return sprintf(buf, "%pa\n", &mem->addr);
59 }
60
61 static ssize_t map_size_show(struct uio_mem *mem, char *buf)
62 {
63         return sprintf(buf, "%pa\n", &mem->size);
64 }
65
66 static ssize_t map_offset_show(struct uio_mem *mem, char *buf)
67 {
68         return sprintf(buf, "0x%llx\n", (unsigned long long)mem->offs);
69 }
70
71 struct map_sysfs_entry {
72         struct attribute attr;
73         ssize_t (*show)(struct uio_mem *, char *);
74         ssize_t (*store)(struct uio_mem *, const char *, size_t);
75 };
76
77 static struct map_sysfs_entry name_attribute =
78         __ATTR(name, S_IRUGO, map_name_show, NULL);
79 static struct map_sysfs_entry addr_attribute =
80         __ATTR(addr, S_IRUGO, map_addr_show, NULL);
81 static struct map_sysfs_entry size_attribute =
82         __ATTR(size, S_IRUGO, map_size_show, NULL);
83 static struct map_sysfs_entry offset_attribute =
84         __ATTR(offset, S_IRUGO, map_offset_show, NULL);
85
86 static struct attribute *attrs[] = {
87         &name_attribute.attr,
88         &addr_attribute.attr,
89         &size_attribute.attr,
90         &offset_attribute.attr,
91         NULL,   /* need to NULL terminate the list of attributes */
92 };
93
94 static void map_release(struct kobject *kobj)
95 {
96         struct uio_map *map = to_map(kobj);
97         kfree(map);
98 }
99
100 static ssize_t map_type_show(struct kobject *kobj, struct attribute *attr,
101                              char *buf)
102 {
103         struct uio_map *map = to_map(kobj);
104         struct uio_mem *mem = map->mem;
105         struct map_sysfs_entry *entry;
106
107         entry = container_of(attr, struct map_sysfs_entry, attr);
108
109         if (!entry->show)
110                 return -EIO;
111
112         return entry->show(mem, buf);
113 }
114
115 static const struct sysfs_ops map_sysfs_ops = {
116         .show = map_type_show,
117 };
118
119 static struct kobj_type map_attr_type = {
120         .release        = map_release,
121         .sysfs_ops      = &map_sysfs_ops,
122         .default_attrs  = attrs,
123 };
124
125 struct uio_portio {
126         struct kobject kobj;
127         struct uio_port *port;
128 };
129 #define to_portio(portio) container_of(portio, struct uio_portio, kobj)
130
131 static ssize_t portio_name_show(struct uio_port *port, char *buf)
132 {
133         if (unlikely(!port->name))
134                 port->name = "";
135
136         return sprintf(buf, "%s\n", port->name);
137 }
138
139 static ssize_t portio_start_show(struct uio_port *port, char *buf)
140 {
141         return sprintf(buf, "0x%lx\n", port->start);
142 }
143
144 static ssize_t portio_size_show(struct uio_port *port, char *buf)
145 {
146         return sprintf(buf, "0x%lx\n", port->size);
147 }
148
149 static ssize_t portio_porttype_show(struct uio_port *port, char *buf)
150 {
151         const char *porttypes[] = {"none", "x86", "gpio", "other"};
152
153         if ((port->porttype < 0) || (port->porttype > UIO_PORT_OTHER))
154                 return -EINVAL;
155
156         return sprintf(buf, "port_%s\n", porttypes[port->porttype]);
157 }
158
159 struct portio_sysfs_entry {
160         struct attribute attr;
161         ssize_t (*show)(struct uio_port *, char *);
162         ssize_t (*store)(struct uio_port *, const char *, size_t);
163 };
164
165 static struct portio_sysfs_entry portio_name_attribute =
166         __ATTR(name, S_IRUGO, portio_name_show, NULL);
167 static struct portio_sysfs_entry portio_start_attribute =
168         __ATTR(start, S_IRUGO, portio_start_show, NULL);
169 static struct portio_sysfs_entry portio_size_attribute =
170         __ATTR(size, S_IRUGO, portio_size_show, NULL);
171 static struct portio_sysfs_entry portio_porttype_attribute =
172         __ATTR(porttype, S_IRUGO, portio_porttype_show, NULL);
173
174 static struct attribute *portio_attrs[] = {
175         &portio_name_attribute.attr,
176         &portio_start_attribute.attr,
177         &portio_size_attribute.attr,
178         &portio_porttype_attribute.attr,
179         NULL,
180 };
181
182 static void portio_release(struct kobject *kobj)
183 {
184         struct uio_portio *portio = to_portio(kobj);
185         kfree(portio);
186 }
187
188 static ssize_t portio_type_show(struct kobject *kobj, struct attribute *attr,
189                              char *buf)
190 {
191         struct uio_portio *portio = to_portio(kobj);
192         struct uio_port *port = portio->port;
193         struct portio_sysfs_entry *entry;
194
195         entry = container_of(attr, struct portio_sysfs_entry, attr);
196
197         if (!entry->show)
198                 return -EIO;
199
200         return entry->show(port, buf);
201 }
202
203 static const struct sysfs_ops portio_sysfs_ops = {
204         .show = portio_type_show,
205 };
206
207 static struct kobj_type portio_attr_type = {
208         .release        = portio_release,
209         .sysfs_ops      = &portio_sysfs_ops,
210         .default_attrs  = portio_attrs,
211 };
212
213 static ssize_t name_show(struct device *dev,
214                          struct device_attribute *attr, char *buf)
215 {
216         struct uio_device *idev = dev_get_drvdata(dev);
217         int ret;
218
219         mutex_lock(&idev->info_lock);
220         if (!idev->info) {
221                 ret = -EINVAL;
222                 dev_err(dev, "the device has been unregistered\n");
223                 goto out;
224         }
225
226         ret = sprintf(buf, "%s\n", idev->info->name);
227
228 out:
229         mutex_unlock(&idev->info_lock);
230         return ret;
231 }
232 static DEVICE_ATTR_RO(name);
233
234 static ssize_t version_show(struct device *dev,
235                             struct device_attribute *attr, char *buf)
236 {
237         struct uio_device *idev = dev_get_drvdata(dev);
238         int ret;
239
240         mutex_lock(&idev->info_lock);
241         if (!idev->info) {
242                 ret = -EINVAL;
243                 dev_err(dev, "the device has been unregistered\n");
244                 goto out;
245         }
246
247         ret = sprintf(buf, "%s\n", idev->info->version);
248
249 out:
250         mutex_unlock(&idev->info_lock);
251         return ret;
252 }
253 static DEVICE_ATTR_RO(version);
254
255 static ssize_t event_show(struct device *dev,
256                           struct device_attribute *attr, char *buf)
257 {
258         struct uio_device *idev = dev_get_drvdata(dev);
259         return sprintf(buf, "%u\n", (unsigned int)atomic_read(&idev->event));
260 }
261 static DEVICE_ATTR_RO(event);
262
263 static struct attribute *uio_attrs[] = {
264         &dev_attr_name.attr,
265         &dev_attr_version.attr,
266         &dev_attr_event.attr,
267         NULL,
268 };
269 ATTRIBUTE_GROUPS(uio);
270
271 /* UIO class infrastructure */
272 static struct class uio_class = {
273         .name = "uio",
274         .dev_groups = uio_groups,
275 };
276
277 /*
278  * device functions
279  */
280 static int uio_dev_add_attributes(struct uio_device *idev)
281 {
282         int ret;
283         int mi, pi;
284         int map_found = 0;
285         int portio_found = 0;
286         struct uio_mem *mem;
287         struct uio_map *map;
288         struct uio_port *port;
289         struct uio_portio *portio;
290
291         for (mi = 0; mi < MAX_UIO_MAPS; mi++) {
292                 mem = &idev->info->mem[mi];
293                 if (mem->size == 0)
294                         break;
295                 if (!map_found) {
296                         map_found = 1;
297                         idev->map_dir = kobject_create_and_add("maps",
298                                                         &idev->dev.kobj);
299                         if (!idev->map_dir) {
300                                 ret = -ENOMEM;
301                                 goto err_map;
302                         }
303                 }
304                 map = kzalloc(sizeof(*map), GFP_KERNEL);
305                 if (!map) {
306                         ret = -ENOMEM;
307                         goto err_map;
308                 }
309                 kobject_init(&map->kobj, &map_attr_type);
310                 map->mem = mem;
311                 mem->map = map;
312                 ret = kobject_add(&map->kobj, idev->map_dir, "map%d", mi);
313                 if (ret)
314                         goto err_map_kobj;
315                 ret = kobject_uevent(&map->kobj, KOBJ_ADD);
316                 if (ret)
317                         goto err_map_kobj;
318         }
319
320         for (pi = 0; pi < MAX_UIO_PORT_REGIONS; pi++) {
321                 port = &idev->info->port[pi];
322                 if (port->size == 0)
323                         break;
324                 if (!portio_found) {
325                         portio_found = 1;
326                         idev->portio_dir = kobject_create_and_add("portio",
327                                                         &idev->dev.kobj);
328                         if (!idev->portio_dir) {
329                                 ret = -ENOMEM;
330                                 goto err_portio;
331                         }
332                 }
333                 portio = kzalloc(sizeof(*portio), GFP_KERNEL);
334                 if (!portio) {
335                         ret = -ENOMEM;
336                         goto err_portio;
337                 }
338                 kobject_init(&portio->kobj, &portio_attr_type);
339                 portio->port = port;
340                 port->portio = portio;
341                 ret = kobject_add(&portio->kobj, idev->portio_dir,
342                                                         "port%d", pi);
343                 if (ret)
344                         goto err_portio_kobj;
345                 ret = kobject_uevent(&portio->kobj, KOBJ_ADD);
346                 if (ret)
347                         goto err_portio_kobj;
348         }
349
350         return 0;
351
352 err_portio:
353         pi--;
354 err_portio_kobj:
355         for (; pi >= 0; pi--) {
356                 port = &idev->info->port[pi];
357                 portio = port->portio;
358                 kobject_put(&portio->kobj);
359         }
360         kobject_put(idev->portio_dir);
361 err_map:
362         mi--;
363 err_map_kobj:
364         for (; mi >= 0; mi--) {
365                 mem = &idev->info->mem[mi];
366                 map = mem->map;
367                 kobject_put(&map->kobj);
368         }
369         kobject_put(idev->map_dir);
370         dev_err(&idev->dev, "error creating sysfs files (%d)\n", ret);
371         return ret;
372 }
373
374 static void uio_dev_del_attributes(struct uio_device *idev)
375 {
376         int i;
377         struct uio_mem *mem;
378         struct uio_port *port;
379
380         for (i = 0; i < MAX_UIO_MAPS; i++) {
381                 mem = &idev->info->mem[i];
382                 if (mem->size == 0)
383                         break;
384                 kobject_put(&mem->map->kobj);
385         }
386         kobject_put(idev->map_dir);
387
388         for (i = 0; i < MAX_UIO_PORT_REGIONS; i++) {
389                 port = &idev->info->port[i];
390                 if (port->size == 0)
391                         break;
392                 kobject_put(&port->portio->kobj);
393         }
394         kobject_put(idev->portio_dir);
395 }
396
397 static int uio_get_minor(struct uio_device *idev)
398 {
399         int retval = -ENOMEM;
400
401         mutex_lock(&minor_lock);
402         retval = idr_alloc(&uio_idr, idev, 0, UIO_MAX_DEVICES, GFP_KERNEL);
403         if (retval >= 0) {
404                 idev->minor = retval;
405                 retval = 0;
406         } else if (retval == -ENOSPC) {
407                 dev_err(&idev->dev, "too many uio devices\n");
408                 retval = -EINVAL;
409         }
410         mutex_unlock(&minor_lock);
411         return retval;
412 }
413
414 static void uio_free_minor(struct uio_device *idev)
415 {
416         mutex_lock(&minor_lock);
417         idr_remove(&uio_idr, idev->minor);
418         mutex_unlock(&minor_lock);
419 }
420
421 /**
422  * uio_event_notify - trigger an interrupt event
423  * @info: UIO device capabilities
424  */
425 void uio_event_notify(struct uio_info *info)
426 {
427         struct uio_device *idev = info->uio_dev;
428
429         atomic_inc(&idev->event);
430         wake_up_interruptible(&idev->wait);
431         kill_fasync(&idev->async_queue, SIGIO, POLL_IN);
432 }
433 EXPORT_SYMBOL_GPL(uio_event_notify);
434
435 /**
436  * uio_interrupt - hardware interrupt handler
437  * @irq: IRQ number, can be UIO_IRQ_CYCLIC for cyclic timer
438  * @dev_id: Pointer to the devices uio_device structure
439  */
440 static irqreturn_t uio_interrupt(int irq, void *dev_id)
441 {
442         struct uio_device *idev = (struct uio_device *)dev_id;
443         irqreturn_t ret;
444
445         ret = idev->info->handler(irq, idev->info);
446         if (ret == IRQ_HANDLED)
447                 uio_event_notify(idev->info);
448
449         return ret;
450 }
451
452 struct uio_listener {
453         struct uio_device *dev;
454         s32 event_count;
455 };
456
457 static int uio_open(struct inode *inode, struct file *filep)
458 {
459         struct uio_device *idev;
460         struct uio_listener *listener;
461         int ret = 0;
462
463         mutex_lock(&minor_lock);
464         idev = idr_find(&uio_idr, iminor(inode));
465         mutex_unlock(&minor_lock);
466         if (!idev) {
467                 ret = -ENODEV;
468                 goto out;
469         }
470
471         get_device(&idev->dev);
472
473         if (!try_module_get(idev->owner)) {
474                 ret = -ENODEV;
475                 goto err_module_get;
476         }
477
478         listener = kmalloc(sizeof(*listener), GFP_KERNEL);
479         if (!listener) {
480                 ret = -ENOMEM;
481                 goto err_alloc_listener;
482         }
483
484         listener->dev = idev;
485         listener->event_count = atomic_read(&idev->event);
486         filep->private_data = listener;
487
488         mutex_lock(&idev->info_lock);
489         if (!idev->info) {
490                 mutex_unlock(&idev->info_lock);
491                 ret = -EINVAL;
492                 goto err_alloc_listener;
493         }
494
495         if (idev->info && idev->info->open)
496                 ret = idev->info->open(idev->info, inode);
497         mutex_unlock(&idev->info_lock);
498         if (ret)
499                 goto err_infoopen;
500
501         return 0;
502
503 err_infoopen:
504         kfree(listener);
505
506 err_alloc_listener:
507         module_put(idev->owner);
508
509 err_module_get:
510         put_device(&idev->dev);
511
512 out:
513         return ret;
514 }
515
516 static int uio_fasync(int fd, struct file *filep, int on)
517 {
518         struct uio_listener *listener = filep->private_data;
519         struct uio_device *idev = listener->dev;
520
521         return fasync_helper(fd, filep, on, &idev->async_queue);
522 }
523
524 static int uio_release(struct inode *inode, struct file *filep)
525 {
526         int ret = 0;
527         struct uio_listener *listener = filep->private_data;
528         struct uio_device *idev = listener->dev;
529
530         mutex_lock(&idev->info_lock);
531         if (idev->info && idev->info->release)
532                 ret = idev->info->release(idev->info, inode);
533         mutex_unlock(&idev->info_lock);
534
535         module_put(idev->owner);
536         kfree(listener);
537         put_device(&idev->dev);
538         return ret;
539 }
540
541 static __poll_t uio_poll(struct file *filep, poll_table *wait)
542 {
543         struct uio_listener *listener = filep->private_data;
544         struct uio_device *idev = listener->dev;
545         __poll_t ret = 0;
546
547         mutex_lock(&idev->info_lock);
548         if (!idev->info || !idev->info->irq)
549                 ret = -EIO;
550         mutex_unlock(&idev->info_lock);
551
552         if (ret)
553                 return ret;
554
555         poll_wait(filep, &idev->wait, wait);
556         if (listener->event_count != atomic_read(&idev->event))
557                 return EPOLLIN | EPOLLRDNORM;
558         return 0;
559 }
560
561 static ssize_t uio_read(struct file *filep, char __user *buf,
562                         size_t count, loff_t *ppos)
563 {
564         struct uio_listener *listener = filep->private_data;
565         struct uio_device *idev = listener->dev;
566         DECLARE_WAITQUEUE(wait, current);
567         ssize_t retval = 0;
568         s32 event_count;
569
570         mutex_lock(&idev->info_lock);
571         if (!idev->info || !idev->info->irq)
572                 retval = -EIO;
573         mutex_unlock(&idev->info_lock);
574
575         if (retval)
576                 return retval;
577
578         if (count != sizeof(s32))
579                 return -EINVAL;
580
581         add_wait_queue(&idev->wait, &wait);
582
583         do {
584                 set_current_state(TASK_INTERRUPTIBLE);
585
586                 event_count = atomic_read(&idev->event);
587                 if (event_count != listener->event_count) {
588                         __set_current_state(TASK_RUNNING);
589                         if (copy_to_user(buf, &event_count, count))
590                                 retval = -EFAULT;
591                         else {
592                                 listener->event_count = event_count;
593                                 retval = count;
594                         }
595                         break;
596                 }
597
598                 if (filep->f_flags & O_NONBLOCK) {
599                         retval = -EAGAIN;
600                         break;
601                 }
602
603                 if (signal_pending(current)) {
604                         retval = -ERESTARTSYS;
605                         break;
606                 }
607                 schedule();
608         } while (1);
609
610         __set_current_state(TASK_RUNNING);
611         remove_wait_queue(&idev->wait, &wait);
612
613         return retval;
614 }
615
616 static ssize_t uio_write(struct file *filep, const char __user *buf,
617                         size_t count, loff_t *ppos)
618 {
619         struct uio_listener *listener = filep->private_data;
620         struct uio_device *idev = listener->dev;
621         ssize_t retval;
622         s32 irq_on;
623
624         if (count != sizeof(s32))
625                 return -EINVAL;
626
627         if (copy_from_user(&irq_on, buf, count))
628                 return -EFAULT;
629
630         mutex_lock(&idev->info_lock);
631         if (!idev->info) {
632                 retval = -EINVAL;
633                 goto out;
634         }
635
636         if (!idev->info || !idev->info->irq) {
637                 retval = -EIO;
638                 goto out;
639         }
640
641         if (!idev->info->irqcontrol) {
642                 retval = -ENOSYS;
643                 goto out;
644         }
645
646         retval = idev->info->irqcontrol(idev->info, irq_on);
647
648 out:
649         mutex_unlock(&idev->info_lock);
650         return retval ? retval : sizeof(s32);
651 }
652
653 static int uio_find_mem_index(struct vm_area_struct *vma)
654 {
655         struct uio_device *idev = vma->vm_private_data;
656
657         if (vma->vm_pgoff < MAX_UIO_MAPS) {
658                 if (idev->info->mem[vma->vm_pgoff].size == 0)
659                         return -1;
660                 return (int)vma->vm_pgoff;
661         }
662         return -1;
663 }
664
665 static vm_fault_t uio_vma_fault(struct vm_fault *vmf)
666 {
667         struct uio_device *idev = vmf->vma->vm_private_data;
668         struct page *page;
669         unsigned long offset;
670         void *addr;
671         int ret = 0;
672         int mi;
673
674         mutex_lock(&idev->info_lock);
675         if (!idev->info) {
676                 ret = VM_FAULT_SIGBUS;
677                 goto out;
678         }
679
680         mi = uio_find_mem_index(vmf->vma);
681         if (mi < 0) {
682                 ret = VM_FAULT_SIGBUS;
683                 goto out;
684         }
685
686         /*
687          * We need to subtract mi because userspace uses offset = N*PAGE_SIZE
688          * to use mem[N].
689          */
690         offset = (vmf->pgoff - mi) << PAGE_SHIFT;
691
692         addr = (void *)(unsigned long)idev->info->mem[mi].addr + offset;
693         if (idev->info->mem[mi].memtype == UIO_MEM_LOGICAL)
694                 page = virt_to_page(addr);
695         else
696                 page = vmalloc_to_page(addr);
697         get_page(page);
698         vmf->page = page;
699
700 out:
701         mutex_unlock(&idev->info_lock);
702
703         return ret;
704 }
705
706 static const struct vm_operations_struct uio_logical_vm_ops = {
707         .fault = uio_vma_fault,
708 };
709
710 static int uio_mmap_logical(struct vm_area_struct *vma)
711 {
712         vma->vm_flags |= VM_DONTEXPAND | VM_DONTDUMP;
713         vma->vm_ops = &uio_logical_vm_ops;
714         return 0;
715 }
716
717 static const struct vm_operations_struct uio_physical_vm_ops = {
718 #ifdef CONFIG_HAVE_IOREMAP_PROT
719         .access = generic_access_phys,
720 #endif
721 };
722
723 static int uio_mmap_physical(struct vm_area_struct *vma)
724 {
725         struct uio_device *idev = vma->vm_private_data;
726         int mi = uio_find_mem_index(vma);
727         struct uio_mem *mem;
728
729         if (mi < 0)
730                 return -EINVAL;
731         mem = idev->info->mem + mi;
732
733         if (mem->addr & ~PAGE_MASK)
734                 return -ENODEV;
735         if (vma->vm_end - vma->vm_start > mem->size)
736                 return -EINVAL;
737
738         vma->vm_ops = &uio_physical_vm_ops;
739         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
740
741         /*
742          * We cannot use the vm_iomap_memory() helper here,
743          * because vma->vm_pgoff is the map index we looked
744          * up above in uio_find_mem_index(), rather than an
745          * actual page offset into the mmap.
746          *
747          * So we just do the physical mmap without a page
748          * offset.
749          */
750         return remap_pfn_range(vma,
751                                vma->vm_start,
752                                mem->addr >> PAGE_SHIFT,
753                                vma->vm_end - vma->vm_start,
754                                vma->vm_page_prot);
755 }
756
757 static int uio_mmap(struct file *filep, struct vm_area_struct *vma)
758 {
759         struct uio_listener *listener = filep->private_data;
760         struct uio_device *idev = listener->dev;
761         int mi;
762         unsigned long requested_pages, actual_pages;
763         int ret = 0;
764
765         if (vma->vm_end < vma->vm_start)
766                 return -EINVAL;
767
768         vma->vm_private_data = idev;
769
770         mutex_lock(&idev->info_lock);
771         if (!idev->info) {
772                 ret = -EINVAL;
773                 goto out;
774         }
775
776         mi = uio_find_mem_index(vma);
777         if (mi < 0) {
778                 ret = -EINVAL;
779                 goto out;
780         }
781
782         requested_pages = vma_pages(vma);
783         actual_pages = ((idev->info->mem[mi].addr & ~PAGE_MASK)
784                         + idev->info->mem[mi].size + PAGE_SIZE -1) >> PAGE_SHIFT;
785         if (requested_pages > actual_pages) {
786                 ret = -EINVAL;
787                 goto out;
788         }
789
790         if (idev->info->mmap) {
791                 ret = idev->info->mmap(idev->info, vma);
792                 goto out;
793         }
794
795         switch (idev->info->mem[mi].memtype) {
796                 case UIO_MEM_PHYS:
797                         ret = uio_mmap_physical(vma);
798                         break;
799                 case UIO_MEM_LOGICAL:
800                 case UIO_MEM_VIRTUAL:
801                         ret = uio_mmap_logical(vma);
802                         break;
803                 default:
804                         ret = -EINVAL;
805         }
806
807 out:
808         mutex_unlock(&idev->info_lock);
809         return ret;
810 }
811
812 static const struct file_operations uio_fops = {
813         .owner          = THIS_MODULE,
814         .open           = uio_open,
815         .release        = uio_release,
816         .read           = uio_read,
817         .write          = uio_write,
818         .mmap           = uio_mmap,
819         .poll           = uio_poll,
820         .fasync         = uio_fasync,
821         .llseek         = noop_llseek,
822 };
823
824 static int uio_major_init(void)
825 {
826         static const char name[] = "uio";
827         struct cdev *cdev = NULL;
828         dev_t uio_dev = 0;
829         int result;
830
831         result = alloc_chrdev_region(&uio_dev, 0, UIO_MAX_DEVICES, name);
832         if (result)
833                 goto out;
834
835         result = -ENOMEM;
836         cdev = cdev_alloc();
837         if (!cdev)
838                 goto out_unregister;
839
840         cdev->owner = THIS_MODULE;
841         cdev->ops = &uio_fops;
842         kobject_set_name(&cdev->kobj, "%s", name);
843
844         result = cdev_add(cdev, uio_dev, UIO_MAX_DEVICES);
845         if (result)
846                 goto out_put;
847
848         uio_major = MAJOR(uio_dev);
849         uio_cdev = cdev;
850         return 0;
851 out_put:
852         kobject_put(&cdev->kobj);
853 out_unregister:
854         unregister_chrdev_region(uio_dev, UIO_MAX_DEVICES);
855 out:
856         return result;
857 }
858
859 static void uio_major_cleanup(void)
860 {
861         unregister_chrdev_region(MKDEV(uio_major, 0), UIO_MAX_DEVICES);
862         cdev_del(uio_cdev);
863 }
864
865 static int init_uio_class(void)
866 {
867         int ret;
868
869         /* This is the first time in here, set everything up properly */
870         ret = uio_major_init();
871         if (ret)
872                 goto exit;
873
874         ret = class_register(&uio_class);
875         if (ret) {
876                 printk(KERN_ERR "class_register failed for uio\n");
877                 goto err_class_register;
878         }
879         return 0;
880
881 err_class_register:
882         uio_major_cleanup();
883 exit:
884         return ret;
885 }
886
887 static void release_uio_class(void)
888 {
889         class_unregister(&uio_class);
890         uio_major_cleanup();
891 }
892
893 static void uio_device_release(struct device *dev)
894 {
895         struct uio_device *idev = dev_get_drvdata(dev);
896
897         kfree(idev);
898 }
899
900 /**
901  * uio_register_device - register a new userspace IO device
902  * @owner:      module that creates the new device
903  * @parent:     parent device
904  * @info:       UIO device capabilities
905  *
906  * returns zero on success or a negative error code.
907  */
908 int __uio_register_device(struct module *owner,
909                           struct device *parent,
910                           struct uio_info *info)
911 {
912         struct uio_device *idev;
913         int ret = 0;
914
915         if (!parent || !info || !info->name || !info->version)
916                 return -EINVAL;
917
918         info->uio_dev = NULL;
919
920         idev = kzalloc(sizeof(*idev), GFP_KERNEL);
921         if (!idev) {
922                 return -ENOMEM;
923         }
924
925         idev->owner = owner;
926         idev->info = info;
927         mutex_init(&idev->info_lock);
928         init_waitqueue_head(&idev->wait);
929         atomic_set(&idev->event, 0);
930
931         ret = uio_get_minor(idev);
932         if (ret)
933                 return ret;
934
935         idev->dev.devt = MKDEV(uio_major, idev->minor);
936         idev->dev.class = &uio_class;
937         idev->dev.parent = parent;
938         idev->dev.release = uio_device_release;
939         dev_set_drvdata(&idev->dev, idev);
940
941         ret = dev_set_name(&idev->dev, "uio%d", idev->minor);
942         if (ret)
943                 goto err_device_create;
944
945         ret = device_register(&idev->dev);
946         if (ret)
947                 goto err_device_create;
948
949         ret = uio_dev_add_attributes(idev);
950         if (ret)
951                 goto err_uio_dev_add_attributes;
952
953         if (info->irq && (info->irq != UIO_IRQ_CUSTOM)) {
954                 /*
955                  * Note that we deliberately don't use devm_request_irq
956                  * here. The parent module can unregister the UIO device
957                  * and call pci_disable_msi, which requires that this
958                  * irq has been freed. However, the device may have open
959                  * FDs at the time of unregister and therefore may not be
960                  * freed until they are released.
961                  */
962                 ret = request_irq(info->irq, uio_interrupt,
963                                   info->irq_flags, info->name, idev);
964                 if (ret)
965                         goto err_request_irq;
966         }
967
968         info->uio_dev = idev;
969         return 0;
970
971 err_request_irq:
972         uio_dev_del_attributes(idev);
973 err_uio_dev_add_attributes:
974         device_unregister(&idev->dev);
975 err_device_create:
976         uio_free_minor(idev);
977         return ret;
978 }
979 EXPORT_SYMBOL_GPL(__uio_register_device);
980
981 /**
982  * uio_unregister_device - unregister a industrial IO device
983  * @info:       UIO device capabilities
984  *
985  */
986 void uio_unregister_device(struct uio_info *info)
987 {
988         struct uio_device *idev;
989
990         if (!info || !info->uio_dev)
991                 return;
992
993         idev = info->uio_dev;
994
995         uio_free_minor(idev);
996
997         mutex_lock(&idev->info_lock);
998         uio_dev_del_attributes(idev);
999
1000         if (info->irq && info->irq != UIO_IRQ_CUSTOM)
1001                 free_irq(info->irq, idev);
1002
1003         idev->info = NULL;
1004         mutex_unlock(&idev->info_lock);
1005
1006         device_unregister(&idev->dev);
1007
1008         return;
1009 }
1010 EXPORT_SYMBOL_GPL(uio_unregister_device);
1011
1012 static int __init uio_init(void)
1013 {
1014         return init_uio_class();
1015 }
1016
1017 static void __exit uio_exit(void)
1018 {
1019         release_uio_class();
1020         idr_destroy(&uio_idr);
1021 }
1022
1023 module_init(uio_init)
1024 module_exit(uio_exit)
1025 MODULE_LICENSE("GPL v2");