drivers/uio/uio.c

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