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