Linux的USB-Serial 代码跟踪

我们在Linux dev目录看到的ttyUSB*一系列的终端，这些读写在Linux底层是如何处理的呢？

首先看USB serial 核心层，kernel\drivers\usb\serial\usb-serial.c文件里面实现

static int __init usb_serial_init(void)
{
int i;
int result;


usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS); //也是注册了tty设备
if (!usb_serial_tty_driver)
return -ENOMEM;


/* Initialize our global data */
for (i = 0; i < SERIAL_TTY_MINORS; ++i)
serial_table[i] = NULL;


result = bus_register(&usb_serial_bus_type);
if (result) {
printk(KERN_ERR "usb-serial: %s - registering bus driver "
      "failed\n", __func__);
goto exit_bus;
}


usb_serial_tty_driver->driver_name = "usbserial";
usb_serial_tty_driver->name = "ttyUSB";//子Linux终端下面看到的名字
usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
usb_serial_tty_driver->minor_start = 1;
usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
TTY_DRIVER_DYNAMIC_DEV;
usb_serial_tty_driver->init_termios = tty_std_termios;
usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
| HUPCL | CLOCAL;
usb_serial_tty_driver->init_termios.c_ispeed = 9600;
usb_serial_tty_driver->init_termios.c_ospeed = 9600;
tty_set_operations(usb_serial_tty_driver, &serial_ops); //serial_ops 这函数操作集合，抽象了底层读写操作

result = tty_register_driver(usb_serial_tty_driver);
if (result) {
printk(KERN_ERR "usb-serial: %s - tty_register_driver failed\n",
      __func__);
goto exit_reg_driver;
}


/* register the USB driver */
result = usb_register(&usb_serial_driver);
if (result < 0) {
printk(KERN_ERR "usb-serial: %s - usb_register failed\n",
      __func__);
goto exit_tty;
}


/* register the generic driver, if we should */
result = usb_serial_generic_register(debug);
if (result < 0) {
printk(KERN_ERR "usb-serial: %s - registering generic "
      "driver failed\n", __func__);
goto exit_generic;
}


printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_DESC "\n");


return result;


exit_generic:
usb_deregister(&usb_serial_driver);


exit_tty:
tty_unregister_driver(usb_serial_tty_driver);


exit_reg_driver:
bus_unregister(&usb_serial_bus_type);


exit_bus:
printk(KERN_ERR "usb-serial: %s - returning with error %d\n",
      __func__, result);
put_tty_driver(usb_serial_tty_driver);
return result;
}

serial_ops主要抽象了方法集合有：

static const struct tty_operations serial_ops = {
.open = serial_open,
.close = serial_close,
.write = serial_write,
.hangup = serial_hangup,
.write_room = serial_write_room,
.ioctl = serial_ioctl,
.set_termios = serial_set_termios,
.throttle = serial_throttle,
.unthrottle = serial_unthrottle,
.break_ctl = serial_break,
.chars_in_buffer = serial_chars_in_buffer,
.tiocmget = serial_tiocmget,
.tiocmset = serial_tiocmset,
.get_icount = serial_get_icount,
.cleanup = serial_cleanup,
.install = serial_install,
.proc_fops = &serial_proc_fops,
};

我们来典型分析一下这个两个函数：

static int serial_write(struct tty_struct *tty, const unsigned char *buf,
int count)
{
struct usb_serial_port *port = tty->driver_data;
int retval = -ENODEV;


if (port->serial->dev->state == USB_STATE_NOTATTACHED)
goto exit;


dbg("%s - port %d, %d byte(s)", __func__, port->number, count);


/* pass on to the driver specific version of this function */
retval = port->serial->type->write(tty, port, buf, count); //通过函数指针从这里write数据到底层
if (retval < 0)
retval = usb_translate_errors(retval);
exit:
return retval;
}

读函数对于tty设备来说比较，通过tty核心层的读缓存，底层往上送数据，tty层往上读，它们维护了一个缓冲队列

看接口serial_chars_in_buffer

static int serial_chars_in_buffer(struct tty_struct *tty)
{
struct usb_serial_port *port = tty->driver_data;
dbg("%s - port %d", __func__, port->number);


/* if the device was unplugged then any remaining characters
  fell out of the connector ;) */
if (port->serial->disconnected)
return 0;
/* pass on to the driver specific version of this function */
return port->serial->type->chars_in_buffer(tty);
}

跑到这里USB serial核心层就算注册好接下来就是用一栗子来说明如何向核心层注册

看到kernel\drivers\usb\serial\opticon.c文件

static struct usb_driver opticon_driver = {
.name = "opticon",
.probe = usb_serial_probe,
.disconnect = usb_serial_disconnect,
.suspend = opticon_suspend,
.resume = opticon_resume,
.id_table = id_table,
};


