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