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