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