static struct usb_serial_driver opticon_device = {
.driver = {
.owner = THIS_MODULE,
.name = "opticon",
},
.id_table = id_table,
.num_ports = 1,
.attach = opticon_startup,
.open = opticon_open,
.close = opticon_close,
.write = opticon_write,
.write_room = opticon_write_room,
.disconnect = opticon_disconnect,
.release = opticon_release,
.throttle = opticon_throttle,
.unthrottle = opticon_unthrottle,
.ioctl = opticon_ioctl,
.tiocmget = opticon_tiocmget,
.tiocmset = opticon_tiocmset,
};


static struct usb_serial_driver * const serial_drivers[] = {
&opticon_device, NULL
};

module_usb_serial_driver(opticon_driver, serial_drivers);

找到这个宏通过宏展开我们知道

/*
 * module_usb_serial_driver() - Helper macro for registering a USB Serial driver
 * @__usb_driver: usb_driver struct to register
 * @__serial_drivers: list of usb_serial drivers to register
 *
 * Helper macro for USB serial drivers which do not do anything special
 * in module init/exit. This eliminates a lot of boilerplate. Each
 * module may only use this macro once, and calling it replaces
 * module_init() and module_exit()
 *
 */
#define module_usb_serial_driver(__usb_driver, __serial_drivers) \
module_driver(__usb_driver, usb_serial_register_drivers, \
      usb_serial_deregister_drivers, __serial_drivers)

/**
 * module_driver() - Helper macro for drivers that don't do anything
 * special in module init/exit. This eliminates a lot of boilerplate.
 * Each module may only use this macro once, and calling it replaces
 * module_init() and module_exit().
 *
 * @__driver: driver name
 * @__register: register function for this driver type
 * @__unregister: unregister function for this driver type
 * @...: Additional arguments to be passed to __register and __unregister.
 *
 * Use this macro to construct bus specific macros for registering
 * drivers, and do not use it on its own.
 */
#define module_driver(__driver, __register, __unregister, ...) \
static int __init __driver##_init(void) \
{ \
return __register(&(__driver) , ##__VA_ARGS__); \
} \
module_init(__driver##_init); \
static void __exit __driver##_exit(void) \
{ \
__unregister(&(__driver) , ##__VA_ARGS__); \
} \
module_exit(__driver##_exit);

惊喜吧，看到这里，是那么亲切，是我们的module_init(__driver##_init); opticon_driver 是标准USB驱动接口，serial_drivers是USB serial标准的操作集合，有了这两个后，如何绑定他们在一起干活呢？

这个桥梁就是usb_serial_register_drivers，usb_serial_deregister_drivers一个是注册一个注销。

原型是

/**
 * usb_serial_register_drivers - register drivers for a usb-serial module
 * @udriver: usb_driver used for matching devices/interfaces
 * @serial_drivers: NULL-terminated array of pointers to drivers to be registered
 *
 * Registers @udriver and all the drivers in the @serial_drivers array.
 * Automatically fills in the .no_dynamic_id and PM fields in @udriver and
 * the .usb_driver field in each serial driver.
 */
int usb_serial_register_drivers(struct usb_driver *udriver,
struct usb_serial_driver * const serial_drivers[])
{
int rc;
const struct usb_device_id *saved_id_table;
struct usb_serial_driver * const *sd;


/*
* udriver must be registered before any of the serial drivers,
* because the store_new_id() routine for the serial drivers (in
* bus.c) probes udriver.
*
* Performance hack: We don't want udriver to be probed until
* the serial drivers are registered, because the probe would
* simply fail for lack of a matching serial driver.
* Therefore save off udriver's id_table until we are all set.
*
* Suspend/resume support is implemented in the usb-serial core,
* so fill in the PM-related fields in udriver.
*/
saved_id_table = udriver->id_table;
udriver->id_table = NULL;


udriver->no_dynamic_id = 1;
udriver->supports_autosuspend = 1;
udriver->suspend = usb_serial_suspend;
udriver->resume = usb_serial_resume;
rc = usb_register(udriver);//注册标准USB驱动
if (rc)
return rc;


for (sd = serial_drivers; *sd; ++sd) {
(*sd)->usb_driver = udriver;
rc = usb_serial_register(*sd);//向USB serial 注册操作集合，也是就USBserial底层传递上来的指针opticon_device 
if (rc)
goto failed;
}


/* Now restore udriver's id_table and look for matches */
udriver->id_table = saved_id_table;
rc = driver_attach(&udriver->drvwrap.driver);
return 0;


 failed:
while (sd-- > serial_drivers)
usb_serial_deregister(*sd);
usb_deregister(udriver);
return rc;
}
EXPORT_SYMBOL_GPL(usb_serial_register_drivers);


/**
 * usb_serial_deregister_drivers - deregister drivers for a usb-serial module
 * @udriver: usb_driver to unregister
 * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered
 *
 * Deregisters @udriver and all the drivers in the @serial_drivers array.
 */
void usb_serial_deregister_drivers(struct usb_driver *udriver,
struct usb_serial_driver * const serial_drivers[])
{
for (; *serial_drivers; ++serial_drivers)
usb_serial_deregister(*serial_drivers);
usb_deregister(udriver);
}
EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers);

到此USB serial层应用结束。我们在终端cat echo ttyUSB*这些终端的时候，就回调用到读写函数来。