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