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