1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * USB Skeleton driver - 2.2 4 * 5 * Copyright (C) 2001-2004 Greg Kroah-Hartman (greg@kroah.com) 6 * 7 * This driver is based on the 2.6.3 version of drivers/usb/usb-skeleton.c 8 * but has been rewritten to be easier to read and use. 9 */ 10 11 #include <linux/kernel.h> 12 #include <linux/errno.h> 13 #include <linux/slab.h> 14 #include <linux/module.h> 15 #include <linux/kref.h> 16 #include <linux/uaccess.h> 17 #include <linux/usb.h> 18 #include <linux/mutex.h> 19 20 21 /* Define these values to match your devices */ 22 #define USB_SKEL_VENDOR_ID 0xfff0 23 #define USB_SKEL_PRODUCT_ID 0xfff0 24 25 /* table of devices that work with this driver */ 26 static const struct usb_device_id skel_table[] = { 27 { USB_DEVICE(USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID) }, 28 { } /* Terminating entry */ 29 }; 30 MODULE_DEVICE_TABLE(usb, skel_table); 31 32 33 /* Get a minor range for your devices from the usb maintainer */ 34 #define USB_SKEL_MINOR_BASE 192 35 36 /* our private defines. if this grows any larger, use your own .h file */ 37 #define MAX_TRANSFER (PAGE_SIZE - 512) 38 /* MAX_TRANSFER is chosen so that the VM is not stressed by 39 allocations > PAGE_SIZE and the number of packets in a page 40 is an integer 512 is the largest possible packet on EHCI */ 41 #define WRITES_IN_FLIGHT 8 42 /* arbitrarily chosen */ 43 44 /* Structure to hold all of our device specific stuff */ 45 struct usb_skel { 46 struct usb_device *udev; /* the usb device for this device */ 47 struct usb_interface *interface; /* the interface for this device */ 48 struct semaphore limit_sem; /* limiting the number of writes in progress */ 49 struct usb_anchor submitted; /* in case we need to retract our submissions */ 50 struct urb *bulk_in_urb; /* the urb to read data with */ 51 unsigned char *bulk_in_buffer; /* the buffer to receive data */ 52 size_t bulk_in_size; /* the size of the receive buffer */ 53 size_t bulk_in_filled; /* number of bytes in the buffer */ 54 size_t bulk_in_copied; /* already copied to user space */ 55 __u8 bulk_in_endpointAddr; /* the address of the bulk in endpoint */ 56 __u8 bulk_out_endpointAddr; /* the address of the bulk out endpoint */ 57 int errors; /* the last request tanked */ 58 bool ongoing_read; /* a read is going on */ 59 spinlock_t err_lock; /* lock for errors */ 60 struct kref kref; 61 struct mutex io_mutex; /* synchronize I/O with disconnect */ 62 wait_queue_head_t bulk_in_wait; /* to wait for an ongoing read */ 63 }; 64 #define to_skel_dev(d) container_of(d, struct usb_skel, kref) 65 66 static struct usb_driver skel_driver; 67 static void skel_draw_down(struct usb_skel *dev); 68 69 static void skel_delete(struct kref *kref) 70 { 71 struct usb_skel *dev = to_skel_dev(kref); 72 73 usb_free_urb(dev->bulk_in_urb); 74 usb_put_dev(dev->udev); 75 kfree(dev->bulk_in_buffer); 76 kfree(dev); 77 } 78 79 static int skel_open(struct inode *inode, struct file *file) 80 { 81 struct usb_skel *dev; 82 struct usb_interface *interface; 83 int subminor; 84 int retval = 0; 85 86 subminor = iminor(inode); 87 88 interface = usb_find_interface(&skel_driver, subminor); 89 if (!interface) { 90 pr_err("%s - error, can't find device for minor %d\n", 91 __func__, subminor); 92 retval = -ENODEV; 93 goto exit; 94 } 95 96 dev = usb_get_intfdata(interface); 97 if (!dev) { 98 retval = -ENODEV; 99 goto exit; 100 } 101 102 retval = usb_autopm_get_interface(interface); 103 if (retval) 104 goto exit; 105 106 /* increment our usage count for the device */ 107 kref_get(&dev->kref); 108 109 /* save our object in the file's private structure */ 110 file->private_data = dev; 111 112 exit: 113 return retval; 114 } 115 116 static int skel_release(struct inode *inode, struct file *file) 117 { 118 struct usb_skel *dev; 119 120 dev = file->private_data; 121 if (dev == NULL) 122 return -ENODEV; 123 124 /* allow the device to be autosuspended */ 125 mutex_lock(&dev->io_mutex); 126 if (dev->interface) 127 usb_autopm_put_interface(dev->interface); 128 mutex_unlock(&dev->io_mutex); 129 130 /* decrement the count on our device */ 131 kref_put(&dev->kref, skel_delete); 132 return 0; 133 } 134 135 static int skel_flush(struct file *file, fl_owner_t id) 136 { 137 struct usb_skel *dev; 138 int res; 139 140 dev = file->private_data; 141 if (dev == NULL) 142 return -ENODEV; 143 144 /* wait for io to stop */ 145 mutex_lock(&dev->io_mutex); 146 skel_draw_down(dev); 147 148 /* read out errors, leave subsequent opens a clean slate */ 149 spin_lock_irq(&dev->err_lock); 150 res = dev->errors ? (dev->errors == -EPIPE ? -EPIPE : -EIO) : 0; 151 dev->errors = 0; 152 spin_unlock_irq(&dev->err_lock); 153 154 mutex_unlock(&dev->io_mutex); 155 156 return res; 157 } 158 159 static void skel_read_bulk_callback(struct urb *urb) 160 { 161 struct usb_skel *dev; 162 163 dev = urb->context; 164 165 spin_lock(&dev->err_lock); 166 /* sync/async unlink faults aren't errors */ 167 if (urb->status) { 168 if (!(urb->status == -ENOENT || 169 urb->status == -ECONNRESET || 170 urb->status == -ESHUTDOWN)) 171 dev_err(&dev->interface->dev, 172 "%s - nonzero write bulk status received: %d\n", 173 __func__, urb->status); 174 175 dev->errors = urb->status; 176 } else { 177 dev->bulk_in_filled = urb->actual_length; 178 } 179 dev->ongoing_read = 0; 180 spin_unlock(&dev->err_lock); 181 182 wake_up_interruptible(&dev->bulk_in_wait); 183 } 184 185 static int skel_do_read_io(struct usb_skel *dev, size_t count) 186 { 187 int rv; 188 189 /* prepare a read */ 190 usb_fill_bulk_urb(dev->bulk_in_urb, 191 dev->udev, 192 usb_rcvbulkpipe(dev->udev, 193 dev->bulk_in_endpointAddr), 194 dev->bulk_in_buffer, 195 min(dev->bulk_in_size, count), 196 skel_read_bulk_callback, 197 dev); 198 /* tell everybody to leave the URB alone */ 199 spin_lock_irq(&dev->err_lock); 200 dev->ongoing_read = 1; 201 spin_unlock_irq(&dev->err_lock); 202 203 /* submit bulk in urb, which means no data to deliver */ 204 dev->bulk_in_filled = 0; 205 dev->bulk_in_copied = 0; 206 207 /* do it */ 208 rv = usb_submit_urb(dev->bulk_in_urb, GFP_KERNEL); 209 if (rv < 0) { 210 dev_err(&dev->interface->dev, 211 "%s - failed submitting read urb, error %d\n", 212 __func__, rv); 213 rv = (rv == -ENOMEM) ? rv : -EIO; 214 spin_lock_irq(&dev->err_lock); 215 dev->ongoing_read = 0; 216 spin_unlock_irq(&dev->err_lock); 217 } 218 219 return rv; 220 } 221 222 static ssize_t skel_read(struct file *file, char *buffer, size_t count, 223 loff_t *ppos) 224 { 225 struct usb_skel *dev; 226 int rv; 227 bool ongoing_io; 228 229 dev = file->private_data; 230 231 /* if we cannot read at all, return EOF */ 232 if (!dev->bulk_in_urb || !count) 233 return 0; 234 235 /* no concurrent readers */ 236 rv = mutex_lock_interruptible(&dev->io_mutex); 237 if (rv < 0) 238 return rv; 239 240 if (!dev->interface) { /* disconnect() was called */ 241 rv = -ENODEV; 242 goto exit; 243 } 244 245 /* if IO is under way, we must not touch things */ 246 retry: 247 spin_lock_irq(&dev->err_lock); 248 ongoing_io = dev->ongoing_read; 249 spin_unlock_irq(&dev->err_lock); 250 251 if (ongoing_io) { 252 /* nonblocking IO shall not wait */ 253 if (file->f_flags & O_NONBLOCK) { 254 rv = -EAGAIN; 255 goto exit; 256 } 257 /* 258 * IO may take forever 259 * hence wait in an interruptible state 260 */ 261 rv = wait_event_interruptible(dev->bulk_in_wait, (!dev->ongoing_read)); 262 if (rv < 0) 263 goto exit; 264 } 265 266 /* errors must be reported */ 267 rv = dev->errors; 268 if (rv < 0) { 269 /* any error is reported once */ 270 dev->errors = 0; 271 /* to preserve notifications about reset */ 272 rv = (rv == -EPIPE) ? rv : -EIO; 273 /* report it */ 274 goto exit; 275 } 276 277 /* 278 * if the buffer is filled we may satisfy the read 279 * else we need to start IO 280 */ 281 282 if (dev->bulk_in_filled) { 283 /* we had read data */ 284 size_t available = dev->bulk_in_filled - dev->bulk_in_copied; 285 size_t chunk = min(available, count); 286 287 if (!available) { 288 /* 289 * all data has been used 290 * actual IO needs to be done 291 */ 292 rv = skel_do_read_io(dev, count); 293 if (rv < 0) 294 goto exit; 295 else 296 goto retry; 297 } 298 /* 299 * data is available 300 * chunk tells us how much shall be copied 301 */ 302 303 if (copy_to_user(buffer, 304 dev->bulk_in_buffer + dev->bulk_in_copied, 305 chunk)) 306 rv = -EFAULT; 307 else 308 rv = chunk; 309 310 dev->bulk_in_copied += chunk; 311 312 /* 313 * if we are asked for more than we have, 314 * we start IO but don't wait 315 */ 316 if (available < count) 317 skel_do_read_io(dev, count - chunk); 318 } else { 319 /* no data in the buffer */ 320 rv = skel_do_read_io(dev, count); 321 if (rv < 0) 322 goto exit; 323 else 324 goto retry; 325 } 326 exit: 327 mutex_unlock(&dev->io_mutex); 328 return rv; 329 } 330 331 static void skel_write_bulk_callback(struct urb *urb) 332 { 333 struct usb_skel *dev; 334 335 dev = urb->context; 336 337 /* sync/async unlink faults aren't errors */ 338 if (urb->status) { 339 if (!(urb->status == -ENOENT || 340 urb->status == -ECONNRESET || 341 urb->status == -ESHUTDOWN)) 342 dev_err(&dev->interface->dev, 343 "%s - nonzero write bulk status received: %d\n", 344 __func__, urb->status); 345 346 spin_lock(&dev->err_lock); 347 dev->errors = urb->status; 348 spin_unlock(&dev->err_lock); 349 } 350 351 /* free up our allocated buffer */ 352 usb_free_coherent(urb->dev, urb->transfer_buffer_length, 353 urb->transfer_buffer, urb->transfer_dma); 354 up(&dev->limit_sem); 355 } 356 357 static ssize_t skel_write(struct file *file, const char *user_buffer, 358 size_t count, loff_t *ppos) 359 { 360 struct usb_skel *dev; 361 int retval = 0; 362 struct urb *urb = NULL; 363 char *buf = NULL; 364 size_t writesize = min(count, (size_t)MAX_TRANSFER); 365 366 dev = file->private_data; 367 368 /* verify that we actually have some data to write */ 369 if (count == 0) 370 goto exit; 371 372 /* 373 * limit the number of URBs in flight to stop a user from using up all 374 * RAM 375 */ 376 if (!(file->f_flags & O_NONBLOCK)) { 377 if (down_interruptible(&dev->limit_sem)) { 378 retval = -ERESTARTSYS; 379 goto exit; 380 } 381 } else { 382 if (down_trylock(&dev->limit_sem)) { 383 retval = -EAGAIN; 384 goto exit; 385 } 386 } 387 388 spin_lock_irq(&dev->err_lock); 389 retval = dev->errors; 390 if (retval < 0) { 391 /* any error is reported once */ 392 dev->errors = 0; 393 /* to preserve notifications about reset */ 394 retval = (retval == -EPIPE) ? retval : -EIO; 395 } 396 spin_unlock_irq(&dev->err_lock); 397 if (retval < 0) 398 goto error; 399 400 /* create a urb, and a buffer for it, and copy the data to the urb */ 401 urb = usb_alloc_urb(0, GFP_KERNEL); 402 if (!urb) { 403 retval = -ENOMEM; 404 goto error; 405 } 406 407 buf = usb_alloc_coherent(dev->udev, writesize, GFP_KERNEL, 408 &urb->transfer_dma); 409 if (!buf) { 410 retval = -ENOMEM; 411 goto error; 412 } 413 414 if (copy_from_user(buf, user_buffer, writesize)) { 415 retval = -EFAULT; 416 goto error; 417 } 418 419 /* this lock makes sure we don't submit URBs to gone devices */ 420 mutex_lock(&dev->io_mutex); 421 if (!dev->interface) { /* disconnect() was called */ 422 mutex_unlock(&dev->io_mutex); 423 retval = -ENODEV; 424 goto error; 425 } 426 427 /* initialize the urb properly */ 428 usb_fill_bulk_urb(urb, dev->udev, 429 usb_sndbulkpipe(dev->udev, dev->bulk_out_endpointAddr), 430 buf, writesize, skel_write_bulk_callback, dev); 431 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP; 432 usb_anchor_urb(urb, &dev->submitted); 433 434 /* send the data out the bulk port */ 435 retval = usb_submit_urb(urb, GFP_KERNEL); 436 mutex_unlock(&dev->io_mutex); 437 if (retval) { 438 dev_err(&dev->interface->dev, 439 "%s - failed submitting write urb, error %d\n", 440 __func__, retval); 441 goto error_unanchor; 442 } 443 444 /* 445 * release our reference to this urb, the USB core will eventually free 446 * it entirely 447 */ 448 usb_free_urb(urb); 449 450 451 return writesize; 452 453 error_unanchor: 454 usb_unanchor_urb(urb); 455 error: 456 if (urb) { 457 usb_free_coherent(dev->udev, writesize, buf, urb->transfer_dma); 458 usb_free_urb(urb); 459 } 460 up(&dev->limit_sem); 461 462 exit: 463 return retval; 464 } 465 466 static const struct file_operations skel_fops = { 467 .owner = THIS_MODULE, 468 .read = skel_read, 469 .write = skel_write, 470 .open = skel_open, 471 .release = skel_release, 472 .flush = skel_flush, 473 .llseek = noop_llseek, 474 }; 475 476 /* 477 * usb class driver info in order to get a minor number from the usb core, 478 * and to have the device registered with the driver core 479 */ 480 static struct usb_class_driver skel_class = { 481 .name = "skel%d", 482 .fops = &skel_fops, 483 .minor_base = USB_SKEL_MINOR_BASE, 484 }; 485 486 static int skel_probe(struct usb_interface *interface, 487 const struct usb_device_id *id) 488 { 489 struct usb_skel *dev; 490 struct usb_endpoint_descriptor *bulk_in, *bulk_out; 491 int retval; 492 493 /* allocate memory for our device state and initialize it */ 494 dev = kzalloc(sizeof(*dev), GFP_KERNEL); 495 if (!dev) 496 return -ENOMEM; 497 498 kref_init(&dev->kref); 499 sema_init(&dev->limit_sem, WRITES_IN_FLIGHT); 500 mutex_init(&dev->io_mutex); 501 spin_lock_init(&dev->err_lock); 502 init_usb_anchor(&dev->submitted); 503 init_waitqueue_head(&dev->bulk_in_wait); 504 505 dev->udev = usb_get_dev(interface_to_usbdev(interface)); 506 dev->interface = interface; 507 508 /* set up the endpoint information */ 509 /* use only the first bulk-in and bulk-out endpoints */ 510 retval = usb_find_common_endpoints(interface->cur_altsetting, 511 &bulk_in, &bulk_out, NULL, NULL); 512 if (retval) { 513 dev_err(&interface->dev, 514 "Could not find both bulk-in and bulk-out endpoints\n"); 515 goto error; 516 } 517 518 dev->bulk_in_size = usb_endpoint_maxp(bulk_in); 519 dev->bulk_in_endpointAddr = bulk_in->bEndpointAddress; 520 dev->bulk_in_buffer = kmalloc(dev->bulk_in_size, GFP_KERNEL); 521 if (!dev->bulk_in_buffer) { 522 retval = -ENOMEM; 523 goto error; 524 } 525 dev->bulk_in_urb = usb_alloc_urb(0, GFP_KERNEL); 526 if (!dev->bulk_in_urb) { 527 retval = -ENOMEM; 528 goto error; 529 } 530 531 dev->bulk_out_endpointAddr = bulk_out->bEndpointAddress; 532 533 /* save our data pointer in this interface device */ 534 usb_set_intfdata(interface, dev); 535 536 /* we can register the device now, as it is ready */ 537 retval = usb_register_dev(interface, &skel_class); 538 if (retval) { 539 /* something prevented us from registering this driver */ 540 dev_err(&interface->dev, 541 "Not able to get a minor for this device.\n"); 542 usb_set_intfdata(interface, NULL); 543 goto error; 544 } 545 546 /* let the user know what node this device is now attached to */ 547 dev_info(&interface->dev, 548 "USB Skeleton device now attached to USBSkel-%d", 549 interface->minor); 550 return 0; 551 552 error: 553 /* this frees allocated memory */ 554 kref_put(&dev->kref, skel_delete); 555 556 return retval; 557 } 558 559 static void skel_disconnect(struct usb_interface *interface) 560 { 561 struct usb_skel *dev; 562 int minor = interface->minor; 563 564 dev = usb_get_intfdata(interface); 565 usb_set_intfdata(interface, NULL); 566 567 /* give back our minor */ 568 usb_deregister_dev(interface, &skel_class); 569 570 /* prevent more I/O from starting */ 571 mutex_lock(&dev->io_mutex); 572 dev->interface = NULL; 573 mutex_unlock(&dev->io_mutex); 574 575 usb_kill_anchored_urbs(&dev->submitted); 576 577 /* decrement our usage count */ 578 kref_put(&dev->kref, skel_delete); 579 580 dev_info(&interface->dev, "USB Skeleton #%d now disconnected", minor); 581 } 582 583 static void skel_draw_down(struct usb_skel *dev) 584 { 585 int time; 586 587 time = usb_wait_anchor_empty_timeout(&dev->submitted, 1000); 588 if (!time) 589 usb_kill_anchored_urbs(&dev->submitted); 590 usb_kill_urb(dev->bulk_in_urb); 591 } 592 593 static int skel_suspend(struct usb_interface *intf, pm_message_t message) 594 { 595 struct usb_skel *dev = usb_get_intfdata(intf); 596 597 if (!dev) 598 return 0; 599 skel_draw_down(dev); 600 return 0; 601 } 602 603 static int skel_resume(struct usb_interface *intf) 604 { 605 return 0; 606 } 607 608 static int skel_pre_reset(struct usb_interface *intf) 609 { 610 struct usb_skel *dev = usb_get_intfdata(intf); 611 612 mutex_lock(&dev->io_mutex); 613 skel_draw_down(dev); 614 615 return 0; 616 } 617 618 static int skel_post_reset(struct usb_interface *intf) 619 { 620 struct usb_skel *dev = usb_get_intfdata(intf); 621 622 /* we are sure no URBs are active - no locking needed */ 623 dev->errors = -EPIPE; 624 mutex_unlock(&dev->io_mutex); 625 626 return 0; 627 } 628 629 static struct usb_driver skel_driver = { 630 .name = "skeleton", 631 .probe = skel_probe, 632 .disconnect = skel_disconnect, 633 .suspend = skel_suspend, 634 .resume = skel_resume, 635 .pre_reset = skel_pre_reset, 636 .post_reset = skel_post_reset, 637 .id_table = skel_table, 638 .supports_autosuspend = 1, 639 }; 640 641 module_usb_driver(skel_driver); 642 643 MODULE_LICENSE("GPL"); 644