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