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