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