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