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