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