drivers/usb/serial/usb-serial.c

   1 /*
   2  * USB Serial Converter driver
   3  *
   4  * Copyright (C) 2009 - 2013 Johan Hovold (jhovold@gmail.com)
   5  * Copyright (C) 1999 - 2012 Greg Kroah-Hartman (greg@kroah.com)
   6  * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
   7  * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
   8  *
   9  *      This program is free software; you can redistribute it and/or
  10  *      modify it under the terms of the GNU General Public License version
  11  *      2 as published by the Free Software Foundation.
  12  *
  13  * This driver was originally based on the ACM driver by Armin Fuerst (which was
  14  * based on a driver by Brad Keryan)
  15  *
  16  * See Documentation/usb/usb-serial.txt for more information on using this
  17  * driver
  18  */
  19
  20 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  21
  22 #include <linux/kernel.h>
  23 #include <linux/errno.h>
  24 #include <linux/init.h>
  25 #include <linux/slab.h>
  26 #include <linux/tty.h>
  27 #include <linux/tty_driver.h>
  28 #include <linux/tty_flip.h>
  29 #include <linux/module.h>
  30 #include <linux/moduleparam.h>
  31 #include <linux/seq_file.h>
  32 #include <linux/spinlock.h>
  33 #include <linux/mutex.h>
  34 #include <linux/list.h>
  35 #include <linux/uaccess.h>
  36 #include <linux/serial.h>
  37 #include <linux/usb.h>
  38 #include <linux/usb/serial.h>
  39 #include <linux/kfifo.h>
  40 #include <linux/idr.h>
  41 #include "pl2303.h"
  42
  43 #define DRIVER_AUTHOR "Greg Kroah-Hartman <gregkh@linuxfoundation.org>"
  44 #define DRIVER_DESC "USB Serial Driver core"
  45
  46 #define USB_SERIAL_TTY_MAJOR    188
  47 #define USB_SERIAL_TTY_MINORS   512     /* should be enough for a while */
  48
  49 /* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
  50    the MODULE_DEVICE_TABLE declarations in each serial driver
  51    cause the "hotplug" program to pull in whatever module is necessary
  52    via modprobe, and modprobe will load usbserial because the serial
  53    drivers depend on it.
  54 */
  55
  56 static DEFINE_IDR(serial_minors);
  57 static DEFINE_MUTEX(table_lock);
  58 static LIST_HEAD(usb_serial_driver_list);
  59
  60 /*
  61  * Look up the serial port structure.  If it is found and it hasn't been
  62  * disconnected, return with the parent usb_serial structure's disc_mutex held
  63  * and its refcount incremented.  Otherwise return NULL.
  64  */
  65 struct usb_serial_port *usb_serial_port_get_by_minor(unsigned minor)
  66 {
  67         struct usb_serial *serial;
  68         struct usb_serial_port *port;
  69
  70         mutex_lock(&table_lock);
  71         port = idr_find(&serial_minors, minor);
  72         if (!port)
  73                 goto exit;
  74
  75         serial = port->serial;
  76         mutex_lock(&serial->disc_mutex);
  77         if (serial->disconnected) {
  78                 mutex_unlock(&serial->disc_mutex);
  79                 port = NULL;
  80         } else {
  81                 kref_get(&serial->kref);
  82         }
  83 exit:
  84         mutex_unlock(&table_lock);
  85         return port;
  86 }
  87
  88 static int allocate_minors(struct usb_serial *serial, int num_ports)
  89 {
  90         struct usb_serial_port *port;
  91         unsigned int i, j;
  92         int minor;
  93
  94         dev_dbg(&serial->interface->dev, "%s %d\n", __func__, num_ports);
  95
  96         mutex_lock(&table_lock);
  97         for (i = 0; i < num_ports; ++i) {
  98                 port = serial->port[i];
  99                 minor = idr_alloc(&serial_minors, port, 0,
 100                                         USB_SERIAL_TTY_MINORS, GFP_KERNEL);
 101                 if (minor < 0)
 102                         goto error;
 103                 port->minor = minor;
 104                 port->port_number = i;
 105         }
 106         serial->minors_reserved = 1;
 107         mutex_unlock(&table_lock);
 108         return 0;
 109 error:
 110         /* unwind the already allocated minors */
 111         for (j = 0; j < i; ++j)
 112                 idr_remove(&serial_minors, serial->port[j]->minor);
 113         mutex_unlock(&table_lock);
 114         return minor;
 115 }
 116
 117 static void release_minors(struct usb_serial *serial)
 118 {
 119         int i;
 120
 121         mutex_lock(&table_lock);
 122         for (i = 0; i < serial->num_ports; ++i)
 123                 idr_remove(&serial_minors, serial->port[i]->minor);
 124         mutex_unlock(&table_lock);
 125         serial->minors_reserved = 0;
 126 }
 127
 128 static void destroy_serial(struct kref *kref)
 129 {
 130         struct usb_serial *serial;
 131         struct usb_serial_port *port;
 132         int i;
 133
 134         serial = to_usb_serial(kref);
 135
 136         /* return the minor range that this device had */
 137         if (serial->minors_reserved)
 138                 release_minors(serial);
 139
 140         if (serial->attached && serial->type->release)
 141                 serial->type->release(serial);
 142
 143         /* Now that nothing is using the ports, they can be freed */
 144         for (i = 0; i < serial->num_port_pointers; ++i) {
 145                 port = serial->port[i];
 146                 if (port) {
 147                         port->serial = NULL;
 148                         put_device(&port->dev);
 149                 }
 150         }
 151
 152         usb_put_intf(serial->interface);
 153         usb_put_dev(serial->dev);
 154         kfree(serial);
 155 }
 156
 157 void usb_serial_put(struct usb_serial *serial)
 158 {
 159         kref_put(&serial->kref, destroy_serial);
 160 }
 161
 162 /*****************************************************************************
 163  * Driver tty interface functions
 164  *****************************************************************************/
 165
 166 /**
 167  * serial_install - install tty
 168  * @driver: the driver (USB in our case)
 169  * @tty: the tty being created
 170  *
 171  * Create the termios objects for this tty.  We use the default
 172  * USB serial settings but permit them to be overridden by
 173  * serial->type->init_termios.
 174  *
 175  * This is the first place a new tty gets used.  Hence this is where we
 176  * acquire references to the usb_serial structure and the driver module,
 177  * where we store a pointer to the port, and where we do an autoresume.
 178  * All these actions are reversed in serial_cleanup().
 179  */
 180 static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
 181 {
 182         int idx = tty->index;
 183         struct usb_serial *serial;
 184         struct usb_serial_port *port;
 185         int retval = -ENODEV;
 186
 187         port = usb_serial_port_get_by_minor(idx);
 188         if (!port)
 189                 return retval;
 190
 191         serial = port->serial;
 192         if (!try_module_get(serial->type->driver.owner))
 193                 goto error_module_get;
 194
 195         retval = usb_autopm_get_interface(serial->interface);
 196         if (retval)
 197                 goto error_get_interface;
 198
 199         retval = tty_port_install(&port->port, driver, tty);
 200         if (retval)
 201                 goto error_init_termios;
 202
 203         mutex_unlock(&serial->disc_mutex);
 204
 205         /* allow the driver to update the settings */
 206         if (serial->type->init_termios)
 207                 serial->type->init_termios(tty);
 208
 209         tty->driver_data = port;
 210
 211         return retval;
 212
 213  error_init_termios:
 214         usb_autopm_put_interface(serial->interface);
 215  error_get_interface:
 216         module_put(serial->type->driver.owner);
 217  error_module_get:
 218         usb_serial_put(serial);
 219         mutex_unlock(&serial->disc_mutex);
 220         return retval;
 221 }
 222
 223 static int serial_port_activate(struct tty_port *tport, struct tty_struct *tty)
 224 {
 225         struct usb_serial_port *port =
 226                 container_of(tport, struct usb_serial_port, port);
 227         struct usb_serial *serial = port->serial;
 228         int retval;
 229
 230         mutex_lock(&serial->disc_mutex);
 231         if (serial->disconnected)
 232                 retval = -ENODEV;
 233         else
 234                 retval = port->serial->type->open(tty, port);
 235         mutex_unlock(&serial->disc_mutex);
 236
 237         if (retval < 0)
 238                 retval = usb_translate_errors(retval);
 239
 240         return retval;
 241 }
 242
 243 static int serial_open(struct tty_struct *tty, struct file *filp)
 244 {
 245         struct usb_serial_port *port = tty->driver_data;
 246
 247         dev_dbg(tty->dev, "%s\n", __func__);
 248
 249         return tty_port_open(&port->port, tty, filp);
 250 }
 251
 252 /**
 253  * serial_port_shutdown - shut down hardware
 254  * @tport: tty port to shut down
 255  *
 256  * Shut down a USB serial port. Serialized against activate by the
 257  * tport mutex and kept to matching open/close pairs
 258  * of calls by the initialized flag.
 259  *
 260  * Not called if tty is console.
 261  */
 262 static void serial_port_shutdown(struct tty_port *tport)
 263 {
 264         struct usb_serial_port *port =
 265                 container_of(tport, struct usb_serial_port, port);
 266         struct usb_serial_driver *drv = port->serial->type;
 267
 268         if (drv->close)
 269                 drv->close(port);
 270 }
 271
 272 static void serial_hangup(struct tty_struct *tty)
 273 {
 274         struct usb_serial_port *port = tty->driver_data;
 275
 276         dev_dbg(tty->dev, "%s\n", __func__);
 277
 278         tty_port_hangup(&port->port);
 279 }
 280
 281 static void serial_close(struct tty_struct *tty, struct file *filp)
 282 {
 283         struct usb_serial_port *port = tty->driver_data;
 284
 285         dev_dbg(tty->dev, "%s\n", __func__);
 286
 287         tty_port_close(&port->port, tty, filp);
 288 }
 289
 290 /**
 291  * serial_cleanup - free resources post close/hangup
 292  * @port: port to free up
 293  *
 294  * Do the resource freeing and refcount dropping for the port.
 295  * Avoid freeing the console.
 296  *
 297  * Called asynchronously after the last tty kref is dropped.
 298  */
 299 static void serial_cleanup(struct tty_struct *tty)
 300 {
 301         struct usb_serial_port *port = tty->driver_data;
 302         struct usb_serial *serial;
 303         struct module *owner;
 304
 305         dev_dbg(tty->dev, "%s\n", __func__);
 306
 307         /* The console is magical.  Do not hang up the console hardware
 308          * or there will be tears.
 309          */
 310         if (port->port.console)
 311                 return;
 312
 313         tty->driver_data = NULL;
 314
 315         serial = port->serial;
 316         owner = serial->type->driver.owner;
 317
 318         usb_autopm_put_interface(serial->interface);
 319
 320         usb_serial_put(serial);
 321         module_put(owner);
 322 }
 323
 324 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
 325                                                                 int count)
 326 {
 327         struct usb_serial_port *port = tty->driver_data;
 328         int retval = -ENODEV;
 329
 330         if (port->serial->dev->state == USB_STATE_NOTATTACHED)
 331                 goto exit;
 332
 333         dev_dbg(tty->dev, "%s - %d byte(s)\n", __func__, count);
 334
 335         retval = port->serial->type->write(tty, port, buf, count);
 336         if (retval < 0)
 337                 retval = usb_translate_errors(retval);
 338 exit:
 339         return retval;
 340 }
 341
 342 static int serial_write_room(struct tty_struct *tty)
 343 {
 344         struct usb_serial_port *port = tty->driver_data;
 345
 346         dev_dbg(tty->dev, "%s\n", __func__);
 347
 348         return port->serial->type->write_room(tty);
 349 }
 350
 351 static int serial_chars_in_buffer(struct tty_struct *tty)
 352 {
 353         struct usb_serial_port *port = tty->driver_data;
 354         struct usb_serial *serial = port->serial;
 355
 356         dev_dbg(tty->dev, "%s\n", __func__);
 357
 358         if (serial->disconnected)
 359                 return 0;
 360
 361         return serial->type->chars_in_buffer(tty);
 362 }
 363
 364 static void serial_wait_until_sent(struct tty_struct *tty, int timeout)
 365 {
 366         struct usb_serial_port *port = tty->driver_data;
 367         struct usb_serial *serial = port->serial;
 368
 369         dev_dbg(tty->dev, "%s\n", __func__);
 370
 371         if (!port->serial->type->wait_until_sent)
 372                 return;
 373
 374         mutex_lock(&serial->disc_mutex);
 375         if (!serial->disconnected)
 376                 port->serial->type->wait_until_sent(tty, timeout);
 377         mutex_unlock(&serial->disc_mutex);
 378 }
 379
 380 static void serial_throttle(struct tty_struct *tty)
 381 {
 382         struct usb_serial_port *port = tty->driver_data;
 383
 384         dev_dbg(tty->dev, "%s\n", __func__);
 385
 386         if (port->serial->type->throttle)
 387                 port->serial->type->throttle(tty);
 388 }
 389
 390 static void serial_unthrottle(struct tty_struct *tty)
 391 {
 392         struct usb_serial_port *port = tty->driver_data;
 393
 394         dev_dbg(tty->dev, "%s\n", __func__);
 395
 396         if (port->serial->type->unthrottle)
 397                 port->serial->type->unthrottle(tty);
 398 }
 399
 400 static int serial_ioctl(struct tty_struct *tty,
 401                                         unsigned int cmd, unsigned long arg)
 402 {
 403         struct usb_serial_port *port = tty->driver_data;
 404         int retval = -ENOIOCTLCMD;
 405
 406         dev_dbg(tty->dev, "%s - cmd 0x%04x\n", __func__, cmd);
 407
 408         switch (cmd) {
 409         case TIOCMIWAIT:
 410                 if (port->serial->type->tiocmiwait)
 411                         retval = port->serial->type->tiocmiwait(tty, arg);
 412                 break;
 413         default:
 414                 if (port->serial->type->ioctl)
 415                         retval = port->serial->type->ioctl(tty, cmd, arg);
 416         }
 417
 418         return retval;
 419 }
 420
 421 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
 422 {
 423         struct usb_serial_port *port = tty->driver_data;
 424
 425         dev_dbg(tty->dev, "%s\n", __func__);
 426
 427         if (port->serial->type->set_termios)
 428                 port->serial->type->set_termios(tty, port, old);
 429         else
 430                 tty_termios_copy_hw(&tty->termios, old);
 431 }
 432
 433 static int serial_break(struct tty_struct *tty, int break_state)
 434 {
 435         struct usb_serial_port *port = tty->driver_data;
 436
 437         dev_dbg(tty->dev, "%s\n", __func__);
 438
 439         if (port->serial->type->break_ctl)
 440                 port->serial->type->break_ctl(tty, break_state);
 441
 442         return 0;
 443 }
 444
 445 static int serial_proc_show(struct seq_file *m, void *v)
 446 {
 447         struct usb_serial *serial;
 448         struct usb_serial_port *port;
 449         int i;
 450         char tmp[40];
 451
 452         seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
 453         for (i = 0; i < USB_SERIAL_TTY_MINORS; ++i) {
 454                 port = usb_serial_port_get_by_minor(i);
 455                 if (port == NULL)
 456                         continue;
 457                 serial = port->serial;
 458
 459                 seq_printf(m, "%d:", i);
 460                 if (serial->type->driver.owner)
 461                         seq_printf(m, " module:%s",
 462                                 module_name(serial->type->driver.owner));
 463                 seq_printf(m, " name:\"%s\"",
 464                                 serial->type->description);
 465                 seq_printf(m, " vendor:%04x product:%04x",
 466                         le16_to_cpu(serial->dev->descriptor.idVendor),
 467                         le16_to_cpu(serial->dev->descriptor.idProduct));
 468                 seq_printf(m, " num_ports:%d", serial->num_ports);
 469                 seq_printf(m, " port:%d", port->port_number);
 470                 usb_make_path(serial->dev, tmp, sizeof(tmp));
 471                 seq_printf(m, " path:%s", tmp);
 472
 473                 seq_putc(m, '\n');
 474                 usb_serial_put(serial);
 475                 mutex_unlock(&serial->disc_mutex);
 476         }
 477         return 0;
 478 }
 479
 480 static int serial_proc_open(struct inode *inode, struct file *file)
 481 {
 482         return single_open(file, serial_proc_show, NULL);
 483 }
 484
 485 static const struct file_operations serial_proc_fops = {
 486         .owner          = THIS_MODULE,
 487         .open           = serial_proc_open,
 488         .read           = seq_read,
 489         .llseek         = seq_lseek,
 490         .release        = single_release,
 491 };
 492
 493 static int serial_tiocmget(struct tty_struct *tty)
 494 {
 495         struct usb_serial_port *port = tty->driver_data;
 496
 497         dev_dbg(tty->dev, "%s\n", __func__);
 498
 499         if (port->serial->type->tiocmget)
 500                 return port->serial->type->tiocmget(tty);
 501         return -EINVAL;
 502 }
 503
 504 static int serial_tiocmset(struct tty_struct *tty,
 505                             unsigned int set, unsigned int clear)
 506 {
 507         struct usb_serial_port *port = tty->driver_data;
 508
 509         dev_dbg(tty->dev, "%s\n", __func__);
 510
 511         if (port->serial->type->tiocmset)
 512                 return port->serial->type->tiocmset(tty, set, clear);
 513         return -EINVAL;
 514 }
 515
 516 static int serial_get_icount(struct tty_struct *tty,
 517                                 struct serial_icounter_struct *icount)
 518 {
 519         struct usb_serial_port *port = tty->driver_data;
 520
 521         dev_dbg(tty->dev, "%s\n", __func__);
 522
 523         if (port->serial->type->get_icount)
 524                 return port->serial->type->get_icount(tty, icount);
 525         return -EINVAL;
 526 }
 527
 528 /*
 529  * We would be calling tty_wakeup here, but unfortunately some line
 530  * disciplines have an annoying habit of calling tty->write from
 531  * the write wakeup callback (e.g. n_hdlc.c).
 532  */
 533 void usb_serial_port_softint(struct usb_serial_port *port)
 534 {
 535         schedule_work(&port->work);
 536 }
 537 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
 538
 539 static void usb_serial_port_work(struct work_struct *work)
 540 {
 541         struct usb_serial_port *port =
 542                 container_of(work, struct usb_serial_port, work);
 543
 544         tty_port_tty_wakeup(&port->port);
 545 }
 546
 547 static void usb_serial_port_poison_urbs(struct usb_serial_port *port)
 548 {
 549         int i;
 550
 551         for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
 552                 usb_poison_urb(port->read_urbs[i]);
 553         for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
 554                 usb_poison_urb(port->write_urbs[i]);
 555
 556         usb_poison_urb(port->interrupt_in_urb);
 557         usb_poison_urb(port->interrupt_out_urb);
 558 }
 559
 560 static void usb_serial_port_unpoison_urbs(struct usb_serial_port *port)
 561 {
 562         int i;
 563
 564         for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
 565                 usb_unpoison_urb(port->read_urbs[i]);
 566         for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
 567                 usb_unpoison_urb(port->write_urbs[i]);
 568
 569         usb_unpoison_urb(port->interrupt_in_urb);
 570         usb_unpoison_urb(port->interrupt_out_urb);
 571 }
 572
 573 static void usb_serial_port_release(struct device *dev)
 574 {
 575         struct usb_serial_port *port = to_usb_serial_port(dev);
 576         int i;
 577
 578         dev_dbg(dev, "%s\n", __func__);
 579
 580         usb_free_urb(port->interrupt_in_urb);
 581         usb_free_urb(port->interrupt_out_urb);
 582         for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
 583                 usb_free_urb(port->read_urbs[i]);
 584                 kfree(port->bulk_in_buffers[i]);
 585         }
 586         for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
 587                 usb_free_urb(port->write_urbs[i]);
 588                 kfree(port->bulk_out_buffers[i]);
 589         }
 590         kfifo_free(&port->write_fifo);
 591         kfree(port->interrupt_in_buffer);
 592         kfree(port->interrupt_out_buffer);
 593         tty_port_destroy(&port->port);
 594         kfree(port);
 595 }
 596
 597 static struct usb_serial *create_serial(struct usb_device *dev,
 598                                         struct usb_interface *interface,
 599                                         struct usb_serial_driver *driver)
 600 {
 601         struct usb_serial *serial;
 602
 603         serial = kzalloc(sizeof(*serial), GFP_KERNEL);
 604         if (!serial)
 605                 return NULL;
 606         serial->dev = usb_get_dev(dev);
 607         serial->type = driver;
 608         serial->interface = usb_get_intf(interface);
 609         kref_init(&serial->kref);
 610         mutex_init(&serial->disc_mutex);
 611         serial->minors_reserved = 0;
 612
 613         return serial;
 614 }
 615
 616 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
 617                                             struct usb_serial_driver *drv)
 618 {
 619         struct usb_dynid *dynid;
 620
 621         spin_lock(&drv->dynids.lock);
 622         list_for_each_entry(dynid, &drv->dynids.list, node) {
 623                 if (usb_match_one_id(intf, &dynid->id)) {
 624                         spin_unlock(&drv->dynids.lock);
 625                         return &dynid->id;
 626                 }
 627         }
 628         spin_unlock(&drv->dynids.lock);
 629         return NULL;
 630 }
 631
 632 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
 633                                                 struct usb_interface *intf)
 634 {
 635         const struct usb_device_id *id;
 636
 637         id = usb_match_id(intf, drv->id_table);
 638         if (id) {
 639                 dev_dbg(&intf->dev, "static descriptor matches\n");
 640                 goto exit;
 641         }
 642         id = match_dynamic_id(intf, drv);
 643         if (id)
 644                 dev_dbg(&intf->dev, "dynamic descriptor matches\n");
 645 exit:
 646         return id;
 647 }
 648
 649 /* Caller must hold table_lock */
 650 static struct usb_serial_driver *search_serial_device(
 651                                         struct usb_interface *iface)
 652 {
 653         const struct usb_device_id *id = NULL;
 654         struct usb_serial_driver *drv;
 655         struct usb_driver *driver = to_usb_driver(iface->dev.driver);
 656
 657         /* Check if the usb id matches a known device */
 658         list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
 659                 if (drv->usb_driver == driver)
 660                         id = get_iface_id(drv, iface);
 661                 if (id)
 662                         return drv;
 663         }
 664
 665         return NULL;
 666 }
 667
 668 static int serial_port_carrier_raised(struct tty_port *port)
 669 {
 670         struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
 671         struct usb_serial_driver *drv = p->serial->type;
 672
 673         if (drv->carrier_raised)
 674                 return drv->carrier_raised(p);
 675         /* No carrier control - don't block */
 676         return 1;
 677 }
 678
 679 static void serial_port_dtr_rts(struct tty_port *port, int on)
 680 {
 681         struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
 682         struct usb_serial_driver *drv = p->serial->type;
 683
 684         if (drv->dtr_rts)
 685                 drv->dtr_rts(p, on);
 686 }
 687
 688 static ssize_t port_number_show(struct device *dev,
 689                                 struct device_attribute *attr, char *buf)
 690 {
 691         struct usb_serial_port *port = to_usb_serial_port(dev);
 692
 693         return sprintf(buf, "%u\n", port->port_number);
 694 }
 695 static DEVICE_ATTR_RO(port_number);
 696
 697 static struct attribute *usb_serial_port_attrs[] = {
 698         &dev_attr_port_number.attr,
 699         NULL
 700 };
 701 ATTRIBUTE_GROUPS(usb_serial_port);
 702
 703 static const struct tty_port_operations serial_port_ops = {
 704         .carrier_raised         = serial_port_carrier_raised,
 705         .dtr_rts                = serial_port_dtr_rts,
 706         .activate               = serial_port_activate,
 707         .shutdown               = serial_port_shutdown,
 708 };
 709
 710 static int usb_serial_probe(struct usb_interface *interface,
 711                                const struct usb_device_id *id)
 712 {
 713         struct device *ddev = &interface->dev;
 714         struct usb_device *dev = interface_to_usbdev(interface);
 715         struct usb_serial *serial = NULL;
 716         struct usb_serial_port *port;
 717         struct usb_host_interface *iface_desc;
 718         struct usb_endpoint_descriptor *endpoint;
 719         struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
 720         struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
 721         struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
 722         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
 723         struct usb_serial_driver *type = NULL;
 724         int retval;
 725         int buffer_size;
 726         int i;
 727         int j;
 728         int num_interrupt_in = 0;
 729         int num_interrupt_out = 0;
 730         int num_bulk_in = 0;
 731         int num_bulk_out = 0;
 732         int num_ports = 0;
 733         int max_endpoints;
 734
 735         mutex_lock(&table_lock);
 736         type = search_serial_device(interface);
 737         if (!type) {
 738                 mutex_unlock(&table_lock);
 739                 dev_dbg(ddev, "none matched\n");
 740                 return -ENODEV;
 741         }
 742
 743         if (!try_module_get(type->driver.owner)) {
 744                 mutex_unlock(&table_lock);
 745                 dev_err(ddev, "module get failed, exiting\n");
 746                 return -EIO;
 747         }
 748         mutex_unlock(&table_lock);
 749
 750         serial = create_serial(dev, interface, type);
 751         if (!serial) {
 752                 module_put(type->driver.owner);
 753                 return -ENOMEM;
 754         }
 755
 756         /* if this device type has a probe function, call it */
 757         if (type->probe) {
 758                 const struct usb_device_id *id;
 759
 760                 id = get_iface_id(type, interface);
 761                 retval = type->probe(serial, id);
 762
 763                 if (retval) {
 764                         dev_dbg(ddev, "sub driver rejected device\n");
 765                         usb_serial_put(serial);
 766                         module_put(type->driver.owner);
 767                         return retval;
 768                 }
 769         }
 770
 771         /* descriptor matches, let's find the endpoints needed */
 772         /* check out the endpoints */
 773         iface_desc = interface->cur_altsetting;
 774         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 775                 endpoint = &iface_desc->endpoint[i].desc;
 776
 777                 if (usb_endpoint_is_bulk_in(endpoint)) {
 778                         /* we found a bulk in endpoint */
 779                         dev_dbg(ddev, "found bulk in on endpoint %d\n", i);
 780                         if (num_bulk_in < MAX_NUM_PORTS) {
 781                                 bulk_in_endpoint[num_bulk_in] = endpoint;
 782                                 ++num_bulk_in;
 783                         }
 784                 }
 785
 786                 if (usb_endpoint_is_bulk_out(endpoint)) {
 787                         /* we found a bulk out endpoint */
 788                         dev_dbg(ddev, "found bulk out on endpoint %d\n", i);
 789                         if (num_bulk_out < MAX_NUM_PORTS) {
 790                                 bulk_out_endpoint[num_bulk_out] = endpoint;
 791                                 ++num_bulk_out;
 792                         }
 793                 }
 794
 795                 if (usb_endpoint_is_int_in(endpoint)) {
 796                         /* we found a interrupt in endpoint */
 797                         dev_dbg(ddev, "found interrupt in on endpoint %d\n", i);
 798                         if (num_interrupt_in < MAX_NUM_PORTS) {
 799                                 interrupt_in_endpoint[num_interrupt_in] =
 800                                                 endpoint;
 801                                 ++num_interrupt_in;
 802                         }
 803                 }
 804
 805                 if (usb_endpoint_is_int_out(endpoint)) {
 806                         /* we found an interrupt out endpoint */
 807                         dev_dbg(ddev, "found interrupt out on endpoint %d\n", i);
 808                         if (num_interrupt_out < MAX_NUM_PORTS) {
 809                                 interrupt_out_endpoint[num_interrupt_out] =
 810                                                 endpoint;
 811                                 ++num_interrupt_out;
 812                         }
 813                 }
 814         }
 815
 816 #if IS_ENABLED(CONFIG_USB_SERIAL_PL2303)
 817         /* BEGIN HORRIBLE HACK FOR PL2303 */
 818         /* this is needed due to the looney way its endpoints are set up */
 819         if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
 820              (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
 821             ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
 822              (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
 823             ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
 824              (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID)) ||
 825             ((le16_to_cpu(dev->descriptor.idVendor) == SIEMENS_VENDOR_ID) &&
 826              (le16_to_cpu(dev->descriptor.idProduct) == SIEMENS_PRODUCT_ID_EF81))) {
 827                 if (interface != dev->actconfig->interface[0]) {
 828                         /* check out the endpoints of the other interface*/
 829                         iface_desc = dev->actconfig->interface[0]->cur_altsetting;
 830                         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
 831                                 endpoint = &iface_desc->endpoint[i].desc;
 832                                 if (usb_endpoint_is_int_in(endpoint)) {
 833                                         /* we found a interrupt in endpoint */
 834                                         dev_dbg(ddev, "found interrupt in for Prolific device on separate interface\n");
 835                                         if (num_interrupt_in < MAX_NUM_PORTS) {
 836                                                 interrupt_in_endpoint[num_interrupt_in] = endpoint;
 837                                                 ++num_interrupt_in;
 838                                         }
 839                                 }
 840                         }
 841                 }
 842
 843                 /* Now make sure the PL-2303 is configured correctly.
 844                  * If not, give up now and hope this hack will work
 845                  * properly during a later invocation of usb_serial_probe
 846                  */
 847                 if (num_bulk_in == 0 || num_bulk_out == 0) {
 848                         dev_info(ddev, "PL-2303 hack: descriptors matched but endpoints did not\n");
 849                         usb_serial_put(serial);
 850                         module_put(type->driver.owner);
 851                         return -ENODEV;
 852                 }
 853         }
 854         /* END HORRIBLE HACK FOR PL2303 */
 855 #endif
 856
 857 #ifdef CONFIG_USB_SERIAL_GENERIC
 858         if (type == &usb_serial_generic_device) {
 859                 num_ports = num_bulk_out;
 860                 if (num_ports == 0) {
 861                         dev_err(ddev, "Generic device with no bulk out, not allowed.\n");
 862                         usb_serial_put(serial);
 863                         module_put(type->driver.owner);
 864                         return -EIO;
 865                 }
 866                 dev_info(ddev, "The \"generic\" usb-serial driver is only for testing and one-off prototypes.\n");
 867                 dev_info(ddev, "Tell linux-usb@vger.kernel.org to add your device to a proper driver.\n");
 868         }
 869 #endif
 870         if (!num_ports) {
 871                 /* if this device type has a calc_num_ports function, call it */
 872                 if (type->calc_num_ports)
 873                         num_ports = type->calc_num_ports(serial);
 874                 if (!num_ports)
 875                         num_ports = type->num_ports;
 876         }
 877
 878         if (num_ports > MAX_NUM_PORTS) {
 879                 dev_warn(ddev, "too many ports requested: %d\n", num_ports);
 880                 num_ports = MAX_NUM_PORTS;
 881         }
 882
 883         serial->num_ports = num_ports;
 884         serial->num_bulk_in = num_bulk_in;
 885         serial->num_bulk_out = num_bulk_out;
 886         serial->num_interrupt_in = num_interrupt_in;
 887         serial->num_interrupt_out = num_interrupt_out;
 888
 889         /* found all that we need */
 890         dev_info(ddev, "%s converter detected\n", type->description);
 891
 892         /* create our ports, we need as many as the max endpoints */
 893         /* we don't use num_ports here because some devices have more
 894            endpoint pairs than ports */
 895         max_endpoints = max(num_bulk_in, num_bulk_out);
 896         max_endpoints = max(max_endpoints, num_interrupt_in);
 897         max_endpoints = max(max_endpoints, num_interrupt_out);
 898         max_endpoints = max(max_endpoints, (int)serial->num_ports);
 899         serial->num_port_pointers = max_endpoints;
 900
 901         dev_dbg(ddev, "setting up %d port structure(s)\n", max_endpoints);
 902         for (i = 0; i < max_endpoints; ++i) {
 903                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
 904                 if (!port)
 905                         goto probe_error;
 906                 tty_port_init(&port->port);
 907                 port->port.ops = &serial_port_ops;
 908                 port->serial = serial;
 909                 spin_lock_init(&port->lock);
 910                 /* Keep this for private driver use for the moment but
 911                    should probably go away */
 912                 INIT_WORK(&port->work, usb_serial_port_work);
 913                 serial->port[i] = port;
 914                 port->dev.parent = &interface->dev;
 915                 port->dev.driver = NULL;
 916                 port->dev.bus = &usb_serial_bus_type;
 917                 port->dev.release = &usb_serial_port_release;
 918                 port->dev.groups = usb_serial_port_groups;
 919                 device_initialize(&port->dev);
 920         }
 921
 922         /* set up the endpoint information */
 923         for (i = 0; i < num_bulk_in; ++i) {
 924                 endpoint = bulk_in_endpoint[i];
 925                 port = serial->port[i];
 926                 buffer_size = max_t(int, serial->type->bulk_in_size,
 927                                 usb_endpoint_maxp(endpoint));
 928                 port->bulk_in_size = buffer_size;
 929                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
 930
 931                 for (j = 0; j < ARRAY_SIZE(port->read_urbs); ++j) {
 932                         set_bit(j, &port->read_urbs_free);
 933                         port->read_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
 934                         if (!port->read_urbs[j])
 935                                 goto probe_error;
 936                         port->bulk_in_buffers[j] = kmalloc(buffer_size,
 937                                                                 GFP_KERNEL);
 938                         if (!port->bulk_in_buffers[j])
 939                                 goto probe_error;
 940                         usb_fill_bulk_urb(port->read_urbs[j], dev,
 941                                         usb_rcvbulkpipe(dev,
 942                                                 endpoint->bEndpointAddress),
 943                                         port->bulk_in_buffers[j], buffer_size,
 944                                         serial->type->read_bulk_callback,
 945                                         port);
 946                 }
 947
 948                 port->read_urb = port->read_urbs[0];
 949                 port->bulk_in_buffer = port->bulk_in_buffers[0];
 950         }
 951
 952         for (i = 0; i < num_bulk_out; ++i) {
 953                 endpoint = bulk_out_endpoint[i];
 954                 port = serial->port[i];
 955                 if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
 956                         goto probe_error;
 957                 buffer_size = serial->type->bulk_out_size;
 958                 if (!buffer_size)
 959                         buffer_size = usb_endpoint_maxp(endpoint);
 960                 port->bulk_out_size = buffer_size;
 961                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
 962
 963                 for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
 964                         set_bit(j, &port->write_urbs_free);
 965                         port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
 966                         if (!port->write_urbs[j])
 967                                 goto probe_error;
 968                         port->bulk_out_buffers[j] = kmalloc(buffer_size,
 969                                                                 GFP_KERNEL);
 970                         if (!port->bulk_out_buffers[j])
 971                                 goto probe_error;
 972                         usb_fill_bulk_urb(port->write_urbs[j], dev,
 973                                         usb_sndbulkpipe(dev,
 974                                                 endpoint->bEndpointAddress),
 975                                         port->bulk_out_buffers[j], buffer_size,
 976                                         serial->type->write_bulk_callback,
 977                                         port);
 978                 }
 979
 980                 port->write_urb = port->write_urbs[0];
 981                 port->bulk_out_buffer = port->bulk_out_buffers[0];
 982         }
 983
 984         if (serial->type->read_int_callback) {
 985                 for (i = 0; i < num_interrupt_in; ++i) {
 986                         endpoint = interrupt_in_endpoint[i];
 987                         port = serial->port[i];
 988                         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
 989                         if (!port->interrupt_in_urb)
 990                                 goto probe_error;
 991                         buffer_size = usb_endpoint_maxp(endpoint);
 992                         port->interrupt_in_endpointAddress =
 993                                                 endpoint->bEndpointAddress;
 994                         port->interrupt_in_buffer = kmalloc(buffer_size,
 995                                                                 GFP_KERNEL);
 996                         if (!port->interrupt_in_buffer)
 997                                 goto probe_error;
 998                         usb_fill_int_urb(port->interrupt_in_urb, dev,
 999                                 usb_rcvintpipe(dev,
1000                                                 endpoint->bEndpointAddress),
1001                                 port->interrupt_in_buffer, buffer_size,
1002                                 serial->type->read_int_callback, port,
1003                                 endpoint->bInterval);
1004                 }
1005         } else if (num_interrupt_in) {
1006                 dev_dbg(ddev, "The device claims to support interrupt in transfers, but read_int_callback is not defined\n");
1007         }
1008
1009         if (serial->type->write_int_callback) {
1010                 for (i = 0; i < num_interrupt_out; ++i) {
1011                         endpoint = interrupt_out_endpoint[i];
1012                         port = serial->port[i];
1013                         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
1014                         if (!port->interrupt_out_urb)
1015                                 goto probe_error;
1016                         buffer_size = usb_endpoint_maxp(endpoint);
1017                         port->interrupt_out_size = buffer_size;
1018                         port->interrupt_out_endpointAddress =
1019                                                 endpoint->bEndpointAddress;
1020                         port->interrupt_out_buffer = kmalloc(buffer_size,
1021                                                                 GFP_KERNEL);
1022                         if (!port->interrupt_out_buffer)
1023                                 goto probe_error;
1024                         usb_fill_int_urb(port->interrupt_out_urb, dev,
1025                                 usb_sndintpipe(dev,
1026                                                   endpoint->bEndpointAddress),
1027                                 port->interrupt_out_buffer, buffer_size,
1028                                 serial->type->write_int_callback, port,
1029                                 endpoint->bInterval);
1030                 }
1031         } else if (num_interrupt_out) {
1032                 dev_dbg(ddev, "The device claims to support interrupt out transfers, but write_int_callback is not defined\n");
1033         }
1034
1035         usb_set_intfdata(interface, serial);
1036
1037         /* if this device type has an attach function, call it */
1038         if (type->attach) {
1039                 retval = type->attach(serial);
1040                 if (retval < 0)
1041                         goto probe_error;
1042                 serial->attached = 1;
1043                 if (retval > 0) {
1044                         /* quietly accept this device, but don't bind to a
1045                            serial port as it's about to disappear */
1046                         serial->num_ports = 0;
1047                         goto exit;
1048                 }
1049         } else {
1050                 serial->attached = 1;
1051         }
1052
1053         /* Avoid race with tty_open and serial_install by setting the
1054          * disconnected flag and not clearing it until all ports have been
1055          * registered.
1056          */
1057         serial->disconnected = 1;
1058
1059         if (allocate_minors(serial, num_ports)) {
1060                 dev_err(ddev, "No more free serial minor numbers\n");
1061                 goto probe_error;
1062         }
1063
1064         /* register all of the individual ports with the driver core */
1065         for (i = 0; i < num_ports; ++i) {
1066                 port = serial->port[i];
1067                 dev_set_name(&port->dev, "ttyUSB%d", port->minor);
1068                 dev_dbg(ddev, "registering %s\n", dev_name(&port->dev));
1069                 device_enable_async_suspend(&port->dev);
1070
1071                 retval = device_add(&port->dev);
1072                 if (retval)
1073                         dev_err(ddev, "Error registering port device, continuing\n");
1074         }
1075
1076         serial->disconnected = 0;
1077
1078         if (num_ports > 0)
1079                 usb_serial_console_init(serial->port[0]->minor);
1080 exit:
1081         module_put(type->driver.owner);
1082         return 0;
1083
1084 probe_error:
1085         usb_serial_put(serial);
1086         module_put(type->driver.owner);
1087         return -EIO;
1088 }
1089
1090 static void usb_serial_disconnect(struct usb_interface *interface)
1091 {
1092         int i;
1093         struct usb_serial *serial = usb_get_intfdata(interface);
1094         struct device *dev = &interface->dev;
1095         struct usb_serial_port *port;
1096         struct tty_struct *tty;
1097
1098         usb_serial_console_disconnect(serial);
1099
1100         mutex_lock(&serial->disc_mutex);
1101         /* must set a flag, to signal subdrivers */
1102         serial->disconnected = 1;
1103         mutex_unlock(&serial->disc_mutex);
1104
1105         for (i = 0; i < serial->num_ports; ++i) {
1106                 port = serial->port[i];
1107                 tty = tty_port_tty_get(&port->port);
1108                 if (tty) {
1109                         tty_vhangup(tty);
1110                         tty_kref_put(tty);
1111                 }
1112                 usb_serial_port_poison_urbs(port);
1113                 wake_up_interruptible(&port->port.delta_msr_wait);
1114                 cancel_work_sync(&port->work);
1115                 if (device_is_registered(&port->dev))
1116                         device_del(&port->dev);
1117         }
1118         if (serial->type->disconnect)
1119                 serial->type->disconnect(serial);
1120
1121         /* let the last holder of this object cause it to be cleaned up */
1122         usb_serial_put(serial);
1123         dev_info(dev, "device disconnected\n");
1124 }
1125
1126 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1127 {
1128         struct usb_serial *serial = usb_get_intfdata(intf);
1129         int i, r = 0;
1130
1131         serial->suspending = 1;
1132
1133         /*
1134          * serial->type->suspend() MUST return 0 in system sleep context,
1135          * otherwise, the resume callback has to recover device from
1136          * previous suspend failure.
1137          */
1138         if (serial->type->suspend) {
1139                 r = serial->type->suspend(serial, message);
1140                 if (r < 0) {
1141                         serial->suspending = 0;
1142                         goto err_out;
1143                 }
1144         }
1145
1146         for (i = 0; i < serial->num_ports; ++i)
1147                 usb_serial_port_poison_urbs(serial->port[i]);
1148 err_out:
1149         return r;
1150 }
1151 EXPORT_SYMBOL(usb_serial_suspend);
1152
1153 static void usb_serial_unpoison_port_urbs(struct usb_serial *serial)
1154 {
1155         int i;
1156
1157         for (i = 0; i < serial->num_ports; ++i)
1158                 usb_serial_port_unpoison_urbs(serial->port[i]);
1159 }
1160
1161 int usb_serial_resume(struct usb_interface *intf)
1162 {
1163         struct usb_serial *serial = usb_get_intfdata(intf);
1164         int rv;
1165
1166         usb_serial_unpoison_port_urbs(serial);
1167
1168         serial->suspending = 0;
1169         if (serial->type->resume)
1170                 rv = serial->type->resume(serial);
1171         else
1172                 rv = usb_serial_generic_resume(serial);
1173
1174         return rv;
1175 }
1176 EXPORT_SYMBOL(usb_serial_resume);
1177
1178 static int usb_serial_reset_resume(struct usb_interface *intf)
1179 {
1180         struct usb_serial *serial = usb_get_intfdata(intf);
1181         int rv;
1182
1183         usb_serial_unpoison_port_urbs(serial);
1184
1185         serial->suspending = 0;
1186         if (serial->type->reset_resume) {
1187                 rv = serial->type->reset_resume(serial);
1188         } else {
1189                 rv = -EOPNOTSUPP;
1190                 intf->needs_binding = 1;
1191         }
1192
1193         return rv;
1194 }
1195
1196 static const struct tty_operations serial_ops = {
1197         .open =                 serial_open,
1198         .close =                serial_close,
1199         .write =                serial_write,
1200         .hangup =               serial_hangup,
1201         .write_room =           serial_write_room,
1202         .ioctl =                serial_ioctl,
1203         .set_termios =          serial_set_termios,
1204         .throttle =             serial_throttle,
1205         .unthrottle =           serial_unthrottle,
1206         .break_ctl =            serial_break,
1207         .chars_in_buffer =      serial_chars_in_buffer,
1208         .wait_until_sent =      serial_wait_until_sent,
1209         .tiocmget =             serial_tiocmget,
1210         .tiocmset =             serial_tiocmset,
1211         .get_icount =           serial_get_icount,
1212         .cleanup =              serial_cleanup,
1213         .install =              serial_install,
1214         .proc_fops =            &serial_proc_fops,
1215 };
1216
1217
1218 struct tty_driver *usb_serial_tty_driver;
1219
1220 /* Driver structure we register with the USB core */
1221 static struct usb_driver usb_serial_driver = {
1222         .name =         "usbserial",
1223         .probe =        usb_serial_probe,
1224         .disconnect =   usb_serial_disconnect,
1225         .suspend =      usb_serial_suspend,
1226         .resume =       usb_serial_resume,
1227         .no_dynamic_id =        1,
1228         .supports_autosuspend = 1,
1229 };
1230
1231 static int __init usb_serial_init(void)
1232 {
1233         int result;
1234
1235         usb_serial_tty_driver = alloc_tty_driver(USB_SERIAL_TTY_MINORS);
1236         if (!usb_serial_tty_driver)
1237                 return -ENOMEM;
1238
1239         /* Initialize our global data */
1240         result = bus_register(&usb_serial_bus_type);
1241         if (result) {
1242                 pr_err("%s - registering bus driver failed\n", __func__);
1243                 goto exit_bus;
1244         }
1245
1246         usb_serial_tty_driver->driver_name = "usbserial";
1247         usb_serial_tty_driver->name = "ttyUSB";
1248         usb_serial_tty_driver->major = USB_SERIAL_TTY_MAJOR;
1249         usb_serial_tty_driver->minor_start = 0;
1250         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1251         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1252         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1253                                                 TTY_DRIVER_DYNAMIC_DEV;
1254         usb_serial_tty_driver->init_termios = tty_std_termios;
1255         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1256                                                         | HUPCL | CLOCAL;
1257         usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1258         usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1259         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1260         result = tty_register_driver(usb_serial_tty_driver);
1261         if (result) {
1262                 pr_err("%s - tty_register_driver failed\n", __func__);
1263                 goto exit_reg_driver;
1264         }
1265
1266         /* register the USB driver */
1267         result = usb_register(&usb_serial_driver);
1268         if (result < 0) {
1269                 pr_err("%s - usb_register failed\n", __func__);
1270                 goto exit_tty;
1271         }
1272
1273         /* register the generic driver, if we should */
1274         result = usb_serial_generic_register();
1275         if (result < 0) {
1276                 pr_err("%s - registering generic driver failed\n", __func__);
1277                 goto exit_generic;
1278         }
1279
1280         return result;
1281
1282 exit_generic:
1283         usb_deregister(&usb_serial_driver);
1284
1285 exit_tty:
1286         tty_unregister_driver(usb_serial_tty_driver);
1287
1288 exit_reg_driver:
1289         bus_unregister(&usb_serial_bus_type);
1290
1291 exit_bus:
1292         pr_err("%s - returning with error %d\n", __func__, result);
1293         put_tty_driver(usb_serial_tty_driver);
1294         return result;
1295 }
1296
1297
1298 static void __exit usb_serial_exit(void)
1299 {
1300         usb_serial_console_exit();
1301
1302         usb_serial_generic_deregister();
1303
1304         usb_deregister(&usb_serial_driver);
1305         tty_unregister_driver(usb_serial_tty_driver);
1306         put_tty_driver(usb_serial_tty_driver);
1307         bus_unregister(&usb_serial_bus_type);
1308         idr_destroy(&serial_minors);
1309 }
1310
1311
1312 module_init(usb_serial_init);
1313 module_exit(usb_serial_exit);
1314
1315 #define set_to_generic_if_null(type, function)                          \
1316         do {                                                            \
1317                 if (!type->function) {                                  \
1318                         type->function = usb_serial_generic_##function; \
1319                         pr_debug("%s: using generic " #function "\n",   \
1320                                                 type->driver.name);     \
1321                 }                                                       \
1322         } while (0)
1323
1324 static void usb_serial_operations_init(struct usb_serial_driver *device)
1325 {
1326         set_to_generic_if_null(device, open);
1327         set_to_generic_if_null(device, write);
1328         set_to_generic_if_null(device, close);
1329         set_to_generic_if_null(device, write_room);
1330         set_to_generic_if_null(device, chars_in_buffer);
1331         if (device->tx_empty)
1332                 set_to_generic_if_null(device, wait_until_sent);
1333         set_to_generic_if_null(device, read_bulk_callback);
1334         set_to_generic_if_null(device, write_bulk_callback);
1335         set_to_generic_if_null(device, process_read_urb);
1336         set_to_generic_if_null(device, prepare_write_buffer);
1337 }
1338
1339 static int usb_serial_register(struct usb_serial_driver *driver)
1340 {
1341         int retval;
1342
1343         if (usb_disabled())
1344                 return -ENODEV;
1345
1346         if (!driver->description)
1347                 driver->description = driver->driver.name;
1348         if (!driver->usb_driver) {
1349                 WARN(1, "Serial driver %s has no usb_driver\n",
1350                                 driver->description);
1351                 return -EINVAL;
1352         }
1353
1354         /* Prevent individual ports from being unbound. */
1355         driver->driver.suppress_bind_attrs = true;
1356
1357         usb_serial_operations_init(driver);
1358
1359         /* Add this device to our list of devices */
1360         mutex_lock(&table_lock);
1361         list_add(&driver->driver_list, &usb_serial_driver_list);
1362
1363         retval = usb_serial_bus_register(driver);
1364         if (retval) {
1365                 pr_err("problem %d when registering driver %s\n", retval, driver->description);
1366                 list_del(&driver->driver_list);
1367         } else {
1368                 pr_info("USB Serial support registered for %s\n", driver->description);
1369         }
1370         mutex_unlock(&table_lock);
1371         return retval;
1372 }
1373
1374 static void usb_serial_deregister(struct usb_serial_driver *device)
1375 {
1376         pr_info("USB Serial deregistering driver %s\n", device->description);
1377
1378         mutex_lock(&table_lock);
1379         list_del(&device->driver_list);
1380         mutex_unlock(&table_lock);
1381
1382         usb_serial_bus_deregister(device);
1383 }
1384
1385 /**
1386  * usb_serial_register_drivers - register drivers for a usb-serial module
1387  * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
1388  * @name: name of the usb_driver for this set of @serial_drivers
1389  * @id_table: list of all devices this @serial_drivers set binds to
1390  *
1391  * Registers all the drivers in the @serial_drivers array, and dynamically
1392  * creates a struct usb_driver with the name @name and id_table of @id_table.
1393  */
1394 int usb_serial_register_drivers(struct usb_serial_driver *const serial_drivers[],
1395                                 const char *name,
1396                                 const struct usb_device_id *id_table)
1397 {
1398         int rc;
1399         struct usb_driver *udriver;
1400         struct usb_serial_driver * const *sd;
1401
1402         /*
1403          * udriver must be registered before any of the serial drivers,
1404          * because the store_new_id() routine for the serial drivers (in
1405          * bus.c) probes udriver.
1406          *
1407          * Performance hack: We don't want udriver to be probed until
1408          * the serial drivers are registered, because the probe would
1409          * simply fail for lack of a matching serial driver.
1410          * So we leave udriver's id_table set to NULL until we are all set.
1411          *
1412          * Suspend/resume support is implemented in the usb-serial core,
1413          * so fill in the PM-related fields in udriver.
1414          */
1415         udriver = kzalloc(sizeof(*udriver), GFP_KERNEL);
1416         if (!udriver)
1417                 return -ENOMEM;
1418
1419         udriver->name = name;
1420         udriver->no_dynamic_id = 1;
1421         udriver->supports_autosuspend = 1;
1422         udriver->suspend = usb_serial_suspend;
1423         udriver->resume = usb_serial_resume;
1424         udriver->probe = usb_serial_probe;
1425         udriver->disconnect = usb_serial_disconnect;
1426
1427         /* we only set the reset_resume field if the serial_driver has one */
1428         for (sd = serial_drivers; *sd; ++sd) {
1429                 if ((*sd)->reset_resume) {
1430                         udriver->reset_resume = usb_serial_reset_resume;
1431                         break;
1432                 }
1433         }
1434
1435         rc = usb_register(udriver);
1436         if (rc)
1437                 goto failed_usb_register;
1438
1439         for (sd = serial_drivers; *sd; ++sd) {
1440                 (*sd)->usb_driver = udriver;
1441                 rc = usb_serial_register(*sd);
1442                 if (rc)
1443                         goto failed;
1444         }
1445
1446         /* Now set udriver's id_table and look for matches */
1447         udriver->id_table = id_table;
1448         rc = driver_attach(&udriver->drvwrap.driver);
1449         return 0;
1450
1451  failed:
1452         while (sd-- > serial_drivers)
1453                 usb_serial_deregister(*sd);
1454         usb_deregister(udriver);
1455 failed_usb_register:
1456         kfree(udriver);
1457         return rc;
1458 }
1459 EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
1460
1461 /**
1462  * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
1463  * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
1464  *
1465  * Deregisters all the drivers in the @serial_drivers array and deregisters and
1466  * frees the struct usb_driver that was created by the call to
1467  * usb_serial_register_drivers().
1468  */
1469 void usb_serial_deregister_drivers(struct usb_serial_driver *const serial_drivers[])
1470 {
1471         struct usb_driver *udriver = (*serial_drivers)->usb_driver;
1472
1473         for (; *serial_drivers; ++serial_drivers)
1474                 usb_serial_deregister(*serial_drivers);
1475         usb_deregister(udriver);
1476         kfree(udriver);
1477 }
1478 EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
1479
1480 MODULE_AUTHOR(DRIVER_AUTHOR);
1481 MODULE_DESCRIPTION(DRIVER_DESC);
1482 MODULE_LICENSE("GPL");