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