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