drivers/usb/serial/usb-serial.c

   1 /*
   2  * USB Serial Converter driver
   3  *
   4  * Copyright (C) 1999 - 2005 Greg Kroah-Hartman (greg@kroah.com)
   5  * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
   6  * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
   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 version
  10  *      2 as published by the Free Software Foundation.
  11  *
  12  * This driver was originally based on the ACM driver by Armin Fuerst (which was
  13  * based on a driver by Brad Keryan)
  14  *
  15  * See Documentation/usb/usb-serial.txt for more information on using this driver
  16  *
  17  */
  18
  19 #include <linux/kernel.h>
  20 #include <linux/errno.h>
  21 #include <linux/init.h>
  22 #include <linux/slab.h>
  23 #include <linux/tty.h>
  24 #include <linux/tty_driver.h>
  25 #include <linux/tty_flip.h>
  26 #include <linux/module.h>
  27 #include <linux/moduleparam.h>
  28 #include <linux/spinlock.h>
  29 #include <linux/mutex.h>
  30 #include <linux/list.h>
  31 #include <linux/smp_lock.h>
  32 #include <asm/uaccess.h>
  33 #include <linux/usb.h>
  34 #include <linux/usb/serial.h>
  35 #include "pl2303.h"
  36
  37 /*
  38  * Version Information
  39  */
  40 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
  41 #define DRIVER_DESC "USB Serial Driver core"
  42
  43 static void port_free(struct usb_serial_port *port);
  44
  45 /* Driver structure we register with the USB core */
  46 static struct usb_driver usb_serial_driver = {
  47         .name =         "usbserial",
  48         .probe =        usb_serial_probe,
  49         .disconnect =   usb_serial_disconnect,
  50         .no_dynamic_id =        1,
  51 };
  52
  53 /* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
  54    the MODULE_DEVICE_TABLE declarations in each serial driver
  55    cause the "hotplug" program to pull in whatever module is necessary
  56    via modprobe, and modprobe will load usbserial because the serial
  57    drivers depend on it.
  58 */
  59
  60 static int debug;
  61 static struct usb_serial *serial_table[SERIAL_TTY_MINORS];      /* initially all NULL */
  62 static LIST_HEAD(usb_serial_driver_list);
  63
  64 struct usb_serial *usb_serial_get_by_index(unsigned index)
  65 {
  66         struct usb_serial *serial = serial_table[index];
  67
  68         if (serial)
  69                 kref_get(&serial->kref);
  70         return serial;
  71 }
  72
  73 static struct usb_serial *get_free_serial (struct usb_serial *serial, int num_ports, unsigned int *minor)
  74 {
  75         unsigned int i, j;
  76         int good_spot;
  77
  78         dbg("%s %d", __FUNCTION__, num_ports);
  79
  80         *minor = 0;
  81         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
  82                 if (serial_table[i])
  83                         continue;
  84
  85                 good_spot = 1;
  86                 for (j = 1; j <= num_ports-1; ++j)
  87                         if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
  88                                 good_spot = 0;
  89                                 i += j;
  90                                 break;
  91                         }
  92                 if (good_spot == 0)
  93                         continue;
  94
  95                 *minor = i;
  96                 dbg("%s - minor base = %d", __FUNCTION__, *minor);
  97                 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i)
  98                         serial_table[i] = serial;
  99                 return serial;
 100         }
 101         return NULL;
 102 }
 103
 104 static void return_serial(struct usb_serial *serial)
 105 {
 106         int i;
 107
 108         dbg("%s", __FUNCTION__);
 109
 110         if (serial == NULL)
 111                 return;
 112
 113         for (i = 0; i < serial->num_ports; ++i) {
 114                 serial_table[serial->minor + i] = NULL;
 115         }
 116 }
 117
 118 static void destroy_serial(struct kref *kref)
 119 {
 120         struct usb_serial *serial;
 121         struct usb_serial_port *port;
 122         int i;
 123
 124         serial = to_usb_serial(kref);
 125
 126         dbg("%s - %s", __FUNCTION__, serial->type->description);
 127
 128         serial->type->shutdown(serial);
 129
 130         /* return the minor range that this device had */
 131         return_serial(serial);
 132
 133         for (i = 0; i < serial->num_ports; ++i)
 134                 serial->port[i]->open_count = 0;
 135
 136         /* the ports are cleaned up and released in port_release() */
 137         for (i = 0; i < serial->num_ports; ++i)
 138                 if (serial->port[i]->dev.parent != NULL) {
 139                         device_unregister(&serial->port[i]->dev);
 140                         serial->port[i] = NULL;
 141                 }
 142
 143         /* If this is a "fake" port, we have to clean it up here, as it will
 144          * not get cleaned up in port_release() as it was never registered with
 145          * the driver core */
 146         if (serial->num_ports < serial->num_port_pointers) {
 147                 for (i = serial->num_ports; i < serial->num_port_pointers; ++i) {
 148                         port = serial->port[i];
 149                         if (!port)
 150                                 continue;
 151                         port_free(port);
 152                 }
 153         }
 154
 155         usb_put_dev(serial->dev);
 156
 157         /* free up any memory that we allocated */
 158         kfree (serial);
 159 }
 160
 161 void usb_serial_put(struct usb_serial *serial)
 162 {
 163         kref_put(&serial->kref, destroy_serial);
 164 }
 165
 166 /*****************************************************************************
 167  * Driver tty interface functions
 168  *****************************************************************************/
 169 static int serial_open (struct tty_struct *tty, struct file * filp)
 170 {
 171         struct usb_serial *serial;
 172         struct usb_serial_port *port;
 173         unsigned int portNumber;
 174         int retval;
 175
 176         dbg("%s", __FUNCTION__);
 177
 178         /* get the serial object associated with this tty pointer */
 179         serial = usb_serial_get_by_index(tty->index);
 180         if (!serial) {
 181                 tty->driver_data = NULL;
 182                 return -ENODEV;
 183         }
 184
 185         portNumber = tty->index - serial->minor;
 186         port = serial->port[portNumber];
 187         if (!port) {
 188                 retval = -ENODEV;
 189                 goto bailout_kref_put;
 190         }
 191
 192         if (mutex_lock_interruptible(&port->mutex)) {
 193                 retval = -ERESTARTSYS;
 194                 goto bailout_kref_put;
 195         }
 196
 197         ++port->open_count;
 198
 199         /* set up our port structure making the tty driver
 200          * remember our port object, and us it */
 201         tty->driver_data = port;
 202         port->tty = tty;
 203
 204         if (port->open_count == 1) {
 205
 206                 /* lock this module before we call it
 207                  * this may fail, which means we must bail out,
 208                  * safe because we are called with BKL held */
 209                 if (!try_module_get(serial->type->driver.owner)) {
 210                         retval = -ENODEV;
 211                         goto bailout_mutex_unlock;
 212                 }
 213
 214                 /* only call the device specific open if this
 215                  * is the first time the port is opened */
 216                 retval = serial->type->open(port, filp);
 217                 if (retval)
 218                         goto bailout_module_put;
 219         }
 220
 221         mutex_unlock(&port->mutex);
 222         return 0;
 223
 224 bailout_module_put:
 225         module_put(serial->type->driver.owner);
 226 bailout_mutex_unlock:
 227         port->open_count = 0;
 228         tty->driver_data = NULL;
 229         port->tty = NULL;
 230         mutex_unlock(&port->mutex);
 231 bailout_kref_put:
 232         usb_serial_put(serial);
 233         return retval;
 234 }
 235
 236 static void serial_close(struct tty_struct *tty, struct file * filp)
 237 {
 238         struct usb_serial_port *port = tty->driver_data;
 239
 240         if (!port)
 241                 return;
 242
 243         dbg("%s - port %d", __FUNCTION__, port->number);
 244
 245         mutex_lock(&port->mutex);
 246
 247         if (port->open_count == 0) {
 248                 mutex_unlock(&port->mutex);
 249                 return;
 250         }
 251
 252         --port->open_count;
 253         if (port->open_count == 0) {
 254                 /* only call the device specific close if this
 255                  * port is being closed by the last owner */
 256                 port->serial->type->close(port, filp);
 257
 258                 if (port->tty) {
 259                         if (port->tty->driver_data)
 260                                 port->tty->driver_data = NULL;
 261                         port->tty = NULL;
 262                 }
 263
 264                 module_put(port->serial->type->driver.owner);
 265         }
 266
 267         mutex_unlock(&port->mutex);
 268         usb_serial_put(port->serial);
 269 }
 270
 271 static int serial_write (struct tty_struct * tty, const unsigned char *buf, int count)
 272 {
 273         struct usb_serial_port *port = tty->driver_data;
 274         int retval = -EINVAL;
 275
 276         if (!port || port->serial->dev->state == USB_STATE_NOTATTACHED)
 277                 goto exit;
 278
 279         dbg("%s - port %d, %d byte(s)", __FUNCTION__, port->number, count);
 280
 281         if (!port->open_count) {
 282                 dbg("%s - port not opened", __FUNCTION__);
 283                 goto exit;
 284         }
 285
 286         /* pass on to the driver specific version of this function */
 287         retval = port->serial->type->write(port, buf, count);
 288
 289 exit:
 290         return retval;
 291 }
 292
 293 static int serial_write_room (struct tty_struct *tty)
 294 {
 295         struct usb_serial_port *port = tty->driver_data;
 296         int retval = -ENODEV;
 297
 298         if (!port)
 299                 goto exit;
 300
 301         dbg("%s - port %d", __FUNCTION__, port->number);
 302
 303         if (!port->open_count) {
 304                 dbg("%s - port not open", __FUNCTION__);
 305                 goto exit;
 306         }
 307
 308         /* pass on to the driver specific version of this function */
 309         retval = port->serial->type->write_room(port);
 310
 311 exit:
 312         return retval;
 313 }
 314
 315 static int serial_chars_in_buffer (struct tty_struct *tty)
 316 {
 317         struct usb_serial_port *port = tty->driver_data;
 318         int retval = -ENODEV;
 319
 320         if (!port)
 321                 goto exit;
 322
 323         dbg("%s = port %d", __FUNCTION__, port->number);
 324
 325         if (!port->open_count) {
 326                 dbg("%s - port not open", __FUNCTION__);
 327                 goto exit;
 328         }
 329
 330         /* pass on to the driver specific version of this function */
 331         retval = port->serial->type->chars_in_buffer(port);
 332
 333 exit:
 334         return retval;
 335 }
 336
 337 static void serial_throttle (struct tty_struct * tty)
 338 {
 339         struct usb_serial_port *port = tty->driver_data;
 340
 341         if (!port)
 342                 return;
 343
 344         dbg("%s - port %d", __FUNCTION__, port->number);
 345
 346         if (!port->open_count) {
 347                 dbg ("%s - port not open", __FUNCTION__);
 348                 return;
 349         }
 350
 351         /* pass on to the driver specific version of this function */
 352         if (port->serial->type->throttle)
 353                 port->serial->type->throttle(port);
 354 }
 355
 356 static void serial_unthrottle (struct tty_struct * tty)
 357 {
 358         struct usb_serial_port *port = tty->driver_data;
 359
 360         if (!port)
 361                 return;
 362
 363         dbg("%s - port %d", __FUNCTION__, port->number);
 364
 365         if (!port->open_count) {
 366                 dbg("%s - port not open", __FUNCTION__);
 367                 return;
 368         }
 369
 370         /* pass on to the driver specific version of this function */
 371         if (port->serial->type->unthrottle)
 372                 port->serial->type->unthrottle(port);
 373 }
 374
 375 static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
 376 {
 377         struct usb_serial_port *port = tty->driver_data;
 378         int retval = -ENODEV;
 379
 380         if (!port)
 381                 goto exit;
 382
 383         dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd);
 384
 385         if (!port->open_count) {
 386                 dbg ("%s - port not open", __FUNCTION__);
 387                 goto exit;
 388         }
 389
 390         /* pass on to the driver specific version of this function if it is available */
 391         if (port->serial->type->ioctl)
 392                 retval = port->serial->type->ioctl(port, file, cmd, arg);
 393         else
 394                 retval = -ENOIOCTLCMD;
 395
 396 exit:
 397         return retval;
 398 }
 399
 400 static void serial_set_termios (struct tty_struct *tty, struct termios * old)
 401 {
 402         struct usb_serial_port *port = tty->driver_data;
 403
 404         if (!port)
 405                 return;
 406
 407         dbg("%s - port %d", __FUNCTION__, port->number);
 408
 409         if (!port->open_count) {
 410                 dbg("%s - port not open", __FUNCTION__);
 411                 return;
 412         }
 413
 414         /* pass on to the driver specific version of this function if it is available */
 415         if (port->serial->type->set_termios)
 416                 port->serial->type->set_termios(port, old);
 417 }
 418
 419 static void serial_break (struct tty_struct *tty, int break_state)
 420 {
 421         struct usb_serial_port *port = tty->driver_data;
 422
 423         if (!port)
 424                 return;
 425
 426         dbg("%s - port %d", __FUNCTION__, port->number);
 427
 428         if (!port->open_count) {
 429                 dbg("%s - port not open", __FUNCTION__);
 430                 return;
 431         }
 432
 433         /* pass on to the driver specific version of this function if it is available */
 434         if (port->serial->type->break_ctl)
 435                 port->serial->type->break_ctl(port, break_state);
 436 }
 437
 438 static int serial_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data)
 439 {
 440         struct usb_serial *serial;
 441         int length = 0;
 442         int i;
 443         off_t begin = 0;
 444         char tmp[40];
 445
 446         dbg("%s", __FUNCTION__);
 447         length += sprintf (page, "usbserinfo:1.0 driver:2.0\n");
 448         for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
 449                 serial = usb_serial_get_by_index(i);
 450                 if (serial == NULL)
 451                         continue;
 452
 453                 length += sprintf (page+length, "%d:", i);
 454                 if (serial->type->driver.owner)
 455                         length += sprintf (page+length, " module:%s", module_name(serial->type->driver.owner));
 456                 length += sprintf (page+length, " name:\"%s\"", serial->type->description);
 457                 length += sprintf (page+length, " vendor:%04x product:%04x",
 458                                    le16_to_cpu(serial->dev->descriptor.idVendor),
 459                                    le16_to_cpu(serial->dev->descriptor.idProduct));
 460                 length += sprintf (page+length, " num_ports:%d", serial->num_ports);
 461                 length += sprintf (page+length, " port:%d", i - serial->minor + 1);
 462
 463                 usb_make_path(serial->dev, tmp, sizeof(tmp));
 464                 length += sprintf (page+length, " path:%s", tmp);
 465
 466                 length += sprintf (page+length, "\n");
 467                 if ((length + begin) > (off + count))
 468                         goto done;
 469                 if ((length + begin) < off) {
 470                         begin += length;
 471                         length = 0;
 472                 }
 473                 usb_serial_put(serial);
 474         }
 475         *eof = 1;
 476 done:
 477         if (off >= (length + begin))
 478                 return 0;
 479         *start = page + (off-begin);
 480         return ((count < begin+length-off) ? count : begin+length-off);
 481 }
 482
 483 static int serial_tiocmget (struct tty_struct *tty, struct file *file)
 484 {
 485         struct usb_serial_port *port = tty->driver_data;
 486
 487         if (!port)
 488                 return -ENODEV;
 489
 490         dbg("%s - port %d", __FUNCTION__, port->number);
 491
 492         if (!port->open_count) {
 493                 dbg("%s - port not open", __FUNCTION__);
 494                 return -ENODEV;
 495         }
 496
 497         if (port->serial->type->tiocmget)
 498                 return port->serial->type->tiocmget(port, file);
 499
 500         return -EINVAL;
 501 }
 502
 503 static int serial_tiocmset (struct tty_struct *tty, struct file *file,
 504                             unsigned int set, unsigned int clear)
 505 {
 506         struct usb_serial_port *port = tty->driver_data;
 507
 508         if (!port)
 509                 return -ENODEV;
 510
 511         dbg("%s - port %d", __FUNCTION__, port->number);
 512
 513         if (!port->open_count) {
 514                 dbg("%s - port not open", __FUNCTION__);
 515                 return -ENODEV;
 516         }
 517
 518         if (port->serial->type->tiocmset)
 519                 return port->serial->type->tiocmset(port, file, set, clear);
 520
 521         return -EINVAL;
 522 }
 523
 524 /*
 525  * We would be calling tty_wakeup here, but unfortunately some line
 526  * disciplines have an annoying habit of calling tty->write from
 527  * the write wakeup callback (e.g. n_hdlc.c).
 528  */
 529 void usb_serial_port_softint(struct usb_serial_port *port)
 530 {
 531         schedule_work(&port->work);
 532 }
 533
 534 static void usb_serial_port_work(void *private)
 535 {
 536         struct usb_serial_port *port = private;
 537         struct tty_struct *tty;
 538
 539         dbg("%s - port %d", __FUNCTION__, port->number);
 540
 541         if (!port)
 542                 return;
 543
 544         tty = port->tty;
 545         if (!tty)
 546                 return;
 547
 548         tty_wakeup(tty);
 549 }
 550
 551 static void port_release(struct device *dev)
 552 {
 553         struct usb_serial_port *port = to_usb_serial_port(dev);
 554
 555         dbg ("%s - %s", __FUNCTION__, dev->bus_id);
 556         port_free(port);
 557 }
 558
 559 static void port_free(struct usb_serial_port *port)
 560 {
 561         usb_kill_urb(port->read_urb);
 562         usb_free_urb(port->read_urb);
 563         usb_kill_urb(port->write_urb);
 564         usb_free_urb(port->write_urb);
 565         usb_kill_urb(port->interrupt_in_urb);
 566         usb_free_urb(port->interrupt_in_urb);
 567         usb_kill_urb(port->interrupt_out_urb);
 568         usb_free_urb(port->interrupt_out_urb);
 569         kfree(port->bulk_in_buffer);
 570         kfree(port->bulk_out_buffer);
 571         kfree(port->interrupt_in_buffer);
 572         kfree(port->interrupt_out_buffer);
 573         flush_scheduled_work();         /* port->work */
 574         kfree(port);
 575 }
 576
 577 static struct usb_serial * create_serial (struct usb_device *dev,
 578                                           struct usb_interface *interface,
 579                                           struct usb_serial_driver *driver)
 580 {
 581         struct usb_serial *serial;
 582
 583         serial = kzalloc(sizeof(*serial), GFP_KERNEL);
 584         if (!serial) {
 585                 dev_err(&dev->dev, "%s - out of memory\n", __FUNCTION__);
 586                 return NULL;
 587         }
 588         serial->dev = usb_get_dev(dev);
 589         serial->type = driver;
 590         serial->interface = interface;
 591         kref_init(&serial->kref);
 592
 593         return serial;
 594 }
 595
 596 static struct usb_serial_driver *search_serial_device(struct usb_interface *iface)
 597 {
 598         struct list_head *p;
 599         const struct usb_device_id *id;
 600         struct usb_serial_driver *t;
 601
 602         /* Check if the usb id matches a known device */
 603         list_for_each(p, &usb_serial_driver_list) {
 604                 t = list_entry(p, struct usb_serial_driver, driver_list);
 605                 id = usb_match_id(iface, t->id_table);
 606                 if (id != NULL) {
 607                         dbg("descriptor matches");
 608                         return t;
 609                 }
 610         }
 611
 612         return NULL;
 613 }
 614
 615 int usb_serial_probe(struct usb_interface *interface,
 616                                const struct usb_device_id *id)
 617 {
 618         struct usb_device *dev = interface_to_usbdev (interface);
 619         struct usb_serial *serial = NULL;
 620         struct usb_serial_port *port;
 621         struct usb_host_interface *iface_desc;
 622         struct usb_endpoint_descriptor *endpoint;
 623         struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
 624         struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
 625         struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
 626         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
 627         struct usb_serial_driver *type = NULL;
 628         int retval;
 629         int minor;
 630         int buffer_size;
 631         int i;
 632         int num_interrupt_in = 0;
 633         int num_interrupt_out = 0;
 634         int num_bulk_in = 0;
 635         int num_bulk_out = 0;
 636         int num_ports = 0;
 637         int max_endpoints;
 638
 639         type = search_serial_device(interface);
 640         if (!type) {
 641                 dbg("none matched");
 642                 return -ENODEV;
 643         }
 644
 645         serial = create_serial (dev, interface, type);
 646         if (!serial) {
 647                 dev_err(&interface->dev, "%s - out of memory\n", __FUNCTION__);
 648                 return -ENOMEM;
 649         }
 650
 651         /* if this device type has a probe function, call it */
 652         if (type->probe) {
 653                 const struct usb_device_id *id;
 654
 655                 if (!try_module_get(type->driver.owner)) {
 656                         dev_err(&interface->dev, "module get failed, exiting\n");
 657                         kfree (serial);
 658                         return -EIO;
 659                 }
 660
 661                 id = usb_match_id(interface, type->id_table);
 662                 retval = type->probe(serial, id);
 663                 module_put(type->driver.owner);
 664
 665                 if (retval) {
 666                         dbg ("sub driver rejected device");
 667                         kfree (serial);
 668                         return retval;
 669                 }
 670         }
 671
 672         /* descriptor matches, let's find the endpoints needed */
 673         /* check out the endpoints */
 674         iface_desc = interface->cur_altsetting;
 675         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 676                 endpoint = &iface_desc->endpoint[i].desc;
 677
 678                 if ((endpoint->bEndpointAddress & 0x80) &&
 679                     ((endpoint->bmAttributes & 3) == 0x02)) {
 680                         /* we found a bulk in endpoint */
 681                         dbg("found bulk in on endpoint %d", i);
 682                         bulk_in_endpoint[num_bulk_in] = endpoint;
 683                         ++num_bulk_in;
 684                 }
 685
 686                 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
 687                     ((endpoint->bmAttributes & 3) == 0x02)) {
 688                         /* we found a bulk out endpoint */
 689                         dbg("found bulk out on endpoint %d", i);
 690                         bulk_out_endpoint[num_bulk_out] = endpoint;
 691                         ++num_bulk_out;
 692                 }
 693
 694                 if ((endpoint->bEndpointAddress & 0x80) &&
 695                     ((endpoint->bmAttributes & 3) == 0x03)) {
 696                         /* we found a interrupt in endpoint */
 697                         dbg("found interrupt in on endpoint %d", i);
 698                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 699                         ++num_interrupt_in;
 700                 }
 701
 702                 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
 703                     ((endpoint->bmAttributes & 3) == 0x03)) {
 704                         /* we found an interrupt out endpoint */
 705                         dbg("found interrupt out on endpoint %d", i);
 706                         interrupt_out_endpoint[num_interrupt_out] = endpoint;
 707                         ++num_interrupt_out;
 708                 }
 709         }
 710
 711 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
 712         /* BEGIN HORRIBLE HACK FOR PL2303 */
 713         /* this is needed due to the looney way its endpoints are set up */
 714         if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
 715              (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
 716             ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
 717              (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID))) {
 718                 if (interface != dev->actconfig->interface[0]) {
 719                         /* check out the endpoints of the other interface*/
 720                         iface_desc = dev->actconfig->interface[0]->cur_altsetting;
 721                         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 722                                 endpoint = &iface_desc->endpoint[i].desc;
 723                                 if ((endpoint->bEndpointAddress & 0x80) &&
 724                                     ((endpoint->bmAttributes & 3) == 0x03)) {
 725                                         /* we found a interrupt in endpoint */
 726                                         dbg("found interrupt in for Prolific device on separate interface");
 727                                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 728                                         ++num_interrupt_in;
 729                                 }
 730                         }
 731                 }
 732
 733                 /* Now make sure the PL-2303 is configured correctly.
 734                  * If not, give up now and hope this hack will work
 735                  * properly during a later invocation of usb_serial_probe
 736                  */
 737                 if (num_bulk_in == 0 || num_bulk_out == 0) {
 738                         dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
 739                         kfree (serial);
 740                         return -ENODEV;
 741                 }
 742         }
 743         /* END HORRIBLE HACK FOR PL2303 */
 744 #endif
 745
 746         /* found all that we need */
 747         dev_info(&interface->dev, "%s converter detected\n", type->description);
 748
 749 #ifdef CONFIG_USB_SERIAL_GENERIC
 750         if (type == &usb_serial_generic_device) {
 751                 num_ports = num_bulk_out;
 752                 if (num_ports == 0) {
 753                         dev_err(&interface->dev, "Generic device with no bulk out, not allowed.\n");
 754                         kfree (serial);
 755                         return -EIO;
 756                 }
 757         }
 758 #endif
 759         if (!num_ports) {
 760                 /* if this device type has a calc_num_ports function, call it */
 761                 if (type->calc_num_ports) {
 762                         if (!try_module_get(type->driver.owner)) {
 763                                 dev_err(&interface->dev, "module get failed, exiting\n");
 764                                 kfree (serial);
 765                                 return -EIO;
 766                         }
 767                         num_ports = type->calc_num_ports (serial);
 768                         module_put(type->driver.owner);
 769                 }
 770                 if (!num_ports)
 771                         num_ports = type->num_ports;
 772         }
 773
 774         if (get_free_serial (serial, num_ports, &minor) == NULL) {
 775                 dev_err(&interface->dev, "No more free serial devices\n");
 776                 kfree (serial);
 777                 return -ENOMEM;
 778         }
 779
 780         serial->minor = minor;
 781         serial->num_ports = num_ports;
 782         serial->num_bulk_in = num_bulk_in;
 783         serial->num_bulk_out = num_bulk_out;
 784         serial->num_interrupt_in = num_interrupt_in;
 785         serial->num_interrupt_out = num_interrupt_out;
 786
 787         /* create our ports, we need as many as the max endpoints */
 788         /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
 789         max_endpoints = max(num_bulk_in, num_bulk_out);
 790         max_endpoints = max(max_endpoints, num_interrupt_in);
 791         max_endpoints = max(max_endpoints, num_interrupt_out);
 792         max_endpoints = max(max_endpoints, (int)serial->num_ports);
 793         serial->num_port_pointers = max_endpoints;
 794         dbg("%s - setting up %d port structures for this device", __FUNCTION__, max_endpoints);
 795         for (i = 0; i < max_endpoints; ++i) {
 796                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 797                 if (!port)
 798                         goto probe_error;
 799                 port->number = i + serial->minor;
 800                 port->serial = serial;
 801                 spin_lock_init(&port->lock);
 802                 mutex_init(&port->mutex);
 803                 INIT_WORK(&port->work, usb_serial_port_work, port);
 804                 serial->port[i] = port;
 805         }
 806
 807         /* set up the endpoint information */
 808         for (i = 0; i < num_bulk_in; ++i) {
 809                 endpoint = bulk_in_endpoint[i];
 810                 port = serial->port[i];
 811                 port->read_urb = usb_alloc_urb (0, GFP_KERNEL);
 812                 if (!port->read_urb) {
 813                         dev_err(&interface->dev, "No free urbs available\n");
 814                         goto probe_error;
 815                 }
 816                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 817                 port->bulk_in_size = buffer_size;
 818                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 819                 port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
 820                 if (!port->bulk_in_buffer) {
 821                         dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer\n");
 822                         goto probe_error;
 823                 }
 824                 usb_fill_bulk_urb (port->read_urb, dev,
 825                                    usb_rcvbulkpipe (dev,
 826                                                     endpoint->bEndpointAddress),
 827                                    port->bulk_in_buffer, buffer_size,
 828                                    serial->type->read_bulk_callback,
 829                                    port);
 830         }
 831
 832         for (i = 0; i < num_bulk_out; ++i) {
 833                 endpoint = bulk_out_endpoint[i];
 834                 port = serial->port[i];
 835                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
 836                 if (!port->write_urb) {
 837                         dev_err(&interface->dev, "No free urbs available\n");
 838                         goto probe_error;
 839                 }
 840                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 841                 port->bulk_out_size = buffer_size;
 842                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 843                 port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
 844                 if (!port->bulk_out_buffer) {
 845                         dev_err(&interface->dev, "Couldn't allocate bulk_out_buffer\n");
 846                         goto probe_error;
 847                 }
 848                 usb_fill_bulk_urb (port->write_urb, dev,
 849                                    usb_sndbulkpipe (dev,
 850                                                     endpoint->bEndpointAddress),
 851                                    port->bulk_out_buffer, buffer_size,
 852                                    serial->type->write_bulk_callback,
 853                                    port);
 854         }
 855
 856         if (serial->type->read_int_callback) {
 857                 for (i = 0; i < num_interrupt_in; ++i) {
 858                         endpoint = interrupt_in_endpoint[i];
 859                         port = serial->port[i];
 860                         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 861                         if (!port->interrupt_in_urb) {
 862                                 dev_err(&interface->dev, "No free urbs available\n");
 863                                 goto probe_error;
 864                         }
 865                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 866                         port->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
 867                         port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
 868                         if (!port->interrupt_in_buffer) {
 869                                 dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n");
 870                                 goto probe_error;
 871                         }
 872                         usb_fill_int_urb (port->interrupt_in_urb, dev,
 873                                           usb_rcvintpipe (dev,
 874                                                           endpoint->bEndpointAddress),
 875                                           port->interrupt_in_buffer, buffer_size,
 876                                           serial->type->read_int_callback, port,
 877                                           endpoint->bInterval);
 878                 }
 879         } else if (num_interrupt_in) {
 880                 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
 881         }
 882
 883         if (serial->type->write_int_callback) {
 884                 for (i = 0; i < num_interrupt_out; ++i) {
 885                         endpoint = interrupt_out_endpoint[i];
 886                         port = serial->port[i];
 887                         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
 888                         if (!port->interrupt_out_urb) {
 889                                 dev_err(&interface->dev, "No free urbs available\n");
 890                                 goto probe_error;
 891                         }
 892                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 893                         port->interrupt_out_size = buffer_size;
 894                         port->interrupt_out_endpointAddress = endpoint->bEndpointAddress;
 895                         port->interrupt_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
 896                         if (!port->interrupt_out_buffer) {
 897                                 dev_err(&interface->dev, "Couldn't allocate interrupt_out_buffer\n");
 898                                 goto probe_error;
 899                         }
 900                         usb_fill_int_urb (port->interrupt_out_urb, dev,
 901                                           usb_sndintpipe (dev,
 902                                                           endpoint->bEndpointAddress),
 903                                           port->interrupt_out_buffer, buffer_size,
 904                                           serial->type->write_int_callback, port,
 905                                           endpoint->bInterval);
 906                 }
 907         } else if (num_interrupt_out) {
 908                 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
 909         }
 910
 911         /* if this device type has an attach function, call it */
 912         if (type->attach) {
 913                 if (!try_module_get(type->driver.owner)) {
 914                         dev_err(&interface->dev, "module get failed, exiting\n");
 915                         goto probe_error;
 916                 }
 917                 retval = type->attach (serial);
 918                 module_put(type->driver.owner);
 919                 if (retval < 0)
 920                         goto probe_error;
 921                 if (retval > 0) {
 922                         /* quietly accept this device, but don't bind to a serial port
 923                          * as it's about to disappear */
 924                         goto exit;
 925                 }
 926         }
 927
 928         /* register all of the individual ports with the driver core */
 929         for (i = 0; i < num_ports; ++i) {
 930                 port = serial->port[i];
 931                 port->dev.parent = &interface->dev;
 932                 port->dev.driver = NULL;
 933                 port->dev.bus = &usb_serial_bus_type;
 934                 port->dev.release = &port_release;
 935
 936                 snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number);
 937                 dbg ("%s - registering %s", __FUNCTION__, port->dev.bus_id);
 938                 device_register (&port->dev);
 939         }
 940
 941         usb_serial_console_init (debug, minor);
 942
 943 exit:
 944         /* success */
 945         usb_set_intfdata (interface, serial);
 946         return 0;
 947
 948 probe_error:
 949         for (i = 0; i < num_bulk_in; ++i) {
 950                 port = serial->port[i];
 951                 if (!port)
 952                         continue;
 953                 if (port->read_urb)
 954                         usb_free_urb (port->read_urb);
 955                 kfree(port->bulk_in_buffer);
 956         }
 957         for (i = 0; i < num_bulk_out; ++i) {
 958                 port = serial->port[i];
 959                 if (!port)
 960                         continue;
 961                 if (port->write_urb)
 962                         usb_free_urb (port->write_urb);
 963                 kfree(port->bulk_out_buffer);
 964         }
 965         for (i = 0; i < num_interrupt_in; ++i) {
 966                 port = serial->port[i];
 967                 if (!port)
 968                         continue;
 969                 if (port->interrupt_in_urb)
 970                         usb_free_urb (port->interrupt_in_urb);
 971                 kfree(port->interrupt_in_buffer);
 972         }
 973         for (i = 0; i < num_interrupt_out; ++i) {
 974                 port = serial->port[i];
 975                 if (!port)
 976                         continue;
 977                 if (port->interrupt_out_urb)
 978                         usb_free_urb (port->interrupt_out_urb);
 979                 kfree(port->interrupt_out_buffer);
 980         }
 981
 982         /* return the minor range that this device had */
 983         return_serial (serial);
 984
 985         /* free up any memory that we allocated */
 986         for (i = 0; i < serial->num_port_pointers; ++i)
 987                 kfree(serial->port[i]);
 988         kfree (serial);
 989         return -EIO;
 990 }
 991
 992 void usb_serial_disconnect(struct usb_interface *interface)
 993 {
 994         int i;
 995         struct usb_serial *serial = usb_get_intfdata (interface);
 996         struct device *dev = &interface->dev;
 997         struct usb_serial_port *port;
 998
 999         usb_serial_console_disconnect(serial);
1000         dbg ("%s", __FUNCTION__);
1001
1002         usb_set_intfdata (interface, NULL);
1003         if (serial) {
1004                 for (i = 0; i < serial->num_ports; ++i) {
1005                         port = serial->port[i];
1006                         if (port && port->tty)
1007                                 tty_hangup(port->tty);
1008                 }
1009                 /* let the last holder of this object
1010                  * cause it to be cleaned up */
1011                 usb_serial_put(serial);
1012         }
1013         dev_info(dev, "device disconnected\n");
1014 }
1015
1016 static struct tty_operations serial_ops = {
1017         .open =                 serial_open,
1018         .close =                serial_close,
1019         .write =                serial_write,
1020         .write_room =           serial_write_room,
1021         .ioctl =                serial_ioctl,
1022         .set_termios =          serial_set_termios,
1023         .throttle =             serial_throttle,
1024         .unthrottle =           serial_unthrottle,
1025         .break_ctl =            serial_break,
1026         .chars_in_buffer =      serial_chars_in_buffer,
1027         .read_proc =            serial_read_proc,
1028         .tiocmget =             serial_tiocmget,
1029         .tiocmset =             serial_tiocmset,
1030 };
1031
1032 struct tty_driver *usb_serial_tty_driver;
1033
1034 static int __init usb_serial_init(void)
1035 {
1036         int i;
1037         int result;
1038
1039         usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1040         if (!usb_serial_tty_driver)
1041                 return -ENOMEM;
1042
1043         /* Initialize our global data */
1044         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
1045                 serial_table[i] = NULL;
1046         }
1047
1048         result = bus_register(&usb_serial_bus_type);
1049         if (result) {
1050                 err("%s - registering bus driver failed", __FUNCTION__);
1051                 goto exit_bus;
1052         }
1053
1054         usb_serial_tty_driver->owner = THIS_MODULE;
1055         usb_serial_tty_driver->driver_name = "usbserial";
1056         usb_serial_tty_driver->name =   "ttyUSB";
1057         usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1058         usb_serial_tty_driver->minor_start = 0;
1059         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1060         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1061         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1062         usb_serial_tty_driver->init_termios = tty_std_termios;
1063         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1064         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1065         result = tty_register_driver(usb_serial_tty_driver);
1066         if (result) {
1067                 err("%s - tty_register_driver failed", __FUNCTION__);
1068                 goto exit_reg_driver;
1069         }
1070
1071         /* register the USB driver */
1072         result = usb_register(&usb_serial_driver);
1073         if (result < 0) {
1074                 err("%s - usb_register failed", __FUNCTION__);
1075                 goto exit_tty;
1076         }
1077
1078         /* register the generic driver, if we should */
1079         result = usb_serial_generic_register(debug);
1080         if (result < 0) {
1081                 err("%s - registering generic driver failed", __FUNCTION__);
1082                 goto exit_generic;
1083         }
1084
1085         info(DRIVER_DESC);
1086
1087         return result;
1088
1089 exit_generic:
1090         usb_deregister(&usb_serial_driver);
1091
1092 exit_tty:
1093         tty_unregister_driver(usb_serial_tty_driver);
1094
1095 exit_reg_driver:
1096         bus_unregister(&usb_serial_bus_type);
1097
1098 exit_bus:
1099         err ("%s - returning with error %d", __FUNCTION__, result);
1100         put_tty_driver(usb_serial_tty_driver);
1101         return result;
1102 }
1103
1104
1105 static void __exit usb_serial_exit(void)
1106 {
1107         usb_serial_console_exit();
1108
1109         usb_serial_generic_deregister();
1110
1111         usb_deregister(&usb_serial_driver);
1112         tty_unregister_driver(usb_serial_tty_driver);
1113         put_tty_driver(usb_serial_tty_driver);
1114         bus_unregister(&usb_serial_bus_type);
1115 }
1116
1117
1118 module_init(usb_serial_init);
1119 module_exit(usb_serial_exit);
1120
1121 #define set_to_generic_if_null(type, function)                          \
1122         do {                                                            \
1123                 if (!type->function) {                                  \
1124                         type->function = usb_serial_generic_##function; \
1125                         dbg("Had to override the " #function            \
1126                                  " usb serial operation with the generic one.");\
1127                         }                                               \
1128         } while (0)
1129
1130 static void fixup_generic(struct usb_serial_driver *device)
1131 {
1132         set_to_generic_if_null(device, open);
1133         set_to_generic_if_null(device, write);
1134         set_to_generic_if_null(device, close);
1135         set_to_generic_if_null(device, write_room);
1136         set_to_generic_if_null(device, chars_in_buffer);
1137         set_to_generic_if_null(device, read_bulk_callback);
1138         set_to_generic_if_null(device, write_bulk_callback);
1139         set_to_generic_if_null(device, shutdown);
1140 }
1141
1142 int usb_serial_register(struct usb_serial_driver *driver)
1143 {
1144         int retval;
1145
1146         fixup_generic(driver);
1147
1148         if (!driver->description)
1149                 driver->description = driver->driver.name;
1150
1151         /* Add this device to our list of devices */
1152         list_add(&driver->driver_list, &usb_serial_driver_list);
1153
1154         retval = usb_serial_bus_register(driver);
1155         if (retval) {
1156                 err("problem %d when registering driver %s", retval, driver->description);
1157                 list_del(&driver->driver_list);
1158         }
1159         else
1160                 info("USB Serial support registered for %s", driver->description);
1161
1162         return retval;
1163 }
1164
1165
1166 void usb_serial_deregister(struct usb_serial_driver *device)
1167 {
1168         info("USB Serial deregistering driver %s", device->description);
1169         list_del(&device->driver_list);
1170         usb_serial_bus_deregister(device);
1171 }
1172
1173
1174
1175 /* If the usb-serial core is built into the core, the usb-serial drivers
1176    need these symbols to load properly as modules. */
1177 EXPORT_SYMBOL_GPL(usb_serial_register);
1178 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1179 EXPORT_SYMBOL_GPL(usb_serial_probe);
1180 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1181 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
1182
1183
1184 /* Module information */
1185 MODULE_AUTHOR( DRIVER_AUTHOR );
1186 MODULE_DESCRIPTION( DRIVER_DESC );
1187 MODULE_LICENSE("GPL");
1188
1189 module_param(debug, bool, S_IRUGO | S_IWUSR);
1190 MODULE_PARM_DESC(debug, "Debug enabled or not");