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