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         /* if the device was unplugged then any remaining characters
 343            fell out of the connector ;) */
 344         if (port->serial->disconnected)
 345                 return 0;
 346         /* pass on to the driver specific version of this function */
 347         return port->serial->type->chars_in_buffer(tty);
 348 }
 349
 350 static void serial_throttle(struct tty_struct *tty)
 351 {
 352         struct usb_serial_port *port = tty->driver_data;
 353         dbg("%s - port %d", __func__, port->number);
 354
 355         WARN_ON(!port->port.count);
 356         /* pass on to the driver specific version of this function */
 357         if (port->serial->type->throttle)
 358                 port->serial->type->throttle(tty);
 359 }
 360
 361 static void serial_unthrottle(struct tty_struct *tty)
 362 {
 363         struct usb_serial_port *port = tty->driver_data;
 364         dbg("%s - port %d", __func__, port->number);
 365
 366         WARN_ON(!port->port.count);
 367         /* pass on to the driver specific version of this function */
 368         if (port->serial->type->unthrottle)
 369                 port->serial->type->unthrottle(tty);
 370 }
 371
 372 static int serial_ioctl(struct tty_struct *tty, struct file *file,
 373                                         unsigned int cmd, unsigned long arg)
 374 {
 375         struct usb_serial_port *port = tty->driver_data;
 376         int retval = -ENODEV;
 377
 378         dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
 379
 380         WARN_ON(!port->port.count);
 381
 382         /* pass on to the driver specific version of this function
 383            if it is available */
 384         if (port->serial->type->ioctl) {
 385                 retval = port->serial->type->ioctl(tty, file, cmd, arg);
 386         } else
 387                 retval = -ENOIOCTLCMD;
 388         return retval;
 389 }
 390
 391 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
 392 {
 393         struct usb_serial_port *port = tty->driver_data;
 394         dbg("%s - port %d", __func__, port->number);
 395
 396         WARN_ON(!port->port.count);
 397         /* pass on to the driver specific version of this function
 398            if it is available */
 399         if (port->serial->type->set_termios)
 400                 port->serial->type->set_termios(tty, port, old);
 401         else
 402                 tty_termios_copy_hw(tty->termios, old);
 403 }
 404
 405 static int serial_break(struct tty_struct *tty, int break_state)
 406 {
 407         struct usb_serial_port *port = tty->driver_data;
 408
 409         dbg("%s - port %d", __func__, port->number);
 410
 411         WARN_ON(!port->port.count);
 412         /* pass on to the driver specific version of this function
 413            if it is available */
 414         if (port->serial->type->break_ctl)
 415                 port->serial->type->break_ctl(tty, break_state);
 416         return 0;
 417 }
 418
 419 static int serial_read_proc(char *page, char **start, off_t off, int count,
 420                                                         int *eof, void *data)
 421 {
 422         struct usb_serial *serial;
 423         int length = 0;
 424         int i;
 425         off_t begin = 0;
 426         char tmp[40];
 427
 428         dbg("%s", __func__);
 429         length += sprintf(page, "usbserinfo:1.0 driver:2.0\n");
 430         for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
 431                 serial = usb_serial_get_by_index(i);
 432                 if (serial == NULL)
 433                         continue;
 434
 435                 length += sprintf(page+length, "%d:", i);
 436                 if (serial->type->driver.owner)
 437                         length += sprintf(page+length, " module:%s",
 438                                 module_name(serial->type->driver.owner));
 439                 length += sprintf(page+length, " name:\"%s\"",
 440                                 serial->type->description);
 441                 length += sprintf(page+length, " vendor:%04x product:%04x",
 442                         le16_to_cpu(serial->dev->descriptor.idVendor),
 443                         le16_to_cpu(serial->dev->descriptor.idProduct));
 444                 length += sprintf(page+length, " num_ports:%d",
 445                                                         serial->num_ports);
 446                 length += sprintf(page+length, " port:%d",
 447                                                         i - serial->minor + 1);
 448                 usb_make_path(serial->dev, tmp, sizeof(tmp));
 449                 length += sprintf(page+length, " path:%s", tmp);
 450
 451                 length += sprintf(page+length, "\n");
 452                 if ((length + begin) > (off + count)) {
 453                         usb_serial_put(serial);
 454                         goto done;
 455                 }
 456                 if ((length + begin) < off) {
 457                         begin += length;
 458                         length = 0;
 459                 }
 460                 usb_serial_put(serial);
 461         }
 462         *eof = 1;
 463 done:
 464         if (off >= (length + begin))
 465                 return 0;
 466         *start = page + (off-begin);
 467         return (count < begin+length-off) ? count : begin+length-off;
 468 }
 469
 470 static int serial_tiocmget(struct tty_struct *tty, struct file *file)
 471 {
 472         struct usb_serial_port *port = tty->driver_data;
 473
 474         dbg("%s - port %d", __func__, port->number);
 475
 476         WARN_ON(!port->port.count);
 477         if (port->serial->type->tiocmget)
 478                 return port->serial->type->tiocmget(tty, file);
 479         return -EINVAL;
 480 }
 481
 482 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
 483                             unsigned int set, unsigned int clear)
 484 {
 485         struct usb_serial_port *port = tty->driver_data;
 486
 487         dbg("%s - port %d", __func__, port->number);
 488
 489         WARN_ON(!port->port.count);
 490         if (port->serial->type->tiocmset)
 491                 return port->serial->type->tiocmset(tty, file, set, clear);
 492         return -EINVAL;
 493 }
 494
 495 /*
 496  * We would be calling tty_wakeup here, but unfortunately some line
 497  * disciplines have an annoying habit of calling tty->write from
 498  * the write wakeup callback (e.g. n_hdlc.c).
 499  */
 500 void usb_serial_port_softint(struct usb_serial_port *port)
 501 {
 502         schedule_work(&port->work);
 503 }
 504 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
 505
 506 static void usb_serial_port_work(struct work_struct *work)
 507 {
 508         struct usb_serial_port *port =
 509                 container_of(work, struct usb_serial_port, work);
 510         struct tty_struct *tty;
 511
 512         dbg("%s - port %d", __func__, port->number);
 513
 514         if (!port)
 515                 return;
 516
 517         tty = tty_port_tty_get(&port->port);
 518         if (!tty)
 519                 return;
 520
 521         tty_wakeup(tty);
 522         tty_kref_put(tty);
 523 }
 524
 525 static void port_release(struct device *dev)
 526 {
 527         struct usb_serial_port *port = to_usb_serial_port(dev);
 528
 529         dbg ("%s - %s", __func__, dev_name(dev));
 530         port_free(port);
 531 }
 532
 533 static void kill_traffic(struct usb_serial_port *port)
 534 {
 535         usb_kill_urb(port->read_urb);
 536         usb_kill_urb(port->write_urb);
 537         /*
 538          * This is tricky.
 539          * Some drivers submit the read_urb in the
 540          * handler for the write_urb or vice versa
 541          * this order determines the order in which
 542          * usb_kill_urb() must be used to reliably
 543          * kill the URBs. As it is unknown here,
 544          * both orders must be used in turn.
 545          * The call below is not redundant.
 546          */
 547         usb_kill_urb(port->read_urb);
 548         usb_kill_urb(port->interrupt_in_urb);
 549         usb_kill_urb(port->interrupt_out_urb);
 550 }
 551
 552 static void port_free(struct usb_serial_port *port)
 553 {
 554         kill_traffic(port);
 555         usb_free_urb(port->read_urb);
 556         usb_free_urb(port->write_urb);
 557         usb_free_urb(port->interrupt_in_urb);
 558         usb_free_urb(port->interrupt_out_urb);
 559         kfree(port->bulk_in_buffer);
 560         kfree(port->bulk_out_buffer);
 561         kfree(port->interrupt_in_buffer);
 562         kfree(port->interrupt_out_buffer);
 563         flush_scheduled_work();         /* port->work */
 564         kfree(port);
 565 }
 566
 567 static struct usb_serial *create_serial(struct usb_device *dev,
 568                                         struct usb_interface *interface,
 569                                         struct usb_serial_driver *driver)
 570 {
 571         struct usb_serial *serial;
 572
 573         serial = kzalloc(sizeof(*serial), GFP_KERNEL);
 574         if (!serial) {
 575                 dev_err(&dev->dev, "%s - out of memory\n", __func__);
 576                 return NULL;
 577         }
 578         serial->dev = usb_get_dev(dev);
 579         serial->type = driver;
 580         serial->interface = interface;
 581         kref_init(&serial->kref);
 582         mutex_init(&serial->disc_mutex);
 583         serial->minor = SERIAL_TTY_NO_MINOR;
 584
 585         return serial;
 586 }
 587
 588 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
 589                                             struct usb_serial_driver *drv)
 590 {
 591         struct usb_dynid *dynid;
 592
 593         spin_lock(&drv->dynids.lock);
 594         list_for_each_entry(dynid, &drv->dynids.list, node) {
 595                 if (usb_match_one_id(intf, &dynid->id)) {
 596                         spin_unlock(&drv->dynids.lock);
 597                         return &dynid->id;
 598                 }
 599         }
 600         spin_unlock(&drv->dynids.lock);
 601         return NULL;
 602 }
 603
 604 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
 605                                                 struct usb_interface *intf)
 606 {
 607         const struct usb_device_id *id;
 608
 609         id = usb_match_id(intf, drv->id_table);
 610         if (id) {
 611                 dbg("static descriptor matches");
 612                 goto exit;
 613         }
 614         id = match_dynamic_id(intf, drv);
 615         if (id)
 616                 dbg("dynamic descriptor matches");
 617 exit:
 618         return id;
 619 }
 620
 621 static struct usb_serial_driver *search_serial_device(
 622                                         struct usb_interface *iface)
 623 {
 624         const struct usb_device_id *id;
 625         struct usb_serial_driver *drv;
 626
 627         /* Check if the usb id matches a known device */
 628         list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
 629                 id = get_iface_id(drv, iface);
 630                 if (id)
 631                         return drv;
 632         }
 633
 634         return NULL;
 635 }
 636
 637 int usb_serial_probe(struct usb_interface *interface,
 638                                const struct usb_device_id *id)
 639 {
 640         struct usb_device *dev = interface_to_usbdev(interface);
 641         struct usb_serial *serial = NULL;
 642         struct usb_serial_port *port;
 643         struct usb_host_interface *iface_desc;
 644         struct usb_endpoint_descriptor *endpoint;
 645         struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
 646         struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
 647         struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
 648         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
 649         struct usb_serial_driver *type = NULL;
 650         int retval;
 651         unsigned int minor;
 652         int buffer_size;
 653         int i;
 654         int num_interrupt_in = 0;
 655         int num_interrupt_out = 0;
 656         int num_bulk_in = 0;
 657         int num_bulk_out = 0;
 658         int num_ports = 0;
 659         int max_endpoints;
 660
 661         lock_kernel(); /* guard against unloading a serial driver module */
 662         type = search_serial_device(interface);
 663         if (!type) {
 664                 unlock_kernel();
 665                 dbg("none matched");
 666                 return -ENODEV;
 667         }
 668
 669         serial = create_serial(dev, interface, type);
 670         if (!serial) {
 671                 unlock_kernel();
 672                 dev_err(&interface->dev, "%s - out of memory\n", __func__);
 673                 return -ENOMEM;
 674         }
 675
 676         /* if this device type has a probe function, call it */
 677         if (type->probe) {
 678                 const struct usb_device_id *id;
 679
 680                 if (!try_module_get(type->driver.owner)) {
 681                         unlock_kernel();
 682                         dev_err(&interface->dev,
 683                                 "module get failed, exiting\n");
 684                         kfree(serial);
 685                         return -EIO;
 686                 }
 687
 688                 id = get_iface_id(type, interface);
 689                 retval = type->probe(serial, id);
 690                 module_put(type->driver.owner);
 691
 692                 if (retval) {
 693                         unlock_kernel();
 694                         dbg("sub driver rejected device");
 695                         kfree(serial);
 696                         return retval;
 697                 }
 698         }
 699
 700         /* descriptor matches, let's find the endpoints needed */
 701         /* check out the endpoints */
 702         iface_desc = interface->cur_altsetting;
 703         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 704                 endpoint = &iface_desc->endpoint[i].desc;
 705
 706                 if (usb_endpoint_is_bulk_in(endpoint)) {
 707                         /* we found a bulk in endpoint */
 708                         dbg("found bulk in on endpoint %d", i);
 709                         bulk_in_endpoint[num_bulk_in] = endpoint;
 710                         ++num_bulk_in;
 711                 }
 712
 713                 if (usb_endpoint_is_bulk_out(endpoint)) {
 714                         /* we found a bulk out endpoint */
 715                         dbg("found bulk out on endpoint %d", i);
 716                         bulk_out_endpoint[num_bulk_out] = endpoint;
 717                         ++num_bulk_out;
 718                 }
 719
 720                 if (usb_endpoint_is_int_in(endpoint)) {
 721                         /* we found a interrupt in endpoint */
 722                         dbg("found interrupt in on endpoint %d", i);
 723                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 724                         ++num_interrupt_in;
 725                 }
 726
 727                 if (usb_endpoint_is_int_out(endpoint)) {
 728                         /* we found an interrupt out endpoint */
 729                         dbg("found interrupt out on endpoint %d", i);
 730                         interrupt_out_endpoint[num_interrupt_out] = endpoint;
 731                         ++num_interrupt_out;
 732                 }
 733         }
 734
 735 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
 736         /* BEGIN HORRIBLE HACK FOR PL2303 */
 737         /* this is needed due to the looney way its endpoints are set up */
 738         if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
 739              (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
 740             ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
 741              (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
 742             ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
 743              (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
 744             ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
 745              (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
 746                 if (interface != dev->actconfig->interface[0]) {
 747                         /* check out the endpoints of the other interface*/
 748                         iface_desc = dev->actconfig->interface[0]->cur_altsetting;
 749                         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 750                                 endpoint = &iface_desc->endpoint[i].desc;
 751                                 if (usb_endpoint_is_int_in(endpoint)) {
 752                                         /* we found a interrupt in endpoint */
 753                                         dbg("found interrupt in for Prolific device on separate interface");
 754                                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
 755                                         ++num_interrupt_in;
 756                                 }
 757                         }
 758                 }
 759
 760                 /* Now make sure the PL-2303 is configured correctly.
 761                  * If not, give up now and hope this hack will work
 762                  * properly during a later invocation of usb_serial_probe
 763                  */
 764                 if (num_bulk_in == 0 || num_bulk_out == 0) {
 765                         unlock_kernel();
 766                         dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
 767                         kfree(serial);
 768                         return -ENODEV;
 769                 }
 770         }
 771         /* END HORRIBLE HACK FOR PL2303 */
 772 #endif
 773
 774 #ifdef CONFIG_USB_SERIAL_GENERIC
 775         if (type == &usb_serial_generic_device) {
 776                 num_ports = num_bulk_out;
 777                 if (num_ports == 0) {
 778                         unlock_kernel();
 779                         dev_err(&interface->dev,
 780                             "Generic device with no bulk out, not allowed.\n");
 781                         kfree(serial);
 782                         return -EIO;
 783                 }
 784         }
 785 #endif
 786         if (!num_ports) {
 787                 /* if this device type has a calc_num_ports function, call it */
 788                 if (type->calc_num_ports) {
 789                         if (!try_module_get(type->driver.owner)) {
 790                                 unlock_kernel();
 791                                 dev_err(&interface->dev,
 792                                         "module get failed, exiting\n");
 793                                 kfree(serial);
 794                                 return -EIO;
 795                         }
 796                         num_ports = type->calc_num_ports(serial);
 797                         module_put(type->driver.owner);
 798                 }
 799                 if (!num_ports)
 800                         num_ports = type->num_ports;
 801         }
 802
 803         serial->num_ports = num_ports;
 804         serial->num_bulk_in = num_bulk_in;
 805         serial->num_bulk_out = num_bulk_out;
 806         serial->num_interrupt_in = num_interrupt_in;
 807         serial->num_interrupt_out = num_interrupt_out;
 808
 809         /* found all that we need */
 810         dev_info(&interface->dev, "%s converter detected\n",
 811                         type->description);
 812
 813         /* create our ports, we need as many as the max endpoints */
 814         /* we don't use num_ports here because some devices have more
 815            endpoint pairs than ports */
 816         max_endpoints = max(num_bulk_in, num_bulk_out);
 817         max_endpoints = max(max_endpoints, num_interrupt_in);
 818         max_endpoints = max(max_endpoints, num_interrupt_out);
 819         max_endpoints = max(max_endpoints, (int)serial->num_ports);
 820         serial->num_port_pointers = max_endpoints;
 821         unlock_kernel();
 822
 823         dbg("%s - setting up %d port structures for this device",
 824                                                 __func__, max_endpoints);
 825         for (i = 0; i < max_endpoints; ++i) {
 826                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 827                 if (!port)
 828                         goto probe_error;
 829                 tty_port_init(&port->port);
 830                 port->serial = serial;
 831                 spin_lock_init(&port->lock);
 832                 mutex_init(&port->mutex);
 833                 INIT_WORK(&port->work, usb_serial_port_work);
 834                 serial->port[i] = port;
 835         }
 836
 837         /* set up the endpoint information */
 838         for (i = 0; i < num_bulk_in; ++i) {
 839                 endpoint = bulk_in_endpoint[i];
 840                 port = serial->port[i];
 841                 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
 842                 if (!port->read_urb) {
 843                         dev_err(&interface->dev, "No free urbs available\n");
 844                         goto probe_error;
 845                 }
 846                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 847                 port->bulk_in_size = buffer_size;
 848                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 849                 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
 850                 if (!port->bulk_in_buffer) {
 851                         dev_err(&interface->dev,
 852                                         "Couldn't allocate bulk_in_buffer\n");
 853                         goto probe_error;
 854                 }
 855                 usb_fill_bulk_urb(port->read_urb, dev,
 856                                 usb_rcvbulkpipe(dev,
 857                                                 endpoint->bEndpointAddress),
 858                                 port->bulk_in_buffer, buffer_size,
 859                                 serial->type->read_bulk_callback, port);
 860         }
 861
 862         for (i = 0; i < num_bulk_out; ++i) {
 863                 endpoint = bulk_out_endpoint[i];
 864                 port = serial->port[i];
 865                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
 866                 if (!port->write_urb) {
 867                         dev_err(&interface->dev, "No free urbs available\n");
 868                         goto probe_error;
 869                 }
 870                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 871                 port->bulk_out_size = buffer_size;
 872                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 873                 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
 874                 if (!port->bulk_out_buffer) {
 875                         dev_err(&interface->dev,
 876                                         "Couldn't allocate bulk_out_buffer\n");
 877                         goto probe_error;
 878                 }
 879                 usb_fill_bulk_urb(port->write_urb, dev,
 880                                 usb_sndbulkpipe(dev,
 881                                         endpoint->bEndpointAddress),
 882                                 port->bulk_out_buffer, buffer_size,
 883                                 serial->type->write_bulk_callback, port);
 884         }
 885
 886         if (serial->type->read_int_callback) {
 887                 for (i = 0; i < num_interrupt_in; ++i) {
 888                         endpoint = interrupt_in_endpoint[i];
 889                         port = serial->port[i];
 890                         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 891                         if (!port->interrupt_in_urb) {
 892                                 dev_err(&interface->dev,
 893                                                 "No free urbs available\n");
 894                                 goto probe_error;
 895                         }
 896                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 897                         port->interrupt_in_endpointAddress =
 898                                                 endpoint->bEndpointAddress;
 899                         port->interrupt_in_buffer = kmalloc(buffer_size,
 900                                                                 GFP_KERNEL);
 901                         if (!port->interrupt_in_buffer) {
 902                                 dev_err(&interface->dev,
 903                                     "Couldn't allocate interrupt_in_buffer\n");
 904                                 goto probe_error;
 905                         }
 906                         usb_fill_int_urb(port->interrupt_in_urb, dev,
 907                                 usb_rcvintpipe(dev,
 908                                                 endpoint->bEndpointAddress),
 909                                 port->interrupt_in_buffer, buffer_size,
 910                                 serial->type->read_int_callback, port,
 911                                 endpoint->bInterval);
 912                 }
 913         } else if (num_interrupt_in) {
 914                 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
 915         }
 916
 917         if (serial->type->write_int_callback) {
 918                 for (i = 0; i < num_interrupt_out; ++i) {
 919                         endpoint = interrupt_out_endpoint[i];
 920                         port = serial->port[i];
 921                         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
 922                         if (!port->interrupt_out_urb) {
 923                                 dev_err(&interface->dev,
 924                                                 "No free urbs available\n");
 925                                 goto probe_error;
 926                         }
 927                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
 928                         port->interrupt_out_size = buffer_size;
 929                         port->interrupt_out_endpointAddress =
 930                                                 endpoint->bEndpointAddress;
 931                         port->interrupt_out_buffer = kmalloc(buffer_size,
 932                                                                 GFP_KERNEL);
 933                         if (!port->interrupt_out_buffer) {
 934                                 dev_err(&interface->dev,
 935                                   "Couldn't allocate interrupt_out_buffer\n");
 936                                 goto probe_error;
 937                         }
 938                         usb_fill_int_urb(port->interrupt_out_urb, dev,
 939                                 usb_sndintpipe(dev,
 940                                                   endpoint->bEndpointAddress),
 941                                 port->interrupt_out_buffer, buffer_size,
 942                                 serial->type->write_int_callback, port,
 943                                 endpoint->bInterval);
 944                 }
 945         } else if (num_interrupt_out) {
 946                 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
 947         }
 948
 949         /* if this device type has an attach function, call it */
 950         if (type->attach) {
 951                 if (!try_module_get(type->driver.owner)) {
 952                         dev_err(&interface->dev,
 953                                         "module get failed, exiting\n");
 954                         goto probe_error;
 955                 }
 956                 retval = type->attach(serial);
 957                 module_put(type->driver.owner);
 958                 if (retval < 0)
 959                         goto probe_error;
 960                 if (retval > 0) {
 961                         /* quietly accept this device, but don't bind to a
 962                            serial port as it's about to disappear */
 963                         goto exit;
 964                 }
 965         }
 966
 967         if (get_free_serial(serial, num_ports, &minor) == NULL) {
 968                 dev_err(&interface->dev, "No more free serial devices\n");
 969                 goto probe_error;
 970         }
 971         serial->minor = minor;
 972
 973         /* register all of the individual ports with the driver core */
 974         for (i = 0; i < num_ports; ++i) {
 975                 port = serial->port[i];
 976                 port->dev.parent = &interface->dev;
 977                 port->dev.driver = NULL;
 978                 port->dev.bus = &usb_serial_bus_type;
 979                 port->dev.release = &port_release;
 980
 981                 dev_set_name(&port->dev, "ttyUSB%d", port->number);
 982                 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
 983                 retval = device_register(&port->dev);
 984                 if (retval)
 985                         dev_err(&port->dev, "Error registering port device, "
 986                                 "continuing\n");
 987         }
 988
 989         usb_serial_console_init(debug, minor);
 990
 991 exit:
 992         /* success */
 993         usb_set_intfdata(interface, serial);
 994         return 0;
 995
 996 probe_error:
 997         for (i = 0; i < num_bulk_in; ++i) {
 998                 port = serial->port[i];
 999                 if (!port)
1000                         continue;
1001                 usb_free_urb(port->read_urb);
1002                 kfree(port->bulk_in_buffer);
1003         }
1004         for (i = 0; i < num_bulk_out; ++i) {
1005                 port = serial->port[i];
1006                 if (!port)
1007                         continue;
1008                 usb_free_urb(port->write_urb);
1009                 kfree(port->bulk_out_buffer);
1010         }
1011         for (i = 0; i < num_interrupt_in; ++i) {
1012                 port = serial->port[i];
1013                 if (!port)
1014                         continue;
1015                 usb_free_urb(port->interrupt_in_urb);
1016                 kfree(port->interrupt_in_buffer);
1017         }
1018         for (i = 0; i < num_interrupt_out; ++i) {
1019                 port = serial->port[i];
1020                 if (!port)
1021                         continue;
1022                 usb_free_urb(port->interrupt_out_urb);
1023                 kfree(port->interrupt_out_buffer);
1024         }
1025
1026         /* free up any memory that we allocated */
1027         for (i = 0; i < serial->num_port_pointers; ++i)
1028                 kfree(serial->port[i]);
1029         kfree(serial);
1030         return -EIO;
1031 }
1032 EXPORT_SYMBOL_GPL(usb_serial_probe);
1033
1034 void usb_serial_disconnect(struct usb_interface *interface)
1035 {
1036         int i;
1037         struct usb_serial *serial = usb_get_intfdata(interface);
1038         struct device *dev = &interface->dev;
1039         struct usb_serial_port *port;
1040
1041         usb_serial_console_disconnect(serial);
1042         dbg("%s", __func__);
1043
1044         mutex_lock(&serial->disc_mutex);
1045         usb_set_intfdata(interface, NULL);
1046         /* must set a flag, to signal subdrivers */
1047         serial->disconnected = 1;
1048         for (i = 0; i < serial->num_ports; ++i) {
1049                 port = serial->port[i];
1050                 if (port) {
1051                         struct tty_struct *tty = tty_port_tty_get(&port->port);
1052                         if (tty) {
1053                                 tty_hangup(tty);
1054                                 tty_kref_put(tty);
1055                         }
1056                         kill_traffic(port);
1057                 }
1058         }
1059         /* let the last holder of this object
1060          * cause it to be cleaned up */
1061         mutex_unlock(&serial->disc_mutex);
1062         usb_serial_put(serial);
1063         dev_info(dev, "device disconnected\n");
1064 }
1065 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1066
1067 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1068 {
1069         struct usb_serial *serial = usb_get_intfdata(intf);
1070         struct usb_serial_port *port;
1071         int i, r = 0;
1072
1073         for (i = 0; i < serial->num_ports; ++i) {
1074                 port = serial->port[i];
1075                 if (port)
1076                         kill_traffic(port);
1077         }
1078
1079         if (serial->type->suspend)
1080                 r = serial->type->suspend(serial, message);
1081
1082         return r;
1083 }
1084 EXPORT_SYMBOL(usb_serial_suspend);
1085
1086 int usb_serial_resume(struct usb_interface *intf)
1087 {
1088         struct usb_serial *serial = usb_get_intfdata(intf);
1089
1090         if (serial->type->resume)
1091                 return serial->type->resume(serial);
1092         return 0;
1093 }
1094 EXPORT_SYMBOL(usb_serial_resume);
1095
1096 static const struct tty_operations serial_ops = {
1097         .open =                 serial_open,
1098         .close =                serial_close,
1099         .write =                serial_write,
1100         .write_room =           serial_write_room,
1101         .ioctl =                serial_ioctl,
1102         .set_termios =          serial_set_termios,
1103         .throttle =             serial_throttle,
1104         .unthrottle =           serial_unthrottle,
1105         .break_ctl =            serial_break,
1106         .chars_in_buffer =      serial_chars_in_buffer,
1107         .read_proc =            serial_read_proc,
1108         .tiocmget =             serial_tiocmget,
1109         .tiocmset =             serial_tiocmset,
1110 };
1111
1112 struct tty_driver *usb_serial_tty_driver;
1113
1114 static int __init usb_serial_init(void)
1115 {
1116         int i;
1117         int result;
1118
1119         usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1120         if (!usb_serial_tty_driver)
1121                 return -ENOMEM;
1122
1123         /* Initialize our global data */
1124         for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1125                 serial_table[i] = NULL;
1126
1127         result = bus_register(&usb_serial_bus_type);
1128         if (result) {
1129                 printk(KERN_ERR "usb-serial: %s - registering bus driver "
1130                        "failed\n", __func__);
1131                 goto exit_bus;
1132         }
1133
1134         usb_serial_tty_driver->owner = THIS_MODULE;
1135         usb_serial_tty_driver->driver_name = "usbserial";
1136         usb_serial_tty_driver->name =   "ttyUSB";
1137         usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1138         usb_serial_tty_driver->minor_start = 0;
1139         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1140         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1141         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1142                                                 TTY_DRIVER_DYNAMIC_DEV;
1143         usb_serial_tty_driver->init_termios = tty_std_termios;
1144         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1145                                                         | HUPCL | CLOCAL;
1146         usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1147         usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1148         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1149         result = tty_register_driver(usb_serial_tty_driver);
1150         if (result) {
1151                 printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
1152                        __func__);
1153                 goto exit_reg_driver;
1154         }
1155
1156         /* register the USB driver */
1157         result = usb_register(&usb_serial_driver);
1158         if (result < 0) {
1159                 printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
1160                        __func__);
1161                 goto exit_tty;
1162         }
1163
1164         /* register the generic driver, if we should */
1165         result = usb_serial_generic_register(debug);
1166         if (result < 0) {
1167                 printk(KERN_ERR "usb-serial: %s - registering generic "
1168                        "driver failed\n", __func__);
1169                 goto exit_generic;
1170         }
1171
1172         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");
1173
1174         return result;
1175
1176 exit_generic:
1177         usb_deregister(&usb_serial_driver);
1178
1179 exit_tty:
1180         tty_unregister_driver(usb_serial_tty_driver);
1181
1182 exit_reg_driver:
1183         bus_unregister(&usb_serial_bus_type);
1184
1185 exit_bus:
1186         printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
1187                __func__, result);
1188         put_tty_driver(usb_serial_tty_driver);
1189         return result;
1190 }
1191
1192
1193 static void __exit usb_serial_exit(void)
1194 {
1195         usb_serial_console_exit();
1196
1197         usb_serial_generic_deregister();
1198
1199         usb_deregister(&usb_serial_driver);
1200         tty_unregister_driver(usb_serial_tty_driver);
1201         put_tty_driver(usb_serial_tty_driver);
1202         bus_unregister(&usb_serial_bus_type);
1203 }
1204
1205
1206 module_init(usb_serial_init);
1207 module_exit(usb_serial_exit);
1208
1209 #define set_to_generic_if_null(type, function)                          \
1210         do {                                                            \
1211                 if (!type->function) {                                  \
1212                         type->function = usb_serial_generic_##function; \
1213                         dbg("Had to override the " #function            \
1214                                 " usb serial operation with the generic one.");\
1215                         }                                               \
1216         } while (0)
1217
1218 static void fixup_generic(struct usb_serial_driver *device)
1219 {
1220         set_to_generic_if_null(device, open);
1221         set_to_generic_if_null(device, write);
1222         set_to_generic_if_null(device, close);
1223         set_to_generic_if_null(device, write_room);
1224         set_to_generic_if_null(device, chars_in_buffer);
1225         set_to_generic_if_null(device, read_bulk_callback);
1226         set_to_generic_if_null(device, write_bulk_callback);
1227         set_to_generic_if_null(device, shutdown);
1228         set_to_generic_if_null(device, resume);
1229 }
1230
1231 int usb_serial_register(struct usb_serial_driver *driver)
1232 {
1233         /* must be called with BKL held */
1234         int retval;
1235
1236         fixup_generic(driver);
1237
1238         if (!driver->description)
1239                 driver->description = driver->driver.name;
1240
1241         /* Add this device to our list of devices */
1242         list_add(&driver->driver_list, &usb_serial_driver_list);
1243
1244         retval = usb_serial_bus_register(driver);
1245         if (retval) {
1246                 printk(KERN_ERR "usb-serial: problem %d when registering "
1247                        "driver %s\n", retval, driver->description);
1248                 list_del(&driver->driver_list);
1249         } else
1250                 printk(KERN_INFO "USB Serial support registered for %s\n",
1251                                                 driver->description);
1252
1253         return retval;
1254 }
1255 EXPORT_SYMBOL_GPL(usb_serial_register);
1256
1257
1258 void usb_serial_deregister(struct usb_serial_driver *device)
1259 {
1260         /* must be called with BKL held */
1261         printk(KERN_INFO "USB Serial deregistering driver %s\n",
1262                device->description);
1263         list_del(&device->driver_list);
1264         usb_serial_bus_deregister(device);
1265 }
1266 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1267
1268 /* Module information */
1269 MODULE_AUTHOR(DRIVER_AUTHOR);
1270 MODULE_DESCRIPTION(DRIVER_DESC);
1271 MODULE_LICENSE("GPL");
1272
1273 module_param(debug, bool, S_IRUGO | S_IWUSR);
1274 MODULE_PARM_DESC(debug, "Debug enabled or not");