git.oblomov.eu Git - linux-2.6/blob - drivers/usb/serial/usb-serial.c

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