drivers/usb/serial/usb-serial.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
usb_serial_port_get_by_minor
allocate_minors
release_minors
destroy_serial
usb_serial_put
serial_install
serial_port_activate
serial_open
serial_port_shutdown
serial_hangup
serial_close
serial_cleanup
serial_write
serial_write_room
serial_chars_in_buffer
serial_wait_until_sent
serial_throttle
serial_unthrottle
serial_get_serial
serial_set_serial
serial_ioctl
serial_set_termios
serial_break
serial_proc_show
serial_tiocmget
serial_tiocmset
serial_get_icount
usb_serial_port_softint
usb_serial_port_work
usb_serial_port_poison_urbs
usb_serial_port_unpoison_urbs
usb_serial_port_release
create_serial
match_dynamic_id
get_iface_id
search_serial_device
serial_port_carrier_raised
serial_port_dtr_rts
port_number_show
find_endpoints
setup_port_bulk_in
setup_port_bulk_out
setup_port_interrupt_in
setup_port_interrupt_out
usb_serial_probe
usb_serial_disconnect
usb_serial_suspend
usb_serial_unpoison_port_urbs
usb_serial_resume
usb_serial_reset_resume
usb_serial_init
usb_serial_exit
usb_serial_operations_init
usb_serial_register
usb_serial_deregister
usb_serial_register_drivers
usb_serial_deregister_drivers
   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 
  52 static DEFINE_IDR(serial_minors);
  53 static DEFINE_MUTEX(table_lock);
  54 static 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  */
  61 struct 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         }
  79 exit:
  80         mutex_unlock(&table_lock);
  81         return port;
  82 }
  83 
  84 static 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;
 105 error:
 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 
 113 static 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 
 124 static 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 
 153 void 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  */
 176 static 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 
 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_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 
 408 static 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 
 417 static 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 
 438 static 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 
 450 static 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 
 462 static 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 
 497 static 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 
 508 static 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 
 520 static 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  */
 537 void usb_serial_port_softint(struct usb_serial_port *port)
 538 {
 539         schedule_work(&port->work);
 540 }
 541 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
 542 
 543 static 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 
 551 static 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 
 564 static 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 
 577 static 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 
 601 static 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 
 620 static 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 
 636 static 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");
 649 exit:
 650         return id;
 651 }
 652 
 653 /* Caller must hold table_lock */
 654 static 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 
 672 static 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 
 683 static 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 
 692 static 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 }
 699 static DEVICE_ATTR_RO(port_number);
 700 
 701 static struct attribute *usb_serial_port_attrs[] = {
 702         &dev_attr_port_number.attr,
 703         NULL
 704 };
 705 ATTRIBUTE_GROUPS(usb_serial_port);
 706 
 707 static 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 
 714 static 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 
 747 static 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 
 779 static 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 
 816 static 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 
 840 static 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 
 865 static 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);
