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