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