1061 exit:
1062         kfree(epds);
1063         module_put(type->driver.owner);
1064         return 0;
1065 
1066 err_free_epds:
1067         kfree(epds);
1068 err_put_serial:
1069         usb_serial_put(serial);
1070 err_put_module:
1071         module_put(type->driver.owner);
1072 
1073         return retval;
1074 }
1075 
1076 static 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 
1112 int 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]);
1134 err_out:
1135         return r;
1136 }
1137 EXPORT_SYMBOL(usb_serial_suspend);
1138 
1139 static 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 
1147 int 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 }
1162 EXPORT_SYMBOL(usb_serial_resume);
1163 
1164 static 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 
1182 static 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 
1206 struct tty_driver *usb_serial_tty_driver;
1207 
1208 static 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 
1252 exit_generic:
1253         tty_unregister_driver(usb_serial_tty_driver);
1254 
1255 exit_reg_driver:
1256         bus_unregister(&usb_serial_bus_type);
1257 
1258 exit_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 
1265 static 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 
1278 module_init(usb_serial_init);
1279 module_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 
1290 static 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 
1305 static 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         /* Prevent individual ports from being unbound. */
1321         driver->driver.suppress_bind_attrs = true;
1322 
1323         usb_serial_operations_init(driver);
1324 
1325         /* Add this device to our list of devices */
1326         mutex_lock(&table_lock);
1327         list_add(&driver->driver_list, &usb_serial_driver_list);
1328 
1329         retval = usb_serial_bus_register(driver);
1330         if (retval) {
1331                 pr_err("problem %d when registering driver %s\n", retval, driver->description);
1332                 list_del(&driver->driver_list);
1333         } else {
1334                 pr_info("USB Serial support registered for %s\n", driver->description);
1335         }
1336         mutex_unlock(&table_lock);
1337         return retval;
1338 }
1339 
1340 static void usb_serial_deregister(struct usb_serial_driver *device)
1341 {
1342         pr_info("USB Serial deregistering driver %s\n", device->description);
1343 
1344         mutex_lock(&table_lock);
1345         list_del(&device->driver_list);
1346         mutex_unlock(&table_lock);
1347 
1348         usb_serial_bus_deregister(device);
1349 }
1350 
1351 /**
1352  * usb_serial_register_drivers - register drivers for a usb-serial module
1353  * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
1354  * @name: name of the usb_driver for this set of @serial_drivers
1355  * @id_table: list of all devices this @serial_drivers set binds to
1356  *
1357  * Registers all the drivers in the @serial_drivers array, and dynamically
1358  * creates a struct usb_driver with the name @name and id_table of @id_table.
1359  */
1360 int usb_serial_register_drivers(struct usb_serial_driver *const serial_drivers[],
1361                                 const char *name,
1362                                 const struct usb_device_id *id_table)
1363 {
1364         int rc;
1365         struct usb_driver *udriver;
1366         struct usb_serial_driver * const *sd;
1367 
1368         /*
1369          * udriver must be registered before any of the serial drivers,
1370          * because the store_new_id() routine for the serial drivers (in
1371          * bus.c) probes udriver.
1372          *
1373          * Performance hack: We don't want udriver to be probed until
1374          * the serial drivers are registered, because the probe would
1375          * simply fail for lack of a matching serial driver.
1376          * So we leave udriver's id_table set to NULL until we are all set.
1377          *
1378          * Suspend/resume support is implemented in the usb-serial core,
1379          * so fill in the PM-related fields in udriver.
1380          */
1381         udriver = kzalloc(sizeof(*udriver), GFP_KERNEL);
1382         if (!udriver)
1383                 return -ENOMEM;
1384 
1385         udriver->name = name;
1386         udriver->no_dynamic_id = 1;
1387         udriver->supports_autosuspend = 1;
1388         udriver->suspend = usb_serial_suspend;
1389         udriver->resume = usb_serial_resume;
1390         udriver->probe = usb_serial_probe;
1391         udriver->disconnect = usb_serial_disconnect;
1392 
1393         /* we only set the reset_resume field if the serial_driver has one */
1394         for (sd = serial_drivers; *sd; ++sd) {
1395                 if ((*sd)->reset_resume) {
1396                         udriver->reset_resume = usb_serial_reset_resume;
1397                         break;
1398                 }
1399         }
1400 
1401         rc = usb_register(udriver);
1402         if (rc)
1403                 goto failed_usb_register;
1404 
1405         for (sd = serial_drivers; *sd; ++sd) {
1406                 (*sd)->usb_driver = udriver;
1407                 rc = usb_serial_register(*sd);
1408                 if (rc)
1409                         goto failed;
1410         }
1411 
1412         /* Now set udriver's id_table and look for matches */
1413         udriver->id_table = id_table;
1414         rc = driver_attach(&udriver->drvwrap.driver);
1415         return 0;
1416 
1417  failed:
1418         while (sd-- > serial_drivers)
1419                 usb_serial_deregister(*sd);
1420         usb_deregister(udriver);
1421 failed_usb_register:
1422         kfree(udriver);
1423         return rc;
1424 }
1425 EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
1426 
1427 /**
1428  * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
1429  * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
1430  *
1431  * Deregisters all the drivers in the @serial_drivers array and deregisters and
1432  * frees the struct usb_driver that was created by the call to
1433  * usb_serial_register_drivers().
1434  */
1435 void usb_serial_deregister_drivers(struct usb_serial_driver *const serial_drivers[])
1436 {
1437         struct usb_driver *udriver = (*serial_drivers)->usb_driver;
1438 
1439         for (; *serial_drivers; ++serial_drivers)
1440                 usb_serial_deregister(*serial_drivers);
1441         usb_deregister(udriver);
1442         kfree(udriver);
1443 }
1444 EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
1445 
1446 MODULE_AUTHOR(DRIVER_AUTHOR);
1447 MODULE_DESCRIPTION(DRIVER_DESC);
1448 MODULE_LICENSE("GPL v2");
/* [<][>][^][v][top][bottom][index][help] */
root/drivers/usb/serial/usb-serial.c

DEFINITIONS
