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