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