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