1 /* 2 * adutux - driver for ADU devices from Ontrak Control Systems 3 * This is an experimental driver. Use at your own risk. 4 * This driver is not supported by Ontrak Control Systems. 5 * 6 * Copyright (c) 2003 John Homppi (SCO, leave this notice here) 7 * 8 * This program is free software; you can redistribute it and/or 9 * modify it under the terms of the GNU General Public License as 10 * published by the Free Software Foundation; either version 2 of 11 * the License, or (at your option) any later version. 12 * 13 * derived from the Lego USB Tower driver 0.56: 14 * Copyright (c) 2003 David Glance <davidgsf@sourceforge.net> 15 * 2001 Juergen Stuber <stuber@loria.fr> 16 * that was derived from USB Skeleton driver - 0.5 17 * Copyright (c) 2001 Greg Kroah-Hartman (greg@kroah.com) 18 * 19 */ 20 21 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 22 23 #include <linux/kernel.h> 24 #include <linux/errno.h> 25 #include <linux/slab.h> 26 #include <linux/module.h> 27 #include <linux/usb.h> 28 #include <linux/mutex.h> 29 #include <linux/uaccess.h> 30 31 /* Version Information */ 32 #define DRIVER_VERSION "v0.0.13" 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 struct usb_host_interface *iface_desc; 658 struct usb_endpoint_descriptor *endpoint; 659 int retval = -ENODEV; 660 int in_end_size; 661 int out_end_size; 662 int i; 663 664 if (udev == NULL) { 665 dev_err(&interface->dev, "udev is NULL.\n"); 666 goto exit; 667 } 668 669 /* allocate memory for our device state and initialize it */ 670 dev = kzalloc(sizeof(struct adu_device), GFP_KERNEL); 671 if (!dev) { 672 retval = -ENOMEM; 673 goto exit; 674 } 675 676 mutex_init(&dev->mtx); 677 spin_lock_init(&dev->buflock); 678 dev->udev = udev; 679 init_waitqueue_head(&dev->read_wait); 680 init_waitqueue_head(&dev->write_wait); 681 682 iface_desc = &interface->altsetting[0]; 683 684 /* set up the endpoint information */ 685 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { 686 endpoint = &iface_desc->endpoint[i].desc; 687 688 if (usb_endpoint_is_int_in(endpoint)) 689 dev->interrupt_in_endpoint = endpoint; 690 691 if (usb_endpoint_is_int_out(endpoint)) 692 dev->interrupt_out_endpoint = endpoint; 693 } 694 if (dev->interrupt_in_endpoint == NULL) { 695 dev_err(&interface->dev, "interrupt in endpoint not found\n"); 696 goto error; 697 } 698 if (dev->interrupt_out_endpoint == NULL) { 699 dev_err(&interface->dev, "interrupt out endpoint not found\n"); 700 goto error; 701 } 702 703 in_end_size = usb_endpoint_maxp(dev->interrupt_in_endpoint); 704 out_end_size = usb_endpoint_maxp(dev->interrupt_out_endpoint); 705 706 dev->read_buffer_primary = kmalloc((4 * in_end_size), GFP_KERNEL); 707 if (!dev->read_buffer_primary) { 708 retval = -ENOMEM; 709 goto error; 710 } 711 712 /* debug code prime the buffer */ 713 memset(dev->read_buffer_primary, 'a', in_end_size); 714 memset(dev->read_buffer_primary + in_end_size, 'b', in_end_size); 715 memset(dev->read_buffer_primary + (2 * in_end_size), 'c', in_end_size); 716 memset(dev->read_buffer_primary + (3 * in_end_size), 'd', in_end_size); 717 718 dev->read_buffer_secondary = kmalloc((4 * in_end_size), GFP_KERNEL); 719 if (!dev->read_buffer_secondary) { 720 retval = -ENOMEM; 721 goto error; 722 } 723 724 /* debug code prime the buffer */ 725 memset(dev->read_buffer_secondary, 'e', in_end_size); 726 memset(dev->read_buffer_secondary + in_end_size, 'f', in_end_size); 727 memset(dev->read_buffer_secondary + (2 * in_end_size), 'g', in_end_size); 728 memset(dev->read_buffer_secondary + (3 * in_end_size), 'h', in_end_size); 729 730 dev->interrupt_in_buffer = kmalloc(in_end_size, GFP_KERNEL); 731 if (!dev->interrupt_in_buffer) 732 goto error; 733 734 /* debug code prime the buffer */ 735 memset(dev->interrupt_in_buffer, 'i', in_end_size); 736 737 dev->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL); 738 if (!dev->interrupt_in_urb) 739 goto error; 740 dev->interrupt_out_buffer = kmalloc(out_end_size, GFP_KERNEL); 741 if (!dev->interrupt_out_buffer) 742 goto error; 743 dev->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL); 744 if (!dev->interrupt_out_urb) 745 goto error; 746 747 if (!usb_string(udev, udev->descriptor.iSerialNumber, dev->serial_number, 748 sizeof(dev->serial_number))) { 749 dev_err(&interface->dev, "Could not retrieve serial number\n"); 750 goto error; 751 } 752 dev_dbg(&interface->dev,"serial_number=%s", dev->serial_number); 753 754 /* we can register the device now, as it is ready */ 755 usb_set_intfdata(interface, dev); 756 757 retval = usb_register_dev(interface, &adu_class); 758 759 if (retval) { 760 /* something prevented us from registering this driver */ 761 dev_err(&interface->dev, "Not able to get a minor for this device.\n"); 762 usb_set_intfdata(interface, NULL); 763 goto error; 764 } 765 766 dev->minor = interface->minor; 767 768 /* let the user know what node this device is now attached to */ 769 dev_info(&interface->dev, "ADU%d %s now attached to /dev/usb/adutux%d\n", 770 le16_to_cpu(udev->descriptor.idProduct), dev->serial_number, 771 (dev->minor - ADU_MINOR_BASE)); 772 exit: 773 return retval; 774 775 error: 776 adu_delete(dev); 777 return retval; 778 } 779 780 /** 781 * adu_disconnect 782 * 783 * Called by the usb core when the device is removed from the system. 784 */ 785 static void adu_disconnect(struct usb_interface *interface) 786 { 787 struct adu_device *dev; 788 int minor; 789 790 dev = usb_get_intfdata(interface); 791 792 mutex_lock(&dev->mtx); /* not interruptible */ 793 dev->udev = NULL; /* poison */ 794 minor = dev->minor; 795 usb_deregister_dev(interface, &adu_class); 796 mutex_unlock(&dev->mtx); 797 798 mutex_lock(&adutux_mutex); 799 usb_set_intfdata(interface, NULL); 800 801 /* if the device is not opened, then we clean up right now */ 802 if (!dev->open_count) 803 adu_delete(dev); 804 805 mutex_unlock(&adutux_mutex); 806 } 807 808 /* usb specific object needed to register this driver with the usb subsystem */ 809 static struct usb_driver adu_driver = { 810 .name = "adutux", 811 .probe = adu_probe, 812 .disconnect = adu_disconnect, 813 .id_table = device_table, 814 }; 815 816 module_usb_driver(adu_driver); 817 818 MODULE_AUTHOR(DRIVER_AUTHOR); 819 MODULE_DESCRIPTION(DRIVER_DESC); 820 MODULE_LICENSE("GPL"); 821