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