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