1
2
3
4
5
6
7
8
9
10
11
12
13
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
28struct 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};
39
40static int uio_major;
41static DEFINE_IDR(uio_idr);
42static const struct file_operations uio_fops;
43
44
45static struct uio_class {
46 struct kref kref;
47 struct class *class;
48} *uio_class;
49
50
51
52
53
54struct uio_map {
55 struct kobject kobj;
56 struct uio_mem *mem;
57};
58#define to_map(map) container_of(map, struct uio_map, kobj)
59
60static ssize_t map_addr_show(struct uio_mem *mem, char *buf)
61{
62 return sprintf(buf, "0x%lx\n", mem->addr);
63}
64
65static ssize_t map_size_show(struct uio_mem *mem, char *buf)
66{
67 return sprintf(buf, "0x%lx\n", mem->size);
68}
69
70struct uio_sysfs_entry {
71 struct attribute attr;
72 ssize_t (*show)(struct uio_mem *, char *);
73 ssize_t (*store)(struct uio_mem *, const char *, size_t);
74};
75
76static struct uio_sysfs_entry addr_attribute =
77 __ATTR(addr, S_IRUGO, map_addr_show, NULL);
78static struct uio_sysfs_entry size_attribute =
79 __ATTR(size, S_IRUGO, map_size_show, NULL);
80
81static struct attribute *attrs[] = {
82 &addr_attribute.attr,
83 &size_attribute.attr,
84 NULL,
85};
86
87static void map_release(struct kobject *kobj)
88{
89 struct uio_map *map = to_map(kobj);
90 kfree(map);
91}
92
93static ssize_t map_type_show(struct kobject *kobj, struct attribute *attr,
94 char *buf)
95{
96 struct uio_map *map = to_map(kobj);
97 struct uio_mem *mem = map->mem;
98 struct uio_sysfs_entry *entry;
99
100 entry = container_of(attr, struct uio_sysfs_entry, attr);
101
102 if (!entry->show)
103 return -EIO;
104
105 return entry->show(mem, buf);
106}
107
108static struct sysfs_ops uio_sysfs_ops = {
109 .show = map_type_show,
110};
111
112static struct kobj_type map_attr_type = {
113 .release = map_release,
114 .sysfs_ops = &uio_sysfs_ops,
115 .default_attrs = attrs,
116};
117
118static ssize_t show_name(struct device *dev,
119 struct device_attribute *attr, char *buf)
120{
121 struct uio_device *idev = dev_get_drvdata(dev);
122 if (idev)
123 return sprintf(buf, "%s\n", idev->info->name);
124 else
125 return -ENODEV;
126}
127static DEVICE_ATTR(name, S_IRUGO, show_name, NULL);
128
129static ssize_t show_version(struct device *dev,
130 struct device_attribute *attr, char *buf)
131{
132 struct uio_device *idev = dev_get_drvdata(dev);
133 if (idev)
134 return sprintf(buf, "%s\n", idev->info->version);
135 else
136 return -ENODEV;
137}
138static DEVICE_ATTR(version, S_IRUGO, show_version, NULL);
139
140static ssize_t show_event(struct device *dev,
141 struct device_attribute *attr, char *buf)
142{
143 struct uio_device *idev = dev_get_drvdata(dev);
144 if (idev)
145 return sprintf(buf, "%u\n",
146 (unsigned int)atomic_read(&idev->event));
147 else
148 return -ENODEV;
149}
150static DEVICE_ATTR(event, S_IRUGO, show_event, NULL);
151
152static struct attribute *uio_attrs[] = {
153 &dev_attr_name.attr,
154 &dev_attr_version.attr,
155 &dev_attr_event.attr,
156 NULL,
157};
158
159static struct attribute_group uio_attr_grp = {
160 .attrs = uio_attrs,
161};
162
163
164
165
166static int uio_dev_add_attributes(struct uio_device *idev)
167{
168 int ret;
169 int mi;
170 int map_found = 0;
171 struct uio_mem *mem;
172 struct uio_map *map;
173
174 ret = sysfs_create_group(&idev->dev->kobj, &uio_attr_grp);
175 if (ret)
176 goto err_group;
177
178 for (mi = 0; mi < MAX_UIO_MAPS; mi++) {
179 mem = &idev->info->mem[mi];
180 if (mem->size == 0)
181 break;
182 if (!map_found) {
183 map_found = 1;
184 idev->map_dir = kobject_create_and_add("maps",
185 &idev->dev->kobj);
186 if (!idev->map_dir)
187 goto err;
188 }
189 map = kzalloc(sizeof(*map), GFP_KERNEL);
190 if (!map)
191 goto err;
192 kobject_init(&map->kobj, &map_attr_type);
193 map->mem = mem;
194 mem->map = map;
195 ret = kobject_add(&map->kobj, idev->map_dir, "map%d", mi);
196 if (ret)
197 goto err;
198 ret = kobject_uevent(&map->kobj, KOBJ_ADD);
199 if (ret)
200 goto err;
201 }
202
203 return 0;
204
205err:
206 for (mi--; mi>=0; mi--) {
207 mem = &idev->info->mem[mi];
208 map = mem->map;
209 kobject_put(&map->kobj);
210 }
211 kobject_put(idev->map_dir);
212 sysfs_remove_group(&idev->dev->kobj, &uio_attr_grp);
213err_group:
214 dev_err(idev->dev, "error creating sysfs files (%d)\n", ret);
215 return ret;
216}
217
218static void uio_dev_del_attributes(struct uio_device *idev)
219{
220 int mi;
221 struct uio_mem *mem;
222 for (mi = 0; mi < MAX_UIO_MAPS; mi++) {
223 mem = &idev->info->mem[mi];
224 if (mem->size == 0)
225 break;
226 kobject_put(&mem->map->kobj);
227 }
228 kobject_put(idev->map_dir);
229 sysfs_remove_group(&idev->dev->kobj, &uio_attr_grp);
230}
231
232static int uio_get_minor(struct uio_device *idev)
233{
234 static DEFINE_MUTEX(minor_lock);
235 int retval = -ENOMEM;
236 int id;
237
238 mutex_lock(&minor_lock);
239 if (idr_pre_get(&uio_idr, GFP_KERNEL) == 0)
240 goto exit;
241
242 retval = idr_get_new(&uio_idr, idev, &id);
243 if (retval < 0) {
244 if (retval == -EAGAIN)
245 retval = -ENOMEM;
246 goto exit;
247 }
248 idev->minor = id & MAX_ID_MASK;
249exit:
250 mutex_unlock(&minor_lock);
251 return retval;
252}
253
254static void uio_free_minor(struct uio_device *idev)
255{
256 idr_remove(&uio_idr, idev->minor);
257}
258
259
260
261
262
263void uio_event_notify(struct uio_info *info)
264{
265 struct uio_device *idev = info->uio_dev;
266
267 atomic_inc(&idev->event);
268 wake_up_interruptible(&idev->wait);
269 kill_fasync(&idev->async_queue, SIGIO, POLL_IN);
270}
271EXPORT_SYMBOL_GPL(uio_event_notify);
272
273
274
275
276
277
278static irqreturn_t uio_interrupt(int irq, void *dev_id)
279{
280 struct uio_device *idev = (struct uio_device *)dev_id;
281 irqreturn_t ret = idev->info->handler(irq, idev->info);
282
283 if (ret == IRQ_HANDLED)
284 uio_event_notify(idev->info);
285
286 return ret;
287}
288
289struct uio_listener {
290 struct uio_device *dev;
291 s32 event_count;
292};
293
294static int uio_open(struct inode *inode, struct file *filep)
295{
296 struct uio_device *idev;
297 struct uio_listener *listener;
298 int ret = 0;
299
300 idev = idr_find(&uio_idr, iminor(inode));
301 if (!idev)
302 return -ENODEV;
303
304 listener = kmalloc(sizeof(*listener), GFP_KERNEL);
305 if (!listener)
306 return -ENOMEM;
307
308 listener->dev = idev;
309 listener->event_count = atomic_read(&idev->event);
310 filep->private_data = listener;
311
312 if (idev->info->open) {
313 if (!try_module_get(idev->owner))
314 return -ENODEV;
315 ret = idev->info->open(idev->info, inode);
316 module_put(idev->owner);
317 }
318
319 if (ret)
320 kfree(listener);
321
322 return ret;
323}
324
325static int uio_fasync(int fd, struct file *filep, int on)
326{
327 struct uio_listener *listener = filep->private_data;
328 struct uio_device *idev = listener->dev;
329
330 return fasync_helper(fd, filep, on, &idev->async_queue);
331}
332
333static int uio_release(struct inode *inode, struct file *filep)
334{
335 int ret = 0;
336 struct uio_listener *listener = filep->private_data;
337 struct uio_device *idev = listener->dev;
338
339 if (idev->info->release) {
340 if (!try_module_get(idev->owner))
341 return -ENODEV;
342 ret = idev->info->release(idev->info, inode);
343 module_put(idev->owner);
344 }
345 if (filep->f_flags & FASYNC)
346 ret = uio_fasync(-1, filep, 0);
347 kfree(listener);
348 return ret;
349}
350
351static unsigned int uio_poll(struct file *filep, poll_table *wait)
352{
353 struct uio_listener *listener = filep->private_data;
354 struct uio_device *idev = listener->dev;
355
356 if (idev->info->irq == UIO_IRQ_NONE)
357 return -EIO;
358
359 poll_wait(filep, &idev->wait, wait);
360 if (listener->event_count != atomic_read(&idev->event))
361 return POLLIN | POLLRDNORM;
362 return 0;
363}
364
365static ssize_t uio_read(struct file *filep, char __user *buf,
366 size_t count, loff_t *ppos)
367{
368 struct uio_listener *listener = filep->private_data;
369 struct uio_device *idev = listener->dev;
370 DECLARE_WAITQUEUE(wait, current);
371 ssize_t retval;
372 s32 event_count;
373
374 if (idev->info->irq == UIO_IRQ_NONE)
375 return -EIO;
376
377 if (count != sizeof(s32))
378 return -EINVAL;
379
380 add_wait_queue(&idev->wait, &wait);
381
382 do {
383 set_current_state(TASK_INTERRUPTIBLE);
384
385 event_count = atomic_read(&idev->event);
386 if (event_count != listener->event_count) {
387 if (copy_to_user(buf, &event_count, count))
388 retval = -EFAULT;
389 else {
390 listener->event_count = event_count;
391 retval = count;
392 }
393 break;
394 }
395
396 if (filep->f_flags & O_NONBLOCK) {
397 retval = -EAGAIN;
398 break;
399 }
400
401 if (signal_pending(current)) {
402 retval = -ERESTARTSYS;
403 break;
404 }
405 schedule();
406 } while (1);
407
408 __set_current_state(TASK_RUNNING);
409 remove_wait_queue(&idev->wait, &wait);
410
411 return retval;
412}
413
414static int uio_find_mem_index(struct vm_area_struct *vma)
415{
416 int mi;
417 struct uio_device *idev = vma->vm_private_data;
418
419 for (mi = 0; mi < MAX_UIO_MAPS; mi++) {
420 if (idev->info->mem[mi].size == 0)
421 return -1;
422 if (vma->vm_pgoff == mi)
423 return mi;
424 }
425 return -1;
426}
427
428static void uio_vma_open(struct vm_area_struct *vma)
429{
430 struct uio_device *idev = vma->vm_private_data;
431 idev->vma_count++;
432}
433
434static void uio_vma_close(struct vm_area_struct *vma)
435{
436 struct uio_device *idev = vma->vm_private_data;
437 idev->vma_count--;
438}
439
440static int uio_vma_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
441{
442 struct uio_device *idev = vma->vm_private_data;
443 struct page *page;
444
445 int mi = uio_find_mem_index(vma);
446 if (mi < 0)
447 return VM_FAULT_SIGBUS;
448
449 if (idev->info->mem[mi].memtype == UIO_MEM_LOGICAL)
450 page = virt_to_page(idev->info->mem[mi].addr);
451 else
452 page = vmalloc_to_page((void*)idev->info->mem[mi].addr);
453 get_page(page);
454 vmf->page = page;
455 return 0;
456}
457
458static struct vm_operations_struct uio_vm_ops = {
459 .open = uio_vma_open,
460 .close = uio_vma_close,
461 .fault = uio_vma_fault,
462};
463
464static int uio_mmap_physical(struct vm_area_struct *vma)
465{
466 struct uio_device *idev = vma->vm_private_data;
467 int mi = uio_find_mem_index(vma);
468 if (mi < 0)
469 return -EINVAL;
470
471 vma->vm_flags |= VM_IO | VM_RESERVED;
472
473 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
474
475 return remap_pfn_range(vma,
476 vma->vm_start,
477 idev->info->mem[mi].addr >> PAGE_SHIFT,
478 vma->vm_end - vma->vm_start,
479 vma->vm_page_prot);
480}
481
482static int uio_mmap_logical(struct vm_area_struct *vma)
483{
484 vma->vm_flags |= VM_RESERVED;
485 vma->vm_ops = &uio_vm_ops;
486 uio_vma_open(vma);
487 return 0;
488}
489
490static int uio_mmap(struct file *filep, struct vm_area_struct *vma)
491{
492 struct uio_listener *listener = filep->private_data;
493 struct uio_device *idev = listener->dev;
494 int mi;
495 unsigned long requested_pages, actual_pages;
496 int ret = 0;
497
498 if (vma->vm_end < vma->vm_start)
499 return -EINVAL;
500
501 vma->vm_private_data = idev;
502
503 mi = uio_find_mem_index(vma);
504 if (mi < 0)
505 return -EINVAL;
506
507 requested_pages = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
508 actual_pages = (idev->info->mem[mi].size + PAGE_SIZE -1) >> PAGE_SHIFT;
509 if (requested_pages > actual_pages)
510 return -EINVAL;
511
512 if (idev->info->mmap) {
513 if (!try_module_get(idev->owner))
514 return -ENODEV;
515 ret = idev->info->mmap(idev->info, vma);
516 module_put(idev->owner);
517 return ret;
518 }
519
520 switch (idev->info->mem[mi].memtype) {
521 case UIO_MEM_PHYS:
522 return uio_mmap_physical(vma);
523 case UIO_MEM_LOGICAL:
524 case UIO_MEM_VIRTUAL:
525 return uio_mmap_logical(vma);
526 default:
527 return -EINVAL;
528 }
529}
530
531static const struct file_operations uio_fops = {
532 .owner = THIS_MODULE,
533 .open = uio_open,
534 .release = uio_release,
535 .read = uio_read,
536 .mmap = uio_mmap,
537 .poll = uio_poll,
538 .fasync = uio_fasync,
539};
540
541static int uio_major_init(void)
542{
543 uio_major = register_chrdev(0, "uio", &uio_fops);
544 if (uio_major < 0)
545 return uio_major;
546 return 0;
547}
548
549static void uio_major_cleanup(void)
550{
551 unregister_chrdev(uio_major, "uio");
552}
553
554static int init_uio_class(void)
555{
556 int ret = 0;
557
558 if (uio_class != NULL) {
559 kref_get(&uio_class->kref);
560 goto exit;
561 }
562
563
564 ret = uio_major_init();
565 if (ret)
566 goto exit;
567
568 uio_class = kzalloc(sizeof(*uio_class), GFP_KERNEL);
569 if (!uio_class) {
570 ret = -ENOMEM;
571 goto err_kzalloc;
572 }
573
574 kref_init(&uio_class->kref);
575 uio_class->class = class_create(THIS_MODULE, "uio");
576 if (IS_ERR(uio_class->class)) {
577 ret = IS_ERR(uio_class->class);
578 printk(KERN_ERR "class_create failed for uio\n");
579 goto err_class_create;
580 }
581 return 0;
582
583err_class_create:
584 kfree(uio_class);
585 uio_class = NULL;
586err_kzalloc:
587 uio_major_cleanup();
588exit:
589 return ret;
590}
591
592static void release_uio_class(struct kref *kref)
593{
594
595 class_destroy(uio_class->class);
596 kfree(uio_class);
597 uio_major_cleanup();
598 uio_class = NULL;
599}
600
601static void uio_class_destroy(void)
602{
603 if (uio_class)
604 kref_put(&uio_class->kref, release_uio_class);
605}
606
607
608
609
610
611
612
613
614
615int __uio_register_device(struct module *owner,
616 struct device *parent,
617 struct uio_info *info)
618{
619 struct uio_device *idev;
620 int ret = 0;
621
622 if (!parent || !info || !info->name || !info->version)
623 return -EINVAL;
624
625 info->uio_dev = NULL;
626
627 ret = init_uio_class();
628 if (ret)
629 return ret;
630
631 idev = kzalloc(sizeof(*idev), GFP_KERNEL);
632 if (!idev) {
633 ret = -ENOMEM;
634 goto err_kzalloc;
635 }
636
637 idev->owner = owner;
638 idev->info = info;
639 init_waitqueue_head(&idev->wait);
640 atomic_set(&idev->event, 0);
641
642 ret = uio_get_minor(idev);
643 if (ret)
644 goto err_get_minor;
645
646 idev->dev = device_create(uio_class->class, parent,
647 MKDEV(uio_major, idev->minor),
648 "uio%d", idev->minor);
649 if (IS_ERR(idev->dev)) {
650 printk(KERN_ERR "UIO: device register failed\n");
651 ret = PTR_ERR(idev->dev);
652 goto err_device_create;
653 }
654 dev_set_drvdata(idev->dev, idev);
655
656 ret = uio_dev_add_attributes(idev);
657 if (ret)
658 goto err_uio_dev_add_attributes;
659
660 info->uio_dev = idev;
661
662 if (idev->info->irq >= 0) {
663 ret = request_irq(idev->info->irq, uio_interrupt,
664 idev->info->irq_flags, idev->info->name, idev);
665 if (ret)
666 goto err_request_irq;
667 }
668
669 return 0;
670
671err_request_irq:
672 uio_dev_del_attributes(idev);
673err_uio_dev_add_attributes:
674 device_destroy(uio_class->class, MKDEV(uio_major, idev->minor));
675err_device_create:
676 uio_free_minor(idev);
677err_get_minor:
678 kfree(idev);
679err_kzalloc:
680 uio_class_destroy();
681 return ret;
682}
683EXPORT_SYMBOL_GPL(__uio_register_device);
684
685
686
687
688
689
690void uio_unregister_device(struct uio_info *info)
691{
692 struct uio_device *idev;
693
694 if (!info || !info->uio_dev)
695 return;
696
697 idev = info->uio_dev;
698
699 uio_free_minor(idev);
700
701 if (info->irq >= 0)
702 free_irq(info->irq, idev);
703
704 uio_dev_del_attributes(idev);
705
706 dev_set_drvdata(idev->dev, NULL);
707 device_destroy(uio_class->class, MKDEV(uio_major, idev->minor));
708 kfree(idev);
709 uio_class_destroy();
710
711 return;
712}
713EXPORT_SYMBOL_GPL(uio_unregister_device);
714
715static int __init uio_init(void)
716{
717 return 0;
718}
719
720static void __exit uio_exit(void)
721{
722}
723
724module_init(uio_init)
725module_exit(uio_exit)
726MODULE_LICENSE("GPL v2");
727
