Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * USB Serial Converter driver
0004  *
0005  * Copyright (C) 2009 - 2013 Johan Hovold (jhovold@gmail.com)
0006  * Copyright (C) 1999 - 2012 Greg Kroah-Hartman (greg@kroah.com)
0007  * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
0008  * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
0009  *
0010  * This driver was originally based on the ACM driver by Armin Fuerst (which was
0011  * based on a driver by Brad Keryan)
0012  *
0013  * See Documentation/usb/usb-serial.rst for more information on using this
0014  * driver
0015  */
0016 
0017 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0018 
0019 #include <linux/kernel.h>
0020 #include <linux/errno.h>
0021 #include <linux/init.h>
0022 #include <linux/slab.h>
0023 #include <linux/tty.h>
0024 #include <linux/tty_driver.h>
0025 #include <linux/tty_flip.h>
0026 #include <linux/module.h>
0027 #include <linux/moduleparam.h>
0028 #include <linux/seq_file.h>
0029 #include <linux/spinlock.h>
0030 #include <linux/mutex.h>
0031 #include <linux/list.h>
0032 #include <linux/uaccess.h>
0033 #include <linux/serial.h>
0034 #include <linux/usb.h>
0035 #include <linux/usb/serial.h>
0036 #include <linux/kfifo.h>
0037 #include <linux/idr.h>
0038 
0039 #define DRIVER_AUTHOR "Greg Kroah-Hartman <gregkh@linuxfoundation.org>"
0040 #define DRIVER_DESC "USB Serial Driver core"
0041 
0042 #define USB_SERIAL_TTY_MAJOR    188
0043 #define USB_SERIAL_TTY_MINORS   512 /* should be enough for a while */
0044 
0045 /* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
0046    the MODULE_DEVICE_TABLE declarations in each serial driver
0047    cause the "hotplug" program to pull in whatever module is necessary
0048    via modprobe, and modprobe will load usbserial because the serial
0049    drivers depend on it.
0050 */
0051 
0052 static DEFINE_IDR(serial_minors);
0053 static DEFINE_MUTEX(table_lock);
0054 static LIST_HEAD(usb_serial_driver_list);
0055 
0056 /*
0057  * Look up the serial port structure.  If it is found and it hasn't been
0058  * disconnected, return with the parent usb_serial structure's disc_mutex held
0059  * and its refcount incremented.  Otherwise return NULL.
0060  */
0061 struct usb_serial_port *usb_serial_port_get_by_minor(unsigned minor)
0062 {
0063     struct usb_serial *serial;
0064     struct usb_serial_port *port;
0065 
0066     mutex_lock(&table_lock);
0067     port = idr_find(&serial_minors, minor);
0068     if (!port)
0069         goto exit;
0070 
0071     serial = port->serial;
0072     mutex_lock(&serial->disc_mutex);
0073     if (serial->disconnected) {
0074         mutex_unlock(&serial->disc_mutex);
0075         port = NULL;
0076     } else {
0077         kref_get(&serial->kref);
0078     }
0079 exit:
0080     mutex_unlock(&table_lock);
0081     return port;
0082 }
0083 
0084 static int allocate_minors(struct usb_serial *serial, int num_ports)
0085 {
0086     struct usb_serial_port *port;
0087     unsigned int i, j;
0088     int minor;
0089 
0090     dev_dbg(&serial->interface->dev, "%s %d\n", __func__, num_ports);
0091 
0092     mutex_lock(&table_lock);
0093     for (i = 0; i < num_ports; ++i) {
0094         port = serial->port[i];
0095         minor = idr_alloc(&serial_minors, port, 0,
0096                     USB_SERIAL_TTY_MINORS, GFP_KERNEL);
0097         if (minor < 0)
0098             goto error;
0099         port->minor = minor;
0100         port->port_number = i;
0101     }
0102     serial->minors_reserved = 1;
0103     mutex_unlock(&table_lock);
0104     return 0;
0105 error:
0106     /* unwind the already allocated minors */
0107     for (j = 0; j < i; ++j)
0108         idr_remove(&serial_minors, serial->port[j]->minor);
0109     mutex_unlock(&table_lock);
0110     return minor;
0111 }
0112 
0113 static void release_minors(struct usb_serial *serial)
0114 {
0115     int i;
0116 
0117     mutex_lock(&table_lock);
0118     for (i = 0; i < serial->num_ports; ++i)
0119         idr_remove(&serial_minors, serial->port[i]->minor);
0120     mutex_unlock(&table_lock);
0121     serial->minors_reserved = 0;
0122 }
0123 
0124 int usb_serial_claim_interface(struct usb_serial *serial, struct usb_interface *intf)
0125 {
0126     struct usb_driver *driver = serial->type->usb_driver;
0127     int ret;
0128 
0129     if (serial->sibling)
0130         return -EBUSY;
0131 
0132     ret = usb_driver_claim_interface(driver, intf, serial);
0133     if (ret) {
0134         dev_err(&serial->interface->dev,
0135                 "failed to claim sibling interface: %d\n", ret);
0136         return ret;
0137     }
0138 
0139     serial->sibling = intf;
0140 
0141     return 0;
0142 }
0143 EXPORT_SYMBOL_GPL(usb_serial_claim_interface);
0144 
0145 static void release_sibling(struct usb_serial *serial, struct usb_interface *intf)
0146 {
0147     struct usb_driver *driver = serial->type->usb_driver;
0148     struct usb_interface *sibling;
0149 
0150     if (!serial->sibling)
0151         return;
0152 
0153     if (intf == serial->sibling)
0154         sibling = serial->interface;
0155     else
0156         sibling = serial->sibling;
0157 
0158     usb_set_intfdata(sibling, NULL);
0159     usb_driver_release_interface(driver, sibling);
0160 }
0161 
0162 static void destroy_serial(struct kref *kref)
0163 {
0164     struct usb_serial *serial;
0165     struct usb_serial_port *port;
0166     int i;
0167 
0168     serial = to_usb_serial(kref);
0169 
0170     /* return the minor range that this device had */
0171     if (serial->minors_reserved)
0172         release_minors(serial);
0173 
0174     if (serial->attached && serial->type->release)
0175         serial->type->release(serial);
0176 
0177     /* Now that nothing is using the ports, they can be freed */
0178     for (i = 0; i < serial->num_port_pointers; ++i) {
0179         port = serial->port[i];
0180         if (port) {
0181             port->serial = NULL;
0182             put_device(&port->dev);
0183         }
0184     }
0185 
0186     usb_put_intf(serial->interface);
0187     usb_put_dev(serial->dev);
0188     kfree(serial);
0189 }
0190 
0191 void usb_serial_put(struct usb_serial *serial)
0192 {
0193     kref_put(&serial->kref, destroy_serial);
0194 }
0195 
0196 /*****************************************************************************
0197  * Driver tty interface functions
0198  *****************************************************************************/
0199 
0200 /**
0201  * serial_install - install tty
0202  * @driver: the driver (USB in our case)
0203  * @tty: the tty being created
0204  *
0205  * Initialise the termios structure for this tty.  We use the default
0206  * USB serial settings but permit them to be overridden by
0207  * serial->type->init_termios on first open.
0208  *
0209  * This is the first place a new tty gets used.  Hence this is where we
0210  * acquire references to the usb_serial structure and the driver module,
0211  * where we store a pointer to the port.  All these actions are reversed
0212  * in serial_cleanup().
0213  */
0214 static int serial_install(struct tty_driver *driver, struct tty_struct *tty)
0215 {
0216     int idx = tty->index;
0217     struct usb_serial *serial;
0218     struct usb_serial_port *port;
0219     bool init_termios;
0220     int retval = -ENODEV;
0221 
0222     port = usb_serial_port_get_by_minor(idx);
0223     if (!port)
0224         return retval;
0225 
0226     serial = port->serial;
0227     if (!try_module_get(serial->type->driver.owner))
0228         goto err_put_serial;
0229 
0230     init_termios = (driver->termios[idx] == NULL);
0231 
0232     retval = tty_standard_install(driver, tty);
0233     if (retval)
0234         goto err_put_module;
0235 
0236     mutex_unlock(&serial->disc_mutex);
0237 
0238     /* allow the driver to update the initial settings */
0239     if (init_termios && serial->type->init_termios)
0240         serial->type->init_termios(tty);
0241 
0242     tty->driver_data = port;
0243 
0244     return retval;
0245 
0246 err_put_module:
0247     module_put(serial->type->driver.owner);
0248 err_put_serial:
0249     usb_serial_put(serial);
0250     mutex_unlock(&serial->disc_mutex);
0251     return retval;
0252 }
0253 
0254 static int serial_port_activate(struct tty_port *tport, struct tty_struct *tty)
0255 {
0256     struct usb_serial_port *port =
0257         container_of(tport, struct usb_serial_port, port);
0258     struct usb_serial *serial = port->serial;
0259     int retval;
0260 
0261     mutex_lock(&serial->disc_mutex);
0262     if (serial->disconnected) {
0263         retval = -ENODEV;
0264         goto out_unlock;
0265     }
0266 
0267     retval = usb_autopm_get_interface(serial->interface);
0268     if (retval)
0269         goto out_unlock;
0270 
0271     retval = port->serial->type->open(tty, port);
0272     if (retval)
0273         usb_autopm_put_interface(serial->interface);
0274 out_unlock:
0275     mutex_unlock(&serial->disc_mutex);
0276 
0277     if (retval < 0)
0278         retval = usb_translate_errors(retval);
0279 
0280     return retval;
0281 }
0282 
0283 static int serial_open(struct tty_struct *tty, struct file *filp)
0284 {
0285     struct usb_serial_port *port = tty->driver_data;
0286 
0287     dev_dbg(&port->dev, "%s\n", __func__);
0288 
0289     return tty_port_open(&port->port, tty, filp);
0290 }
0291 
0292 /**
0293  * serial_port_shutdown - shut down hardware
0294  * @tport: tty port to shut down
0295  *
0296  * Shut down a USB serial port. Serialized against activate by the
0297  * tport mutex and kept to matching open/close pairs
0298  * of calls by the tty-port initialized flag.
0299  *
0300  * Not called if tty is console.
0301  */
0302 static void serial_port_shutdown(struct tty_port *tport)
0303 {
0304     struct usb_serial_port *port =
0305         container_of(tport, struct usb_serial_port, port);
0306     struct usb_serial_driver *drv = port->serial->type;
0307 
0308     if (drv->close)
0309         drv->close(port);
0310 
0311     usb_autopm_put_interface(port->serial->interface);
0312 }
0313 
0314 static void serial_hangup(struct tty_struct *tty)
0315 {
0316     struct usb_serial_port *port = tty->driver_data;
0317 
0318     dev_dbg(&port->dev, "%s\n", __func__);
0319 
0320     tty_port_hangup(&port->port);
0321 }
0322 
0323 static void serial_close(struct tty_struct *tty, struct file *filp)
0324 {
0325     struct usb_serial_port *port = tty->driver_data;
0326 
0327     dev_dbg(&port->dev, "%s\n", __func__);
0328 
0329     tty_port_close(&port->port, tty, filp);
0330 }
0331 
0332 /**
0333  * serial_cleanup - free resources post close/hangup
0334  * @tty: tty to clean up
0335  *
0336  * Do the resource freeing and refcount dropping for the port.
0337  * Avoid freeing the console.
0338  *
0339  * Called asynchronously after the last tty kref is dropped.
0340  */
0341 static void serial_cleanup(struct tty_struct *tty)
0342 {
0343     struct usb_serial_port *port = tty->driver_data;
0344     struct usb_serial *serial;
0345     struct module *owner;
0346 
0347     dev_dbg(&port->dev, "%s\n", __func__);
0348 
0349     /* The console is magical.  Do not hang up the console hardware
0350      * or there will be tears.
0351      */
0352     if (port->port.console)
0353         return;
0354 
0355     tty->driver_data = NULL;
0356 
0357     serial = port->serial;
0358     owner = serial->type->driver.owner;
0359 
0360     usb_serial_put(serial);
0361     module_put(owner);
0362 }
0363 
0364 static int serial_write(struct tty_struct *tty, const unsigned char *buf,
0365                                 int count)
0366 {
0367     struct usb_serial_port *port = tty->driver_data;
0368     int retval = -ENODEV;
0369 
0370     if (port->serial->dev->state == USB_STATE_NOTATTACHED)
0371         goto exit;
0372 
0373     dev_dbg(&port->dev, "%s - %d byte(s)\n", __func__, count);
0374 
0375     retval = port->serial->type->write(tty, port, buf, count);
0376     if (retval < 0)
0377         retval = usb_translate_errors(retval);
0378 exit:
0379     return retval;
0380 }
0381 
0382 static unsigned int serial_write_room(struct tty_struct *tty)
0383 {
0384     struct usb_serial_port *port = tty->driver_data;
0385 
0386     dev_dbg(&port->dev, "%s\n", __func__);
0387 
0388     return port->serial->type->write_room(tty);
0389 }
0390 
0391 static unsigned int serial_chars_in_buffer(struct tty_struct *tty)
0392 {
0393     struct usb_serial_port *port = tty->driver_data;
0394     struct usb_serial *serial = port->serial;
0395 
0396     dev_dbg(&port->dev, "%s\n", __func__);
0397 
0398     if (serial->disconnected)
0399         return 0;
0400 
0401     return serial->type->chars_in_buffer(tty);
0402 }
0403 
0404 static void serial_wait_until_sent(struct tty_struct *tty, int timeout)
0405 {
0406     struct usb_serial_port *port = tty->driver_data;
0407     struct usb_serial *serial = port->serial;
0408 
0409     dev_dbg(&port->dev, "%s\n", __func__);
0410 
0411     if (!port->serial->type->wait_until_sent)
0412         return;
0413 
0414     mutex_lock(&serial->disc_mutex);
0415     if (!serial->disconnected)
0416         port->serial->type->wait_until_sent(tty, timeout);
0417     mutex_unlock(&serial->disc_mutex);
0418 }
0419 
0420 static void serial_throttle(struct tty_struct *tty)
0421 {
0422     struct usb_serial_port *port = tty->driver_data;
0423 
0424     dev_dbg(&port->dev, "%s\n", __func__);
0425 
0426     if (port->serial->type->throttle)
0427         port->serial->type->throttle(tty);
0428 }
0429 
0430 static void serial_unthrottle(struct tty_struct *tty)
0431 {
0432     struct usb_serial_port *port = tty->driver_data;
0433 
0434     dev_dbg(&port->dev, "%s\n", __func__);
0435 
0436     if (port->serial->type->unthrottle)
0437         port->serial->type->unthrottle(tty);
0438 }
0439 
0440 static int serial_get_serial(struct tty_struct *tty, struct serial_struct *ss)
0441 {
0442     struct usb_serial_port *port = tty->driver_data;
0443     struct tty_port *tport = &port->port;
0444     unsigned int close_delay, closing_wait;
0445 
0446     mutex_lock(&tport->mutex);
0447 
0448     close_delay = jiffies_to_msecs(tport->close_delay) / 10;
0449     closing_wait = tport->closing_wait;
0450     if (closing_wait != ASYNC_CLOSING_WAIT_NONE)
0451         closing_wait = jiffies_to_msecs(closing_wait) / 10;
0452 
0453     ss->line = port->minor;
0454     ss->close_delay = close_delay;
0455     ss->closing_wait = closing_wait;
0456 
0457     if (port->serial->type->get_serial)
0458         port->serial->type->get_serial(tty, ss);
0459 
0460     mutex_unlock(&tport->mutex);
0461 
0462     return 0;
0463 }
0464 
0465 static int serial_set_serial(struct tty_struct *tty, struct serial_struct *ss)
0466 {
0467     struct usb_serial_port *port = tty->driver_data;
0468     struct tty_port *tport = &port->port;
0469     unsigned int close_delay, closing_wait;
0470     int ret = 0;
0471 
0472     close_delay = msecs_to_jiffies(ss->close_delay * 10);
0473     closing_wait = ss->closing_wait;
0474     if (closing_wait != ASYNC_CLOSING_WAIT_NONE)
0475         closing_wait = msecs_to_jiffies(closing_wait * 10);
0476 
0477     mutex_lock(&tport->mutex);
0478 
0479     if (!capable(CAP_SYS_ADMIN)) {
0480         if (close_delay != tport->close_delay ||
0481                 closing_wait != tport->closing_wait) {
0482             ret = -EPERM;
0483             goto out_unlock;
0484         }
0485     }
0486 
0487     if (port->serial->type->set_serial) {
0488         ret = port->serial->type->set_serial(tty, ss);
0489         if (ret)
0490             goto out_unlock;
0491     }
0492 
0493     tport->close_delay = close_delay;
0494     tport->closing_wait = closing_wait;
0495 out_unlock:
0496     mutex_unlock(&tport->mutex);
0497 
0498     return ret;
0499 }
0500 
0501 static int serial_ioctl(struct tty_struct *tty,
0502                     unsigned int cmd, unsigned long arg)
0503 {
0504     struct usb_serial_port *port = tty->driver_data;
0505     int retval = -ENOIOCTLCMD;
0506 
0507     dev_dbg(&port->dev, "%s - cmd 0x%04x\n", __func__, cmd);
0508 
0509     switch (cmd) {
0510     case TIOCMIWAIT:
0511         if (port->serial->type->tiocmiwait)
0512             retval = port->serial->type->tiocmiwait(tty, arg);
0513         break;
0514     default:
0515         if (port->serial->type->ioctl)
0516             retval = port->serial->type->ioctl(tty, cmd, arg);
0517     }
0518 
0519     return retval;
0520 }
0521 
0522 static void serial_set_termios(struct tty_struct *tty, struct ktermios *old)
0523 {
0524     struct usb_serial_port *port = tty->driver_data;
0525 
0526     dev_dbg(&port->dev, "%s\n", __func__);
0527 
0528     if (port->serial->type->set_termios)
0529         port->serial->type->set_termios(tty, port, old);
0530     else
0531         tty_termios_copy_hw(&tty->termios, old);
0532 }
0533 
0534 static int serial_break(struct tty_struct *tty, int break_state)
0535 {
0536     struct usb_serial_port *port = tty->driver_data;
0537 
0538     dev_dbg(&port->dev, "%s\n", __func__);
0539 
0540     if (port->serial->type->break_ctl)
0541         port->serial->type->break_ctl(tty, break_state);
0542 
0543     return 0;
0544 }
0545 
0546 static int serial_proc_show(struct seq_file *m, void *v)
0547 {
0548     struct usb_serial *serial;
0549     struct usb_serial_port *port;
0550     int i;
0551     char tmp[40];
0552 
0553     seq_puts(m, "usbserinfo:1.0 driver:2.0\n");
0554     for (i = 0; i < USB_SERIAL_TTY_MINORS; ++i) {
0555         port = usb_serial_port_get_by_minor(i);
0556         if (port == NULL)
0557             continue;
0558         serial = port->serial;
0559 
0560         seq_printf(m, "%d:", i);
0561         if (serial->type->driver.owner)
0562             seq_printf(m, " module:%s",
0563                 module_name(serial->type->driver.owner));
0564         seq_printf(m, " name:\"%s\"",
0565                 serial->type->description);
0566         seq_printf(m, " vendor:%04x product:%04x",
0567             le16_to_cpu(serial->dev->descriptor.idVendor),
0568             le16_to_cpu(serial->dev->descriptor.idProduct));
0569         seq_printf(m, " num_ports:%d", serial->num_ports);
0570         seq_printf(m, " port:%d", port->port_number);
0571         usb_make_path(serial->dev, tmp, sizeof(tmp));
0572         seq_printf(m, " path:%s", tmp);
0573 
0574         seq_putc(m, '\n');
0575         usb_serial_put(serial);
0576         mutex_unlock(&serial->disc_mutex);
0577     }
0578     return 0;
0579 }
0580 
0581 static int serial_tiocmget(struct tty_struct *tty)
0582 {
0583     struct usb_serial_port *port = tty->driver_data;
0584 
0585     dev_dbg(&port->dev, "%s\n", __func__);
0586 
0587     if (port->serial->type->tiocmget)
0588         return port->serial->type->tiocmget(tty);
0589     return -ENOTTY;
0590 }
0591 
0592 static int serial_tiocmset(struct tty_struct *tty,
0593                 unsigned int set, unsigned int clear)
0594 {
0595     struct usb_serial_port *port = tty->driver_data;
0596 
0597     dev_dbg(&port->dev, "%s\n", __func__);
0598 
0599     if (port->serial->type->tiocmset)
0600         return port->serial->type->tiocmset(tty, set, clear);
0601     return -ENOTTY;
0602 }
0603 
0604 static int serial_get_icount(struct tty_struct *tty,
0605                 struct serial_icounter_struct *icount)
0606 {
0607     struct usb_serial_port *port = tty->driver_data;
0608 
0609     dev_dbg(&port->dev, "%s\n", __func__);
0610 
0611     if (port->serial->type->get_icount)
0612         return port->serial->type->get_icount(tty, icount);
0613     return -ENOTTY;
0614 }
0615 
0616 /*
0617  * We would be calling tty_wakeup here, but unfortunately some line
0618  * disciplines have an annoying habit of calling tty->write from
0619  * the write wakeup callback (e.g. n_hdlc.c).
0620  */
0621 void usb_serial_port_softint(struct usb_serial_port *port)
0622 {
0623     schedule_work(&port->work);
0624 }
0625 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
0626 
0627 static void usb_serial_port_work(struct work_struct *work)
0628 {
0629     struct usb_serial_port *port =
0630         container_of(work, struct usb_serial_port, work);
0631 
0632     tty_port_tty_wakeup(&port->port);
0633 }
0634 
0635 static void usb_serial_port_poison_urbs(struct usb_serial_port *port)
0636 {
0637     int i;
0638 
0639     for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
0640         usb_poison_urb(port->read_urbs[i]);
0641     for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
0642         usb_poison_urb(port->write_urbs[i]);
0643 
0644     usb_poison_urb(port->interrupt_in_urb);
0645     usb_poison_urb(port->interrupt_out_urb);
0646 }
0647 
0648 static void usb_serial_port_unpoison_urbs(struct usb_serial_port *port)
0649 {
0650     int i;
0651 
0652     for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
0653         usb_unpoison_urb(port->read_urbs[i]);
0654     for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i)
0655         usb_unpoison_urb(port->write_urbs[i]);
0656 
0657     usb_unpoison_urb(port->interrupt_in_urb);
0658     usb_unpoison_urb(port->interrupt_out_urb);
0659 }
0660 
0661 static void usb_serial_port_release(struct device *dev)
0662 {
0663     struct usb_serial_port *port = to_usb_serial_port(dev);
0664     int i;
0665 
0666     dev_dbg(dev, "%s\n", __func__);
0667 
0668     usb_free_urb(port->interrupt_in_urb);
0669     usb_free_urb(port->interrupt_out_urb);
0670     for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
0671         usb_free_urb(port->read_urbs[i]);
0672         kfree(port->bulk_in_buffers[i]);
0673     }
0674     for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
0675         usb_free_urb(port->write_urbs[i]);
0676         kfree(port->bulk_out_buffers[i]);
0677     }
0678     kfifo_free(&port->write_fifo);
0679     kfree(port->interrupt_in_buffer);
0680     kfree(port->interrupt_out_buffer);
0681     tty_port_destroy(&port->port);
0682     kfree(port);
0683 }
0684 
0685 static struct usb_serial *create_serial(struct usb_device *dev,
0686                     struct usb_interface *interface,
0687                     struct usb_serial_driver *driver)
0688 {
0689     struct usb_serial *serial;
0690 
0691     serial = kzalloc(sizeof(*serial), GFP_KERNEL);
0692     if (!serial)
0693         return NULL;
0694     serial->dev = usb_get_dev(dev);
0695     serial->type = driver;
0696     serial->interface = usb_get_intf(interface);
0697     kref_init(&serial->kref);
0698     mutex_init(&serial->disc_mutex);
0699     serial->minors_reserved = 0;
0700 
0701     return serial;
0702 }
0703 
0704 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
0705                         struct usb_serial_driver *drv)
0706 {
0707     struct usb_dynid *dynid;
0708 
0709     spin_lock(&drv->dynids.lock);
0710     list_for_each_entry(dynid, &drv->dynids.list, node) {
0711         if (usb_match_one_id(intf, &dynid->id)) {
0712             spin_unlock(&drv->dynids.lock);
0713             return &dynid->id;
0714         }
0715     }
0716     spin_unlock(&drv->dynids.lock);
0717     return NULL;
0718 }
0719 
0720 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
0721                         struct usb_interface *intf)
0722 {
0723     const struct usb_device_id *id;
0724 
0725     id = usb_match_id(intf, drv->id_table);
0726     if (id) {
0727         dev_dbg(&intf->dev, "static descriptor matches\n");
0728         goto exit;
0729     }
0730     id = match_dynamic_id(intf, drv);
0731     if (id)
0732         dev_dbg(&intf->dev, "dynamic descriptor matches\n");
0733 exit:
0734     return id;
0735 }
0736 
0737 /* Caller must hold table_lock */
0738 static struct usb_serial_driver *search_serial_device(
0739                     struct usb_interface *iface)
0740 {
0741     const struct usb_device_id *id = NULL;
0742     struct usb_serial_driver *drv;
0743     struct usb_driver *driver = to_usb_driver(iface->dev.driver);
0744 
0745     /* Check if the usb id matches a known device */
0746     list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
0747         if (drv->usb_driver == driver)
0748             id = get_iface_id(drv, iface);
0749         if (id)
0750             return drv;
0751     }
0752 
0753     return NULL;
0754 }
0755 
0756 static int serial_port_carrier_raised(struct tty_port *port)
0757 {
0758     struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
0759     struct usb_serial_driver *drv = p->serial->type;
0760 
0761     if (drv->carrier_raised)
0762         return drv->carrier_raised(p);
0763     /* No carrier control - don't block */
0764     return 1;
0765 }
0766 
0767 static void serial_port_dtr_rts(struct tty_port *port, int on)
0768 {
0769     struct usb_serial_port *p = container_of(port, struct usb_serial_port, port);
0770     struct usb_serial_driver *drv = p->serial->type;
0771 
0772     if (drv->dtr_rts)
0773         drv->dtr_rts(p, on);
0774 }
0775 
0776 static ssize_t port_number_show(struct device *dev,
0777                 struct device_attribute *attr, char *buf)
0778 {
0779     struct usb_serial_port *port = to_usb_serial_port(dev);
0780 
0781     return sprintf(buf, "%u\n", port->port_number);
0782 }
0783 static DEVICE_ATTR_RO(port_number);
0784 
0785 static struct attribute *usb_serial_port_attrs[] = {
0786     &dev_attr_port_number.attr,
0787     NULL
0788 };
0789 ATTRIBUTE_GROUPS(usb_serial_port);
0790 
0791 static const struct tty_port_operations serial_port_ops = {
0792     .carrier_raised     = serial_port_carrier_raised,
0793     .dtr_rts        = serial_port_dtr_rts,
0794     .activate       = serial_port_activate,
0795     .shutdown       = serial_port_shutdown,
0796 };
0797 
0798 static void store_endpoint(struct usb_serial *serial,
0799                     struct usb_serial_endpoints *epds,
0800                     struct usb_endpoint_descriptor *epd)
0801 {
0802     struct device *dev = &serial->interface->dev;
0803     u8 addr = epd->bEndpointAddress;
0804 
0805     if (usb_endpoint_is_bulk_in(epd)) {
0806         if (epds->num_bulk_in == ARRAY_SIZE(epds->bulk_in))
0807             return;
0808         dev_dbg(dev, "found bulk in endpoint %02x\n", addr);
0809         epds->bulk_in[epds->num_bulk_in++] = epd;
0810     } else if (usb_endpoint_is_bulk_out(epd)) {
0811         if (epds->num_bulk_out == ARRAY_SIZE(epds->bulk_out))
0812             return;
0813         dev_dbg(dev, "found bulk out endpoint %02x\n", addr);
0814         epds->bulk_out[epds->num_bulk_out++] = epd;
0815     } else if (usb_endpoint_is_int_in(epd)) {
0816         if (epds->num_interrupt_in == ARRAY_SIZE(epds->interrupt_in))
0817             return;
0818         dev_dbg(dev, "found interrupt in endpoint %02x\n", addr);
0819         epds->interrupt_in[epds->num_interrupt_in++] = epd;
0820     } else if (usb_endpoint_is_int_out(epd)) {
0821         if (epds->num_interrupt_out == ARRAY_SIZE(epds->interrupt_out))
0822             return;
0823         dev_dbg(dev, "found interrupt out endpoint %02x\n", addr);
0824         epds->interrupt_out[epds->num_interrupt_out++] = epd;
0825     }
0826 }
0827 
0828 static void find_endpoints(struct usb_serial *serial,
0829                     struct usb_serial_endpoints *epds,
0830                     struct usb_interface *intf)
0831 {
0832     struct usb_host_interface *iface_desc;
0833     struct usb_endpoint_descriptor *epd;
0834     unsigned int i;
0835 
0836     iface_desc = intf->cur_altsetting;
0837     for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
0838         epd = &iface_desc->endpoint[i].desc;
0839         store_endpoint(serial, epds, epd);
0840     }
0841 }
0842 
0843 static int setup_port_bulk_in(struct usb_serial_port *port,
0844                     struct usb_endpoint_descriptor *epd)
0845 {
0846     struct usb_serial_driver *type = port->serial->type;
0847     struct usb_device *udev = port->serial->dev;
0848     int buffer_size;
0849     int i;
0850 
0851     buffer_size = max_t(int, type->bulk_in_size, usb_endpoint_maxp(epd));
0852     port->bulk_in_size = buffer_size;
0853     port->bulk_in_endpointAddress = epd->bEndpointAddress;
0854 
0855     for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) {
0856         set_bit(i, &port->read_urbs_free);
0857         port->read_urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
0858         if (!port->read_urbs[i])
0859             return -ENOMEM;
0860         port->bulk_in_buffers[i] = kmalloc(buffer_size, GFP_KERNEL);
0861         if (!port->bulk_in_buffers[i])
0862             return -ENOMEM;
0863         usb_fill_bulk_urb(port->read_urbs[i], udev,
0864                 usb_rcvbulkpipe(udev, epd->bEndpointAddress),
0865                 port->bulk_in_buffers[i], buffer_size,
0866                 type->read_bulk_callback, port);
0867     }
0868 
0869     port->read_urb = port->read_urbs[0];
0870     port->bulk_in_buffer = port->bulk_in_buffers[0];
0871 
0872     return 0;
0873 }
0874 
0875 static int setup_port_bulk_out(struct usb_serial_port *port,
0876                     struct usb_endpoint_descriptor *epd)
0877 {
0878     struct usb_serial_driver *type = port->serial->type;
0879     struct usb_device *udev = port->serial->dev;
0880     int buffer_size;
0881     int i;
0882 
0883     if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
0884         return -ENOMEM;
0885     if (type->bulk_out_size)
0886         buffer_size = type->bulk_out_size;
0887     else
0888         buffer_size = usb_endpoint_maxp(epd);
0889     port->bulk_out_size = buffer_size;
0890     port->bulk_out_endpointAddress = epd->bEndpointAddress;
0891 
0892     for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
0893         set_bit(i, &port->write_urbs_free);
0894         port->write_urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
0895         if (!port->write_urbs[i])
0896             return -ENOMEM;
0897         port->bulk_out_buffers[i] = kmalloc(buffer_size, GFP_KERNEL);
0898         if (!port->bulk_out_buffers[i])
0899             return -ENOMEM;
0900         usb_fill_bulk_urb(port->write_urbs[i], udev,
0901                 usb_sndbulkpipe(udev, epd->bEndpointAddress),
0902                 port->bulk_out_buffers[i], buffer_size,
0903                 type->write_bulk_callback, port);
0904     }
0905 
0906     port->write_urb = port->write_urbs[0];
0907     port->bulk_out_buffer = port->bulk_out_buffers[0];
0908 
0909     return 0;
0910 }
0911 
0912 static int setup_port_interrupt_in(struct usb_serial_port *port,
0913                     struct usb_endpoint_descriptor *epd)
0914 {
0915     struct usb_serial_driver *type = port->serial->type;
0916     struct usb_device *udev = port->serial->dev;
0917     int buffer_size;
0918 
0919     port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
0920     if (!port->interrupt_in_urb)
0921         return -ENOMEM;
0922     buffer_size = usb_endpoint_maxp(epd);
0923     port->interrupt_in_endpointAddress = epd->bEndpointAddress;
0924     port->interrupt_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
0925     if (!port->interrupt_in_buffer)
0926         return -ENOMEM;
0927     usb_fill_int_urb(port->interrupt_in_urb, udev,
0928             usb_rcvintpipe(udev, epd->bEndpointAddress),
0929             port->interrupt_in_buffer, buffer_size,
0930             type->read_int_callback, port,
0931             epd->bInterval);
0932 
0933     return 0;
0934 }
0935 
0936 static int setup_port_interrupt_out(struct usb_serial_port *port,
0937                     struct usb_endpoint_descriptor *epd)
0938 {
0939     struct usb_serial_driver *type = port->serial->type;
0940     struct usb_device *udev = port->serial->dev;
0941     int buffer_size;
0942 
0943     port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
0944     if (!port->interrupt_out_urb)
0945         return -ENOMEM;
0946     buffer_size = usb_endpoint_maxp(epd);
0947     port->interrupt_out_size = buffer_size;
0948     port->interrupt_out_endpointAddress = epd->bEndpointAddress;
0949     port->interrupt_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
0950     if (!port->interrupt_out_buffer)
0951         return -ENOMEM;
0952     usb_fill_int_urb(port->interrupt_out_urb, udev,
0953             usb_sndintpipe(udev, epd->bEndpointAddress),
0954             port->interrupt_out_buffer, buffer_size,
0955             type->write_int_callback, port,
0956             epd->bInterval);
0957 
0958     return 0;
0959 }
0960 
0961 static int usb_serial_probe(struct usb_interface *interface,
0962                    const struct usb_device_id *id)
0963 {
0964     struct device *ddev = &interface->dev;
0965     struct usb_device *dev = interface_to_usbdev(interface);
0966     struct usb_serial *serial = NULL;
0967     struct usb_serial_port *port;
0968     struct usb_serial_endpoints *epds;
0969     struct usb_serial_driver *type = NULL;
0970     int retval;
0971     int i;
0972     int num_ports = 0;
0973     unsigned char max_endpoints;
0974 
0975     mutex_lock(&table_lock);
0976     type = search_serial_device(interface);
0977     if (!type) {
0978         mutex_unlock(&table_lock);
0979         dev_dbg(ddev, "none matched\n");
0980         return -ENODEV;
0981     }
0982 
0983     if (!try_module_get(type->driver.owner)) {
0984         mutex_unlock(&table_lock);
0985         dev_err(ddev, "module get failed, exiting\n");
0986         return -EIO;
0987     }
0988     mutex_unlock(&table_lock);
0989 
0990     serial = create_serial(dev, interface, type);
0991     if (!serial) {
0992         retval = -ENOMEM;
0993         goto err_put_module;
0994     }
0995 
0996     /* if this device type has a probe function, call it */
0997     if (type->probe) {
0998         const struct usb_device_id *id;
0999 
1000         id = get_iface_id(type, interface);
1001         retval = type->probe(serial, id);
1002 
1003         if (retval) {
1004             dev_dbg(ddev, "sub driver rejected device\n");
1005             goto err_release_sibling;
1006         }
1007     }
1008 
1009     /* descriptor matches, let's find the endpoints needed */
1010     epds = kzalloc(sizeof(*epds), GFP_KERNEL);
1011     if (!epds) {
1012         retval = -ENOMEM;
1013         goto err_release_sibling;
1014     }
1015 
1016     find_endpoints(serial, epds, interface);
1017     if (serial->sibling)
1018         find_endpoints(serial, epds, serial->sibling);
1019 
1020     if (epds->num_bulk_in < type->num_bulk_in ||
1021             epds->num_bulk_out < type->num_bulk_out ||
1022             epds->num_interrupt_in < type->num_interrupt_in ||
1023             epds->num_interrupt_out < type->num_interrupt_out) {
1024         dev_err(ddev, "required endpoints missing\n");
1025         retval = -ENODEV;
1026         goto err_free_epds;
1027     }
1028 
1029     if (type->calc_num_ports) {
1030         retval = type->calc_num_ports(serial, epds);
1031         if (retval < 0)
1032             goto err_free_epds;
1033         num_ports = retval;
1034     }
1035 
1036     if (!num_ports)
1037         num_ports = type->num_ports;
1038 
1039     if (num_ports > MAX_NUM_PORTS) {
1040         dev_warn(ddev, "too many ports requested: %d\n", num_ports);
1041         num_ports = MAX_NUM_PORTS;
1042     }
1043 
1044     serial->num_ports = (unsigned char)num_ports;
1045     serial->num_bulk_in = epds->num_bulk_in;
1046     serial->num_bulk_out = epds->num_bulk_out;
1047     serial->num_interrupt_in = epds->num_interrupt_in;
1048     serial->num_interrupt_out = epds->num_interrupt_out;
1049 
1050     /* found all that we need */
1051     dev_info(ddev, "%s converter detected\n", type->description);
1052 
1053     /* create our ports, we need as many as the max endpoints */
1054     /* we don't use num_ports here because some devices have more
1055        endpoint pairs than ports */
1056     max_endpoints = max(epds->num_bulk_in, epds->num_bulk_out);
1057     max_endpoints = max(max_endpoints, epds->num_interrupt_in);
1058     max_endpoints = max(max_endpoints, epds->num_interrupt_out);
1059     max_endpoints = max(max_endpoints, serial->num_ports);
1060     serial->num_port_pointers = max_endpoints;
1061 
1062     dev_dbg(ddev, "setting up %d port structure(s)\n", max_endpoints);
1063     for (i = 0; i < max_endpoints; ++i) {
1064         port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
1065         if (!port) {
1066             retval = -ENOMEM;
1067             goto err_free_epds;
1068         }
1069         tty_port_init(&port->port);
1070         port->port.ops = &serial_port_ops;
1071         port->serial = serial;
1072         spin_lock_init(&port->lock);
1073         /* Keep this for private driver use for the moment but
1074            should probably go away */
1075         INIT_WORK(&port->work, usb_serial_port_work);
1076         serial->port[i] = port;
1077         port->dev.parent = &interface->dev;
1078         port->dev.driver = NULL;
1079         port->dev.bus = &usb_serial_bus_type;
1080         port->dev.release = &usb_serial_port_release;
1081         port->dev.groups = usb_serial_port_groups;
1082         device_initialize(&port->dev);
1083     }
1084 
1085     /* set up the endpoint information */
1086     for (i = 0; i < epds->num_bulk_in; ++i) {
1087         retval = setup_port_bulk_in(serial->port[i], epds->bulk_in[i]);
1088         if (retval)
1089             goto err_free_epds;
1090     }
1091 
1092     for (i = 0; i < epds->num_bulk_out; ++i) {
1093         retval = setup_port_bulk_out(serial->port[i],
1094                 epds->bulk_out[i]);
1095         if (retval)
1096             goto err_free_epds;
1097     }
1098 
1099     if (serial->type->read_int_callback) {
1100         for (i = 0; i < epds->num_interrupt_in; ++i) {
1101             retval = setup_port_interrupt_in(serial->port[i],
1102                     epds->interrupt_in[i]);
1103             if (retval)
1104                 goto err_free_epds;
1105         }
1106     } else if (epds->num_interrupt_in) {
1107         dev_dbg(ddev, "The device claims to support interrupt in transfers, but read_int_callback is not defined\n");
1108     }
1109 
1110     if (serial->type->write_int_callback) {
1111         for (i = 0; i < epds->num_interrupt_out; ++i) {
1112             retval = setup_port_interrupt_out(serial->port[i],
1113                     epds->interrupt_out[i]);
1114             if (retval)
1115                 goto err_free_epds;
1116         }
1117     } else if (epds->num_interrupt_out) {
1118         dev_dbg(ddev, "The device claims to support interrupt out transfers, but write_int_callback is not defined\n");
1119     }
1120 
1121     usb_set_intfdata(interface, serial);
1122 
1123     /* if this device type has an attach function, call it */
1124     if (type->attach) {
1125         retval = type->attach(serial);
1126         if (retval < 0)
1127             goto err_free_epds;
1128         serial->attached = 1;
1129         if (retval > 0) {
1130             /* quietly accept this device, but don't bind to a
1131                serial port as it's about to disappear */
1132             serial->num_ports = 0;
1133             goto exit;
1134         }
1135     } else {
1136         serial->attached = 1;
1137     }
1138 
1139     retval = allocate_minors(serial, num_ports);
1140     if (retval) {
1141         dev_err(ddev, "No more free serial minor numbers\n");
1142         goto err_free_epds;
1143     }
1144 
1145     /* register all of the individual ports with the driver core */
1146     for (i = 0; i < num_ports; ++i) {
1147         port = serial->port[i];
1148         dev_set_name(&port->dev, "ttyUSB%d", port->minor);
1149         dev_dbg(ddev, "registering %s\n", dev_name(&port->dev));
1150         device_enable_async_suspend(&port->dev);
1151 
1152         retval = device_add(&port->dev);
1153         if (retval)
1154             dev_err(ddev, "Error registering port device, continuing\n");
1155     }
1156 
1157     if (num_ports > 0)
1158         usb_serial_console_init(serial->port[0]->minor);
1159 exit:
1160     kfree(epds);
1161     module_put(type->driver.owner);
1162     return 0;
1163 
1164 err_free_epds:
1165     kfree(epds);
1166 err_release_sibling:
1167     release_sibling(serial, interface);
1168     usb_serial_put(serial);
1169 err_put_module:
1170     module_put(type->driver.owner);
1171 
1172     return retval;
1173 }
1174 
1175 static void usb_serial_disconnect(struct usb_interface *interface)
1176 {
1177     int i;
1178     struct usb_serial *serial = usb_get_intfdata(interface);
1179     struct device *dev = &interface->dev;
1180     struct usb_serial_port *port;
1181     struct tty_struct *tty;
1182 
1183     /* sibling interface is cleaning up */
1184     if (!serial)
1185         return;
1186 
1187     usb_serial_console_disconnect(serial);
1188 
1189     mutex_lock(&serial->disc_mutex);
1190     /* must set a flag, to signal subdrivers */
1191     serial->disconnected = 1;
1192     mutex_unlock(&serial->disc_mutex);
1193 
1194     for (i = 0; i < serial->num_ports; ++i) {
1195         port = serial->port[i];
1196         tty = tty_port_tty_get(&port->port);
1197         if (tty) {
1198             tty_vhangup(tty);
1199             tty_kref_put(tty);
1200         }
1201         usb_serial_port_poison_urbs(port);
1202         wake_up_interruptible(&port->port.delta_msr_wait);
1203         cancel_work_sync(&port->work);
1204         if (device_is_registered(&port->dev))
1205             device_del(&port->dev);
1206     }
1207     if (serial->type->disconnect)
1208         serial->type->disconnect(serial);
1209 
1210     release_sibling(serial, interface);
1211 
1212     /* let the last holder of this object cause it to be cleaned up */
1213     usb_serial_put(serial);
1214     dev_info(dev, "device disconnected\n");
1215 }
1216 
1217 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1218 {
1219     struct usb_serial *serial = usb_get_intfdata(intf);
1220     int i, r;
1221 
1222     /* suspend when called for first sibling interface */
1223     if (serial->suspend_count++)
1224         return 0;
1225 
1226     /*
1227      * serial->type->suspend() MUST return 0 in system sleep context,
1228      * otherwise, the resume callback has to recover device from
1229      * previous suspend failure.
1230      */
1231     if (serial->type->suspend) {
1232         r = serial->type->suspend(serial, message);
1233         if (r < 0) {
1234             serial->suspend_count--;
1235             return r;
1236         }
1237     }
1238 
1239     for (i = 0; i < serial->num_ports; ++i)
1240         usb_serial_port_poison_urbs(serial->port[i]);
1241 
1242     return 0;
1243 }
1244 EXPORT_SYMBOL(usb_serial_suspend);
1245 
1246 static void usb_serial_unpoison_port_urbs(struct usb_serial *serial)
1247 {
1248     int i;
1249 
1250     for (i = 0; i < serial->num_ports; ++i)
1251         usb_serial_port_unpoison_urbs(serial->port[i]);
1252 }
1253 
1254 int usb_serial_resume(struct usb_interface *intf)
1255 {
1256     struct usb_serial *serial = usb_get_intfdata(intf);
1257     int rv;
1258 
1259     /* resume when called for last sibling interface */
1260     if (--serial->suspend_count)
1261         return 0;
1262 
1263     usb_serial_unpoison_port_urbs(serial);
1264 
1265     if (serial->type->resume)
1266         rv = serial->type->resume(serial);
1267     else
1268         rv = usb_serial_generic_resume(serial);
1269 
1270     return rv;
1271 }
1272 EXPORT_SYMBOL(usb_serial_resume);
1273 
1274 static int usb_serial_reset_resume(struct usb_interface *intf)
1275 {
1276     struct usb_serial *serial = usb_get_intfdata(intf);
1277     int rv;
1278 
1279     /* resume when called for last sibling interface */
1280     if (--serial->suspend_count)
1281         return 0;
1282 
1283     usb_serial_unpoison_port_urbs(serial);
1284 
1285     if (serial->type->reset_resume) {
1286         rv = serial->type->reset_resume(serial);
1287     } else {
1288         rv = -EOPNOTSUPP;
1289         intf->needs_binding = 1;
1290     }
1291 
1292     return rv;
1293 }
1294 
1295 static const struct tty_operations serial_ops = {
1296     .open =         serial_open,
1297     .close =        serial_close,
1298     .write =        serial_write,
1299     .hangup =       serial_hangup,
1300     .write_room =       serial_write_room,
1301     .ioctl =        serial_ioctl,
1302     .set_termios =      serial_set_termios,
1303     .throttle =     serial_throttle,
1304     .unthrottle =       serial_unthrottle,
1305     .break_ctl =        serial_break,
1306     .chars_in_buffer =  serial_chars_in_buffer,
1307     .wait_until_sent =  serial_wait_until_sent,
1308     .tiocmget =     serial_tiocmget,
1309     .tiocmset =     serial_tiocmset,
1310     .get_icount =       serial_get_icount,
1311     .set_serial =       serial_set_serial,
1312     .get_serial =       serial_get_serial,
1313     .cleanup =      serial_cleanup,
1314     .install =      serial_install,
1315     .proc_show =        serial_proc_show,
1316 };
1317 
1318 
1319 struct tty_driver *usb_serial_tty_driver;
1320 
1321 static int __init usb_serial_init(void)
1322 {
1323     int result;
1324 
1325     usb_serial_tty_driver = tty_alloc_driver(USB_SERIAL_TTY_MINORS,
1326             TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV);
1327     if (IS_ERR(usb_serial_tty_driver))
1328         return PTR_ERR(usb_serial_tty_driver);
1329 
1330     /* Initialize our global data */
1331     result = bus_register(&usb_serial_bus_type);
1332     if (result) {
1333         pr_err("%s - registering bus driver failed\n", __func__);
1334         goto err_put_driver;
1335     }
1336 
1337     usb_serial_tty_driver->driver_name = "usbserial";
1338     usb_serial_tty_driver->name = "ttyUSB";
1339     usb_serial_tty_driver->major = USB_SERIAL_TTY_MAJOR;
1340     usb_serial_tty_driver->minor_start = 0;
1341     usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1342     usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1343     usb_serial_tty_driver->init_termios = tty_std_termios;
1344     usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1345                             | HUPCL | CLOCAL;
1346     usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1347     usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1348     tty_set_operations(usb_serial_tty_driver, &serial_ops);
1349     result = tty_register_driver(usb_serial_tty_driver);
1350     if (result) {
1351         pr_err("%s - tty_register_driver failed\n", __func__);
1352         goto err_unregister_bus;
1353     }
1354 
1355     /* register the generic driver, if we should */
1356     result = usb_serial_generic_register();
1357     if (result < 0) {
1358         pr_err("%s - registering generic driver failed\n", __func__);
1359         goto err_unregister_driver;
1360     }
1361 
1362     return result;
1363 
1364 err_unregister_driver:
1365     tty_unregister_driver(usb_serial_tty_driver);
1366 err_unregister_bus:
1367     bus_unregister(&usb_serial_bus_type);
1368 err_put_driver:
1369     pr_err("%s - returning with error %d\n", __func__, result);
1370     tty_driver_kref_put(usb_serial_tty_driver);
1371     return result;
1372 }
1373 
1374 
1375 static void __exit usb_serial_exit(void)
1376 {
1377     usb_serial_console_exit();
1378 
1379     usb_serial_generic_deregister();
1380 
1381     tty_unregister_driver(usb_serial_tty_driver);
1382     tty_driver_kref_put(usb_serial_tty_driver);
1383     bus_unregister(&usb_serial_bus_type);
1384     idr_destroy(&serial_minors);
1385 }
1386 
1387 
1388 module_init(usb_serial_init);
1389 module_exit(usb_serial_exit);
1390 
1391 #define set_to_generic_if_null(type, function)              \
1392     do {                                \
1393         if (!type->function) {                  \
1394             type->function = usb_serial_generic_##function; \
1395             pr_debug("%s: using generic " #function "\n",   \
1396                         type->driver.name); \
1397         }                           \
1398     } while (0)
1399 
1400 static void usb_serial_operations_init(struct usb_serial_driver *device)
1401 {
1402     set_to_generic_if_null(device, open);
1403     set_to_generic_if_null(device, write);
1404     set_to_generic_if_null(device, close);
1405     set_to_generic_if_null(device, write_room);
1406     set_to_generic_if_null(device, chars_in_buffer);
1407     if (device->tx_empty)
1408         set_to_generic_if_null(device, wait_until_sent);
1409     set_to_generic_if_null(device, read_bulk_callback);
1410     set_to_generic_if_null(device, write_bulk_callback);
1411     set_to_generic_if_null(device, process_read_urb);
1412     set_to_generic_if_null(device, prepare_write_buffer);
1413 }
1414 
1415 static int usb_serial_register(struct usb_serial_driver *driver)
1416 {
1417     int retval;
1418 
1419     if (usb_disabled())
1420         return -ENODEV;
1421 
1422     if (!driver->description)
1423         driver->description = driver->driver.name;
1424     if (!driver->usb_driver) {
1425         WARN(1, "Serial driver %s has no usb_driver\n",
1426                 driver->description);
1427         return -EINVAL;
1428     }
1429 
1430     /* Prevent individual ports from being unbound. */
1431     driver->driver.suppress_bind_attrs = true;
1432 
1433     usb_serial_operations_init(driver);
1434 
1435     /* Add this device to our list of devices */
1436     mutex_lock(&table_lock);
1437     list_add(&driver->driver_list, &usb_serial_driver_list);
1438 
1439     retval = usb_serial_bus_register(driver);
1440     if (retval) {
1441         pr_err("problem %d when registering driver %s\n", retval, driver->description);
1442         list_del(&driver->driver_list);
1443     } else {
1444         pr_info("USB Serial support registered for %s\n", driver->description);
1445     }
1446     mutex_unlock(&table_lock);
1447     return retval;
1448 }
1449 
1450 static void usb_serial_deregister(struct usb_serial_driver *device)
1451 {
1452     pr_info("USB Serial deregistering driver %s\n", device->description);
1453 
1454     mutex_lock(&table_lock);
1455     list_del(&device->driver_list);
1456     mutex_unlock(&table_lock);
1457 
1458     usb_serial_bus_deregister(device);
1459 }
1460 
1461 /**
1462  * usb_serial_register_drivers - register drivers for a usb-serial module
1463  * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
1464  * @name: name of the usb_driver for this set of @serial_drivers
1465  * @id_table: list of all devices this @serial_drivers set binds to
1466  *
1467  * Registers all the drivers in the @serial_drivers array, and dynamically
1468  * creates a struct usb_driver with the name @name and id_table of @id_table.
1469  */
1470 int usb_serial_register_drivers(struct usb_serial_driver *const serial_drivers[],
1471                 const char *name,
1472                 const struct usb_device_id *id_table)
1473 {
1474     int rc;
1475     struct usb_driver *udriver;
1476     struct usb_serial_driver * const *sd;
1477 
1478     /*
1479      * udriver must be registered before any of the serial drivers,
1480      * because the store_new_id() routine for the serial drivers (in
1481      * bus.c) probes udriver.
1482      *
1483      * Performance hack: We don't want udriver to be probed until
1484      * the serial drivers are registered, because the probe would
1485      * simply fail for lack of a matching serial driver.
1486      * So we leave udriver's id_table set to NULL until we are all set.
1487      *
1488      * Suspend/resume support is implemented in the usb-serial core,
1489      * so fill in the PM-related fields in udriver.
1490      */
1491     udriver = kzalloc(sizeof(*udriver), GFP_KERNEL);
1492     if (!udriver)
1493         return -ENOMEM;
1494 
1495     udriver->name = name;
1496     udriver->no_dynamic_id = 1;
1497     udriver->supports_autosuspend = 1;
1498     udriver->suspend = usb_serial_suspend;
1499     udriver->resume = usb_serial_resume;
1500     udriver->probe = usb_serial_probe;
1501     udriver->disconnect = usb_serial_disconnect;
1502 
1503     /* we only set the reset_resume field if the serial_driver has one */
1504     for (sd = serial_drivers; *sd; ++sd) {
1505         if ((*sd)->reset_resume) {
1506             udriver->reset_resume = usb_serial_reset_resume;
1507             break;
1508         }
1509     }
1510 
1511     rc = usb_register(udriver);
1512     if (rc)
1513         goto err_free_driver;
1514 
1515     for (sd = serial_drivers; *sd; ++sd) {
1516         (*sd)->usb_driver = udriver;
1517         rc = usb_serial_register(*sd);
1518         if (rc)
1519             goto err_deregister_drivers;
1520     }
1521 
1522     /* Now set udriver's id_table and look for matches */
1523     udriver->id_table = id_table;
1524     rc = driver_attach(&udriver->drvwrap.driver);
1525     return 0;
1526 
1527 err_deregister_drivers:
1528     while (sd-- > serial_drivers)
1529         usb_serial_deregister(*sd);
1530     usb_deregister(udriver);
1531 err_free_driver:
1532     kfree(udriver);
1533     return rc;
1534 }
1535 EXPORT_SYMBOL_GPL(usb_serial_register_drivers);
1536 
1537 /**
1538  * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
1539  * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
1540  *
1541  * Deregisters all the drivers in the @serial_drivers array and deregisters and
1542  * frees the struct usb_driver that was created by the call to
1543  * usb_serial_register_drivers().
1544  */
1545 void usb_serial_deregister_drivers(struct usb_serial_driver *const serial_drivers[])
1546 {
1547     struct usb_driver *udriver = (*serial_drivers)->usb_driver;
1548 
1549     for (; *serial_drivers; ++serial_drivers)
1550         usb_serial_deregister(*serial_drivers);
1551     usb_deregister(udriver);
1552     kfree(udriver);
1553 }
1554 EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);
1555 
1556 MODULE_AUTHOR(DRIVER_AUTHOR);
1557 MODULE_DESCRIPTION(DRIVER_DESC);
1558 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!