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