drivers/usb/serial/usb-serial.c

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