1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * adutux - driver for ADU devices from Ontrak Control Systems 4 * This is an experimental driver. Use at your own risk. 5 * This driver is not supported by Ontrak Control Systems. 6 * 7 * Copyright (c) 2003 John Homppi (SCO, leave this notice here) 8 * 9 * This program is free software; you can redistribute it and/or 10 * modify it under the terms of the GNU General Public License as 11 * published by the Free Software Foundation; either version 2 of 12 * the License, or (at your option) any later version. 13 * 14 * derived from the Lego USB Tower driver 0.56: 15 * Copyright (c) 2003 David Glance <davidgsf@sourceforge.net> 16 * 2001 Juergen Stuber <stuber@loria.fr> 17 * that was derived from USB Skeleton driver - 0.5 18 * Copyright (c) 2001 Greg Kroah-Hartman (greg@kroah.com) 19 * 20 */ 21 22 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 23 24 #include <linux/kernel.h> 25 #include <linux/sched/signal.h> 26 #include <linux/errno.h> 27 #include <linux/slab.h> 28 #include <linux/module.h> 29 #include <linux/usb.h> 30 #include <linux/mutex.h> 31 #include <linux/uaccess.h> 32 33 #define DRIVER_AUTHOR "John Homppi" 34 #define DRIVER_DESC "adutux (see www.ontrak.net)" 35 36 /* Define these values to match your device */ 37 #define ADU_VENDOR_ID 0x0a07 38 #define ADU_PRODUCT_ID 0x0064 39 40 /* table of devices that work with this driver */ 41 static const struct usb_device_id device_table[] = { 42 { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID) }, /* ADU100 */ 43 { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+20) }, /* ADU120 */ 44 { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+30) }, /* ADU130 */ 45 { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+100) }, /* ADU200 */ 46 { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+108) }, /* ADU208 */ 47 { USB_DEVICE(ADU_VENDOR_ID, ADU_PRODUCT_ID+118) }, /* ADU218 */ 48 { } /* Terminating entry */ 49 }; 50 51 MODULE_DEVICE_TABLE(usb, device_table); 52 53 #ifdef CONFIG_USB_DYNAMIC_MINORS 54 #define ADU_MINOR_BASE 0 55 #else 56 #define ADU_MINOR_BASE 67 57 #endif 58 59 /* we can have up to this number of device plugged in at once */ 60 #define MAX_DEVICES 16 61 62 #define COMMAND_TIMEOUT (2*HZ) /* 60 second timeout for a command */ 63 64 /* 65 * The locking scheme is a vanilla 3-lock: 66 * adu_device.buflock: A spinlock, covers what IRQs touch. 67 * adutux_mutex: A Static lock to cover open_count. It would also cover 68 * any globals, but we don't have them in 2.6. 69 * adu_device.mtx: A mutex to hold across sleepers like copy_from_user. 70 * It covers all of adu_device, except the open_count 71 * and what .buflock covers. 72 */ 73 74 /* Structure to hold all of our device specific stuff */ 75 struct adu_device { 76 struct mutex mtx; 77 struct usb_device *udev; /* save off the usb device pointer */ 78 struct usb_interface *interface; 79 unsigned int minor; /* the starting minor number for this device */ 80 char serial_number[8]; 81 82 int open_count; /* number of times this port has been opened */ 83 84 char *read_buffer_primary; 85 int read_buffer_length; 86 char *read_buffer_secondary; 87 int secondary_head; 88 int secondary_tail; 89 spinlock_t buflock; 90 91 wait_queue_head_t read_wait; 92 wait_queue_head_t write_wait; 93 94 char *interrupt_in_buffer; 95 struct usb_endpoint_descriptor *interrupt_in_endpoint; 96 struct urb *interrupt_in_urb; 97 int read_urb_finished; 98 99 char *interrupt_out_buffer; 100 struct usb_endpoint_descriptor *interrupt_out_endpoint; 101 struct urb *interrupt_out_urb; 102 int out_urb_finished; 103 }; 104 105 static DEFINE_MUTEX(adutux_mutex); 106 107 static struct usb_driver adu_driver; 108 109 static inline void adu_debug_data(struct device *dev, const char *function, 110 int size, const unsigned char *data) 111 { 112 dev_dbg(dev, "%s - length = %d, data = %*ph\n", 113 function, size, size, data); 114 } 115 116 /** 117 * adu_abort_transfers 118 * aborts transfers and frees associated data structures 119 */ 120 static void adu_abort_transfers(struct adu_device *dev) 121 { 122 unsigned long flags; 123 124 if (dev->udev == NULL) 125 return; 126 127 /* shutdown transfer */ 128 129 /* XXX Anchor these instead */ 130 spin_lock_irqsave(&dev->buflock, flags); 131 if (!dev->read_urb_finished) { 132 spin_unlock_irqrestore(&dev->buflock, flags); 133 usb_kill_urb(dev->interrupt_in_urb); 134 } else 135 spin_unlock_irqrestore(&dev->buflock, flags); 136 137 spin_lock_irqsave(&dev->buflock, flags); 138 if (!dev->out_urb_finished) { 139 spin_unlock_irqrestore(&dev->buflock, flags); 140 usb_kill_urb(dev->interrupt_out_urb); 141 } else 142 spin_unlock_irqrestore(&dev->buflock, flags); 143 } 144 145 static void adu_delete(struct adu_device *dev) 146 { 147 /* free data structures */ 148 usb_free_urb(dev->interrupt_in_urb); 149 usb_free_urb(dev->interrupt_out_urb); 150 kfree(dev->read_buffer_primary); 151 kfree(dev->read_buffer_secondary); 152 kfree(dev->interrupt_in_buffer); 153 kfree(dev->interrupt_out_buffer); 154 kfree(dev); 155 } 156 157 static void adu_interrupt_in_callback(struct urb *urb) 158 { 159 struct adu_device *dev = urb->context; 160 int status = urb->status; 161 162 adu_debug_data(&dev->udev->dev, __func__, 163 urb->actual_length, urb->transfer_buffer); 164 165 spin_lock(&dev->buflock); 166 167 if (status != 0) { 168 if ((status != -ENOENT) && (status != -ECONNRESET) && 169 (status != -ESHUTDOWN)) { 170 dev_dbg(&dev->udev->dev, 171 "%s : nonzero status received: %d\n", 172 __func__, status); 173 } 174 goto exit; 175 } 176 177 if (urb->actual_length > 0 && dev->interrupt_in_buffer[0] != 0x00) { 178 if (dev->read_buffer_length < 179 (4 * usb_endpoint_maxp(dev->interrupt_in_endpoint)) - 180 (urb->actual_length)) { 181 memcpy (dev->read_buffer_primary + 182 dev->read_buffer_length, 183 dev->interrupt_in_buffer, urb->actual_length); 184 185 dev->read_buffer_length += urb->actual_length; 186 dev_dbg(&dev->udev->dev,"%s reading %d\n", __func__, 187 urb->actual_length); 188 } else { 189 dev_dbg(&dev->udev->dev,"%s : read_buffer overflow\n", 190 __func__); 191 } 192 } 193 194 exit: 195 dev->read_urb_finished = 1; 196 spin_unlock(&dev->buflock); 197 /* always wake up so we recover from errors */ 198 wake_up_interruptible(&dev->read_wait); 199 } 200 201 static void adu_interrupt_out_callback(struct urb *urb) 202 { 203 struct adu_device *dev = urb->context; 204 int status = urb->status; 205 206 adu_debug_data(&dev->udev->dev, __func__, 207 urb->actual_length, urb->transfer_buffer); 208 209 if (status != 0) { 210 if ((status != -ENOENT) && 211 (status != -ECONNRESET)) { 212 dev_dbg(&dev->udev->dev, 213 "%s :nonzero status received: %d\n", __func__, 214 status); 215 } 216 return; 217 } 218 219 spin_lock(&dev->buflock); 220 dev->out_urb_finished = 1; 221 wake_up(&dev->write_wait); 222 spin_unlock(&dev->buflock); 223 } 224 225 static int adu_open(struct inode *inode, struct file *file) 226 { 227 struct adu_device *dev = NULL; 228 struct usb_interface *interface; 229 int subminor; 230 int retval; 231 232 subminor = iminor(inode); 233 234 retval = mutex_lock_interruptible(&adutux_mutex); 235 if (retval) 236 goto exit_no_lock; 237 238 interface = usb_find_interface(&adu_driver, subminor); 239 if (!interface) { 240 pr_err("%s - error, can't find device for minor %d\n", 241 __func__, subminor); 242 retval = -ENODEV; 243 goto exit_no_device; 244 } 245 246 dev = usb_get_intfdata(interface); 247 if (!dev || !dev->udev) { 248 retval = -ENODEV; 249 goto exit_no_device; 250 } 251 252 /* check that nobody else is using the device */ 253 if (dev->open_count) { 254 retval = -EBUSY; 255 goto exit_no_device; 256 } 257 258 ++dev->open_count; 259 dev_dbg(&dev->udev->dev, "%s: open count %d\n", __func__, 260 dev->open_count); 261 262 /* save device in the file's private structure */ 263 file->private_data = dev; 264 265 /* initialize in direction */ 266 dev->read_buffer_length = 0; 267 268 /* fixup first read by having urb waiting for it */ 269 usb_fill_int_urb(dev->interrupt_in_urb, dev->udev, 270 usb_rcvintpipe(dev->udev, 271 dev->interrupt_in_endpoint->bEndpointAddress), 272 dev->interrupt_in_buffer, 273 usb_endpoint_maxp(dev->interrupt_in_endpoint), 274 adu_interrupt_in_callback, dev, 275 dev->interrupt_in_endpoint->bInterval); 276 dev->read_urb_finished = 0; 277 if (usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL)) 278 dev->read_urb_finished = 1; 279 /* we ignore failure */ 280 /* end of fixup for first read */ 281 282 /* initialize out direction */ 283 dev->out_urb_finished = 1; 284 285 retval = 0; 286 287 exit_no_device: 288 mutex_unlock(&adutux_mutex); 289 exit_no_lock: 290 return retval; 291 } 292 293 static void adu_release_internal(struct adu_device *dev) 294 { 295 /* decrement our usage count for the device */ 296 --dev->open_count; 297 dev_dbg(&dev->udev->dev, "%s : open count %d\n", __func__, 298 dev->open_count); 299 if (dev->open_count <= 0) { 300 adu_abort_transfers(dev); 301 dev->open_count = 0; 302 } 303 } 304 305 static int adu_release(struct inode *inode, struct file *file) 306 { 307 struct adu_device *dev; 308 int retval = 0; 309 310 if (file == NULL) { 311 retval = -ENODEV; 312 goto exit; 313 } 314 315 dev = file->private_data; 316 if (dev == NULL) { 317 retval = -ENODEV; 318 goto exit; 319 } 320 321 mutex_lock(&adutux_mutex); /* not interruptible */ 322 323 if (dev->open_count <= 0) { 324 dev_dbg(&dev->udev->dev, "%s : device not opened\n", __func__); 325 retval = -ENODEV; 326 goto unlock; 327 } 328 329 adu_release_internal(dev); 330 if (dev->udev == NULL) { 331 /* the device was unplugged before the file was released */ 332 if (!dev->open_count) /* ... and we're the last user */ 333 adu_delete(dev); 334 } 335 unlock: 336 mutex_unlock(&adutux_mutex); 337 exit: 338 return retval; 339 } 340 341 static ssize_t adu_read(struct file *file, __user char *buffer, size_t count, 342 loff_t *ppos) 343 { 344 struct adu_device *dev; 345 size_t bytes_read = 0; 346 size_t bytes_to_read = count; 347 int i; 348 int retval = 0; 349 int timeout = 0; 350 int should_submit = 0; 351 unsigned long flags; 352 DECLARE_WAITQUEUE(wait, current); 353 354 dev = file->private_data; 355 if (mutex_lock_interruptible(&dev->mtx)) 356 return -ERESTARTSYS; 357 358 /* verify that the device wasn't unplugged */ 359 if (dev->udev == NULL) { 360 retval = -ENODEV; 361 pr_err("No device or device unplugged %d\n", retval); 362 goto exit; 363 } 364 365 /* verify that some data was requested */ 366 if (count == 0) { 367 dev_dbg(&dev->udev->dev, "%s : read request of 0 bytes\n", 368 __func__); 369 goto exit; 370 } 371 372 timeout = COMMAND_TIMEOUT; 373 dev_dbg(&dev->udev->dev, "%s : about to start looping\n", __func__); 374 while (bytes_to_read) { 375 int data_in_secondary = dev->secondary_tail - dev->secondary_head; 376 dev_dbg(&dev->udev->dev, 377 "%s : while, data_in_secondary=%d, status=%d\n", 378 __func__, data_in_secondary, 379 dev->interrupt_in_urb->status); 380 381 if (data_in_secondary) { 382 /* drain secondary buffer */ 383 int amount = bytes_to_read < data_in_secondary ? bytes_to_read : data_in_secondary; 384 i = copy_to_user(buffer, dev->read_buffer_secondary+dev->secondary_head, amount); 385 if (i) { 386 retval = -EFAULT; 387 goto exit; 388 } 389 dev->secondary_head += (amount - i); 390 bytes_read += (amount - i); 391 bytes_to_read -= (amount - i); 392 } else { 393 /* we check the primary buffer */ 394 spin_lock_irqsave (&dev->buflock, flags); 395 if (dev->read_buffer_length) { 396 /* we secure access to the primary */ 397 char *tmp; 398 dev_dbg(&dev->udev->dev, 399 "%s : swap, read_buffer_length = %d\n", 400 __func__, dev->read_buffer_length); 401 tmp = dev->read_buffer_secondary; 402 dev->read_buffer_secondary = dev->read_buffer_primary; 403 dev->read_buffer_primary = tmp; 404 dev->secondary_head = 0; 405 dev->secondary_tail = dev->read_buffer_length; 406 dev->read_buffer_length = 0; 407 spin_unlock_irqrestore(&dev->buflock, flags); 408 /* we have a free buffer so use it */ 409 should_submit = 1; 410 } else { 411 /* even the primary was empty - we may need to do IO */ 412 if (!dev->read_urb_finished) { 413 /* somebody is doing IO */ 414 spin_unlock_irqrestore(&dev->buflock, flags); 415 dev_dbg(&dev->udev->dev, 416 "%s : submitted already\n", 417 __func__); 418 } else { 419 /* we must initiate input */ 420 dev_dbg(&dev->udev->dev, 421 "%s : initiate input\n", 422 __func__); 423 dev->read_urb_finished = 0; 424 spin_unlock_irqrestore(&dev->buflock, flags); 425 426 usb_fill_int_urb(dev->interrupt_in_urb, dev->udev, 427 usb_rcvintpipe(dev->udev, 428 dev->interrupt_in_endpoint->bEndpointAddress), 429 dev->interrupt_in_buffer, 430 usb_endpoint_maxp(dev->interrupt_in_endpoint), 431 adu_interrupt_in_callback, 432 dev, 433 dev->interrupt_in_endpoint->bInterval); 434 retval = usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL); 435 if (retval) { 436 dev->read_urb_finished = 1; 437 if (retval == -ENOMEM) { 438 retval = bytes_read ? bytes_read : -ENOMEM; 439 } 440 dev_dbg(&dev->udev->dev, 441 "%s : submit failed\n", 442 __func__); 443 goto exit; 444 } 445 } 446 447 /* we wait for I/O to complete */ 448 set_current_state(TASK_INTERRUPTIBLE); 449 add_wait_queue(&dev->read_wait, &wait); 450 spin_lock_irqsave(&dev->buflock, flags); 451 if (!dev->read_urb_finished) { 452 spin_unlock_irqrestore(&dev->buflock, flags); 453 timeout = schedule_timeout(COMMAND_TIMEOUT); 454 } else { 455 spin_unlock_irqrestore(&dev->buflock, flags); 456 set_current_state(TASK_RUNNING); 457 } 458 remove_wait_queue(&dev->read_wait, &wait); 459 460 if (timeout <= 0) { 461 dev_dbg(&dev->udev->dev, 462 "%s : timeout\n", __func__); 463 retval = bytes_read ? bytes_read : -ETIMEDOUT; 464 goto exit; 465 } 466 467 if (signal_pending(current)) { 468 dev_dbg(&dev->udev->dev, 469 "%s : signal pending\n", 470 __func__); 471 retval = bytes_read ? bytes_read : -EINTR; 472 goto exit; 473 } 474 } 475 } 476 } 477 478 retval = bytes_read; 479 /* if the primary buffer is empty then use it */ 480 spin_lock_irqsave(&dev->buflock, flags); 481 if (should_submit && dev->read_urb_finished) { 482 dev->read_urb_finished = 0; 483 spin_unlock_irqrestore(&dev->buflock, flags); 484 usb_fill_int_urb(dev->interrupt_in_urb, dev->udev, 485 usb_rcvintpipe(dev->udev, 486 dev->interrupt_in_endpoint->bEndpointAddress), 487 dev->interrupt_in_buffer, 488 usb_endpoint_maxp(dev->interrupt_in_endpoint), 489 adu_interrupt_in_callback, 490 dev, 491 dev->interrupt_in_endpoint->bInterval); 492 if (usb_submit_urb(dev->interrupt_in_urb, GFP_KERNEL) != 0) 493 dev->read_urb_finished = 1; 494 /* we ignore failure */ 495 } else { 496 spin_unlock_irqrestore(&dev->buflock, flags); 497 } 498 499 exit: 500 /* unlock the device */ 501 mutex_unlock(&dev->mtx); 502 503 return retval; 504 } 505 506 static ssize_t adu_write(struct file *file, const __user char *buffer, 507 size_t count, loff_t *ppos) 508 { 509 DECLARE_WAITQUEUE(waita, current); 510 struct adu_device *dev; 511 size_t bytes_written = 0; 512 size_t bytes_to_write; 513 size_t buffer_size; 514 unsigned long flags; 515 int retval; 516 517 dev = file->private_data; 518 519 retval = mutex_lock_interruptible(&dev->mtx); 520 if (retval) 521 goto exit_nolock; 522 523 /* verify that the device wasn't unplugged */ 524 if (dev->udev == NULL) { 525 retval = -ENODEV; 526 pr_err("No device or device unplugged %d\n", retval); 527 goto exit; 528 } 529 530 /* verify that we actually have some data to write */ 531 if (count == 0) { 532 dev_dbg(&dev->udev->dev, "%s : write request of 0 bytes\n", 533 __func__); 534 goto exit; 535 } 536 537 while (count > 0) { 538 add_wait_queue(&dev->write_wait, &waita); 539 set_current_state(TASK_INTERRUPTIBLE); 540 spin_lock_irqsave(&dev->buflock, flags); 541 if (!dev->out_urb_finished) { 542 spin_unlock_irqrestore(&dev->buflock, flags); 543 544 mutex_unlock(&dev->mtx); 545 if (signal_pending(current)) { 546 dev_dbg(&dev->udev->dev, "%s : interrupted\n", 547 __func__); 548 set_current_state(TASK_RUNNING); 549 retval = -EINTR; 550 goto exit_onqueue; 551 } 552 if (schedule_timeout(COMMAND_TIMEOUT) == 0) { 553 dev_dbg(&dev->udev->dev, 554 "%s - command timed out.\n", __func__); 555 retval = -ETIMEDOUT; 556 goto exit_onqueue; 557 } 558 remove_wait_queue(&dev->write_wait, &waita); 559 retval = mutex_lock_interruptible(&dev->mtx); 560 if (retval) { 561 retval = bytes_written ? bytes_written : retval; 562 goto exit_nolock; 563 } 564 565 dev_dbg(&dev->udev->dev, 566 "%s : in progress, count = %zd\n", 567 __func__, count); 568 } else { 569 spin_unlock_irqrestore(&dev->buflock, flags); 570 set_current_state(TASK_RUNNING); 571 remove_wait_queue(&dev->write_wait, &waita); 572 dev_dbg(&dev->udev->dev, "%s : sending, count = %zd\n", 573 __func__, count); 574 575 /* write the data into interrupt_out_buffer from userspace */ 576 buffer_size = usb_endpoint_maxp(dev->interrupt_out_endpoint); 577 bytes_to_write = count > buffer_size ? buffer_size : count; 578 dev_dbg(&dev->udev->dev, 579 "%s : buffer_size = %zd, count = %zd, bytes_to_write = %zd\n", 580 __func__, buffer_size, count, bytes_to_write); 581 582 if (copy_from_user(dev->interrupt_out_buffer, buffer, bytes_to_write) != 0) { 583 retval = -EFAULT; 584 goto exit; 585 } 586 587 /* send off the urb */ 588 usb_fill_int_urb( 589 dev->interrupt_out_urb, 590 dev->udev, 591 usb_sndintpipe(dev->udev, dev->interrupt_out_endpoint->bEndpointAddress), 592 dev->interrupt_out_buffer, 593 bytes_to_write, 594 adu_interrupt_out_callback, 595 dev, 596 dev->interrupt_out_endpoint->bInterval); 597 dev->interrupt_out_urb->actual_length = bytes_to_write; 598 dev->out_urb_finished = 0; 599 retval = usb_submit_urb(dev->interrupt_out_urb, GFP_KERNEL); 600 if (retval < 0) { 601 dev->out_urb_finished = 1; 602 dev_err(&dev->udev->dev, "Couldn't submit " 603 "interrupt_out_urb %d\n", retval); 604 goto exit; 605 } 606 607 buffer += bytes_to_write; 608 count -= bytes_to_write; 609 610 bytes_written += bytes_to_write; 611 } 612 } 613 mutex_unlock(&dev->mtx); 614 return bytes_written; 615 616 exit: 617 mutex_unlock(&dev->mtx); 618 exit_nolock: 619 return retval; 620 621 exit_onqueue: 622 remove_wait_queue(&dev->write_wait, &waita); 623 return retval; 624 } 625 626 /* file operations needed when we register this driver */ 627 static const struct file_operations adu_fops = { 628 .owner = THIS_MODULE, 629 .read = adu_read, 630 .write = adu_write, 631 .open = adu_open, 632 .release = adu_release, 633 .llseek = noop_llseek, 634 }; 635 636 /* 637 * usb class driver info in order to get a minor number from the usb core, 638 * and to have the device registered with devfs and the driver core 639 */ 640 static struct usb_class_driver adu_class = { 641 .name = "usb/adutux%d", 642 .fops = &adu_fops, 643 .minor_base = ADU_MINOR_BASE, 644 }; 645 646 /** 647 * adu_probe 648 * 649 * Called by the usb core when a new device is connected that it thinks 650 * this driver might be interested in. 651 */ 652 static int adu_probe(struct usb_interface *interface, 653 const struct usb_device_id *id) 654 { 655 struct usb_device *udev = interface_to_usbdev(interface); 656 struct adu_device *dev = NULL; 657 int retval = -ENOMEM; 658 int in_end_size; 659 int out_end_size; 660 int res; 661 662 /* allocate memory for our device state and initialize it */ 663 dev = kzalloc(sizeof(struct adu_device), GFP_KERNEL); 664 if (!dev) 665 return -ENOMEM; 666 667 mutex_init(&dev->mtx); 668 spin_lock_init(&dev->buflock); 669 dev->udev = udev; 670 init_waitqueue_head(&dev->read_wait); 671 init_waitqueue_head(&dev->write_wait); 672 673 res = usb_find_common_endpoints_reverse(&interface->altsetting[0], 674 NULL, NULL, 675 &dev->interrupt_in_endpoint, 676 &dev->interrupt_out_endpoint); 677 if (res) { 678 dev_err(&interface->dev, "interrupt endpoints not found\n"); 679 retval = res; 680 goto error; 681 } 682 683 in_end_size = usb_endpoint_maxp(dev->interrupt_in_endpoint); 684 out_end_size = usb_endpoint_maxp(dev->interrupt_out_endpoint); 685 686 dev->read_buffer_primary = kmalloc((4 * in_end_size), GFP_KERNEL); 687 if (!dev->read_buffer_primary) 688 goto error; 689 690 /* debug code prime the buffer */ 691 memset(dev->read_buffer_primary, 'a', in_end_size); 692 memset(dev->read_buffer_primary + in_end_size, 'b', in_end_size); 693 memset(dev->read_buffer_primary + (2 * in_end_size), 'c', in_end_size); 694 memset(dev->read_buffer_primary + (3 * in_end_size), 'd', in_end_size); 695 696 dev->read_buffer_secondary = kmalloc((4 * in_end_size), GFP_KERNEL); 697 if (!dev->read_buffer_secondary) 698 goto error; 699 700 /* debug code prime the buffer */ 701 memset(dev->read_buffer_secondary, 'e', in_end_size); 702 memset(dev->read_buffer_secondary + in_end_size, 'f', in_end_size); 703 memset(dev->read_buffer_secondary + (2 * in_end_size), 'g', in_end_size); 704 memset(dev->read_buffer_secondary + (3 * in_end_size), 'h', in_end_size); 705 706 dev->interrupt_in_buffer = kmalloc(in_end_size, GFP_KERNEL); 707 if (!dev->interrupt_in_buffer) 708 goto error; 709 710 /* debug code prime the buffer */ 711 memset(dev->interrupt_in_buffer, 'i', in_end_size); 712 713 dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL); 714 if (!dev->interrupt_in_urb) 715 goto error; 716 dev->interrupt_out_buffer = kmalloc(out_end_size, GFP_KERNEL); 717 if (!dev->interrupt_out_buffer) 718 goto error; 719 dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL); 720 if (!dev->interrupt_out_urb) 721 goto error; 722 723 if (!usb_string(udev, udev->descriptor.iSerialNumber, dev->serial_number, 724 sizeof(dev->serial_number))) { 725 dev_err(&interface->dev, "Could not retrieve serial number\n"); 726 retval = -EIO; 727 goto error; 728 } 729 dev_dbg(&interface->dev,"serial_number=%s", dev->serial_number); 730 731 /* we can register the device now, as it is ready */ 732 usb_set_intfdata(interface, dev); 733 734 retval = usb_register_dev(interface, &adu_class); 735 736 if (retval) { 737 /* something prevented us from registering this driver */ 738 dev_err(&interface->dev, "Not able to get a minor for this device.\n"); 739 usb_set_intfdata(interface, NULL); 740 goto error; 741 } 742 743 dev->minor = interface->minor; 744 745 /* let the user know what node this device is now attached to */ 746 dev_info(&interface->dev, "ADU%d %s now attached to /dev/usb/adutux%d\n", 747 le16_to_cpu(udev->descriptor.idProduct), dev->serial_number, 748 (dev->minor - ADU_MINOR_BASE)); 749 750 return 0; 751 752 error: 753 adu_delete(dev); 754 return retval; 755 } 756 757 /** 758 * adu_disconnect 759 * 760 * Called by the usb core when the device is removed from the system. 761 */ 762 static void adu_disconnect(struct usb_interface *interface) 763 { 764 struct adu_device *dev; 765 int minor; 766 767 dev = usb_get_intfdata(interface); 768 769 mutex_lock(&dev->mtx); /* not interruptible */ 770 dev->udev = NULL; /* poison */ 771 minor = dev->minor; 772 usb_deregister_dev(interface, &adu_class); 773 mutex_unlock(&dev->mtx); 774 775 mutex_lock(&adutux_mutex); 776 usb_set_intfdata(interface, NULL); 777 778 /* if the device is not opened, then we clean up right now */ 779 if (!dev->open_count) 780 adu_delete(dev); 781 782 mutex_unlock(&adutux_mutex); 783 } 784 785 /* usb specific object needed to register this driver with the usb subsystem */ 786 static struct usb_driver adu_driver = { 787 .name = "adutux", 788 .probe = adu_probe, 789 .disconnect = adu_disconnect, 790 .id_table = device_table, 791 }; 792 793 module_usb_driver(adu_driver); 794 795 MODULE_AUTHOR(DRIVER_AUTHOR); 796 MODULE_DESCRIPTION(DRIVER_DESC); 797 MODULE_LICENSE("GPL"); 798