usb
通用 USB 设备驱动源码分析
Author:aaron
前段时间写了篇 <qualcomm usb modem 驱动小结 > 的文章 , 描述了自己如何为高通的一个 usb modem 设备写驱动的过程 , 最近发现实际上可以 使用 linux 自带的一个叫 usbserial 的模块作为这个 modem 的驱动并能良好的工作 , 所以写了这片文章来详细的分析下 usbserial 模块的 源码 (2.6.16.3).
应该来说 , 对于那些仅仅是用 USB 来通信 , 在上层可看作 tty 设备 , 不属于任何 USB 设备类型 , 没有什么流控等的普 通 USB 设备来说都可以使用这个驱动来作为设备驱动程序 . 下面就来对这样一种通用的驱动程序来进行详细的分析 . 不对之处敬请指正 !
为了能让 usbserail 模块支持我的设备 , 我必须在命令行上输 入如下命令 :
sudo modprobe usbserial vendor=0x12d1 product=0x1003
该命令用特权用户来加载 usbserial 模块 , 并把该模块依赖的模块一并加 载进系统 , 同时它还设置了 usbserial 的两个参数 : vendor, product, 很显 然这两个参数是厂商 ID 和设备 ID, 而作用就是用于匹配设备 .
首先 , 当然是要知道 usbserial 模块由哪些文 件编译而成 , 这样才能有目的性的去分析其代码 . 而要知道其组成当然是去其目录下看 Makefile 了 , 它位于内核源码目录下的 ./drivers/usb/serial/ 下
./drivers/usb/serial/Makefile:
#
# Makefile for the USB serial device drivers.
#
# Object file lists.
obj-$(CONFIG_USB_SERIAL) += usbserial.o # 编译内核时如何编译该模块
usbserial-obj-$(CONFIG_USB_SERIAL_CONSOLE) += console.o
usbserial-obj-$(CONFIG_USB_EZUSB) += ezusb.o
usbserial-objs := usb-serial.o generic.o bus.o $(usbserial-obj-y) #OK, 就是 usbserial 模块的组成了 .
obj-$(CONFIG_USB_SERIAL_AIRPRIME) += airprime.o
obj-$(CONFIG_USB_SERIAL_ANYDATA) += anydata.o
.......
我们重点看的是 usb-serial.c, generic.c, bus.c
在看源码之前我们先说说该模块的原理及整体结构 :
很简单跟应用层交互的是一个 tty 设备 , 也就是说该模块把 USB 设备映射成一个 tty 设备 ( 即在 /dev/ 目录下为该 USB 设备创建一个 tty 设备文件 ), 然后用于可以用 minicom 之类的串口工具 来打开这个设备 , 并同设备端的设备通信 .
对于发送过程 : tty 设备文件在获取了用户要求发送的数据之后 传递到下层 usbserial 模块的核心层 , 而该核心层就是将数据打包成 USB 格式的数据并由 USB 通信发送到设备端去 ,
对于接收过程 : usbserial 模块会在该设备打开时就启动 一个 urb 在那等待设备端发数据过来 , 收到数据后就 push 到上层 tty 设备的缓冲中去 , 而 tty 设备在收到数据后就会给用户 , 或直接显示在 minicom 之类的工具上 .
usb-serial.c 就是 usbserial 模块的核心 , 它主要用来接收设备端发来的数据并传送到上层 , 同时也接收来自上层应用的数据 , 并组装成 urb 包发送给设备 .
generic.c 对特定设备单独的操作 , 相当于是设备自己的驱动程序 , 由于很多设备具有通用性 , 所以对于没有特殊要求的设备都可以使用这个驱动 来作为自己设备的驱动程序 . 它有两个参数 vendor 和 product, 上面提过了 .
bus.c 每个 usb 驱动和设备都必须要归入某一条总线上 , 即都是归属于某条总线的 , 只有这样系统才能从特定一条 总线开始找到每个驱动和设备并为他们匹配 . 这个文件就是用来模拟一条总线 , 而 usbserial 的每个驱动和设备都会注册到这条总线上来 .
好了 , 是时候分析 usbserial 模块了 .
我们知道当把一个模块加载进系统时会调用这个模块里的一个由 module_init() 声 明的一个初始化函数 . usbserial 当然也不另外 ,
usb-serial.c:
module_init(usb_serial_init);
module_exit(usb_serial_exit);
没错加载时调用的就是 : usb_serial_init().
usb-serial.c:
struct tty_driver *usb_serial_tty_driver;
static int __init usb_serial_init(void)
{
int i;
int result;
// 创建一个 tty_driver 对象 , 对应的就是 tty 设备的驱动 .
usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
if (!usb_serial_tty_driver)
return -ENOMEM;
/* Initialize our global data */
for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
serial_table[i] = NULL; // 该 模块共支持 SERIAL_TTY_MINORS 个该类型设备 .
}
result = bus_register(&usb_serial_bus_type); // 注册这条 serial bus.
if (result) {
err("%s - registering bus driver failed", __FUNCTION__);
goto exit_bus;
}
// 初始化 tty_driver 对象
usb_serial_tty_driver->owner = THIS_MODULE;
usb_serial_tty_driver->driver_name = "usbserial";
usb_serial_tty_driver->devfs_name = "usb/tts/";
usb_serial_tty_driver->name = "ttyUSB"; //tty 设备文件名以这个开头 , 后加 0,1,2,3,....
usb_serial_tty_driver->major = SERIAL_TTY_MAJOR; // 主设备号
usb_serial_tty_driver->minor_start = 0;
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_NO_DEVFS;
usb_serial_tty_driver->init_termios = tty_std_termios;
usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
// 赋值 tty 设备的操作集合 , 即应用层调用 open 时最终会调到 serial_ops->open 里面
tty_set_operations(usb_serial_tty_driver, &serial_ops);
result = tty_register_driver(usb_serial_tty_driver); // 注册这个 tty 驱动
if (result) {
err("%s - tty_register_driver failed", __FUNCTION__);
goto exit_reg_driver;
}
/* register the USB driver */
result = usb_register(&usb_serial_driver); // 注册一个 usb 驱动
if (result < 0) {
err("%s - usb_register failed", __FUNCTION__);
goto exit_tty;
}
/* register the generic driver, if we should */
result = usb_serial_generic_register(debug); // 注册 generic 驱动程序
if (result < 0) {
err("%s - registering generic driver failed", __FUNCTION__);
goto exit_generic;
}
info(DRIVER_DESC);
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:
err ("%s - returning with error %d", __FUNCTION__, result);
put_tty_driver(usb_serial_tty_driver);
return result;
}
该函数先创建并初始化好了一个 tty_driver 的对象 , 并把该对象注册进系统 , 该对象就是 tty 设备的驱动程序 , 后面我们会看到他是如何于 具体 tty 设备绑定在一起的 .
usb_serial.c:
static struct tty_operations serial_ops = {
.open = serial_open,
.close = serial_close,
.write = serial_write,
.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,
.read_proc = serial_read_proc,
.tiocmget = serial_tiocmget,
.tiocmset = serial_tiocmset,
};
这个就是 tty 设备文件对应的操作方法集合 , 例如 , 应用层调用 open 函数来打开该设备文件 时将最终会走到 serial_open 里面 .
usb_serial_init() 还注册了一条总线 : usb_serial_bus_type, 这 样当有设备连上系统时 , 该总线上的驱动就有机会去匹配这个设备 . 后面我们会看到 generic 的驱动就是注册在 该总线上的 .
bus.c:
struct bus_type usb_serial_bus_type = {
.name = "usb-serial",
.match = usb_serial_device_match, // 在设备匹配时会调用
.probe = usb_serial_device_probe,
.remove = usb_serial_device_remove,
};
关于设备匹配过程 (probe) 可以参考我的另一 篇文章 .
usb_serial_init() 在最后 usb_serial_generic_register(debug) 来注册 generic 驱动 .
generic.c:
int usb_serial_generic_register (int _debug)
{
int retval = 0;
debug = _debug;
#ifdef CONFIG_USB_SERIAL_GENERIC
generic_device_ids[0].idVendor = vendor; // 保存厂商 ID
generic_device_ids[0].idProduct = product; // 保 存产品 ID
generic_device_ids[0].match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT; // 匹配类型
/* register our generic driver with ourselves */
retval = usb_serial_register (&usb_serial_generic_device); // 注册驱动
if (retval)
goto exit;
retval = usb_register(&generic_driver); // 注册驱动
if (retval)
usb_serial_deregister(&usb_serial_generic_device);
exit:
#endif
return retval;
}
该函数首先保存了命令通过命令行设备的 vendor,product 用 于以后设备匹配 , 由此我们知道该驱动可以动态支持设备匹配 . 接着该函数注册了 usb_serial_generic_device 驱动 .
generic.c:
struct usb_serial_driver usb_serial_generic_device = {
.driver = {
.owner = THIS_MODULE,
.name = "generic",
},
.id_table = generic_device_ids, // 匹配用的设备列表 , 支持动态匹配
.num_interrupt_in = NUM_DONT_CARE,
.num_bulk_in = NUM_DONT_CARE,
.num_bulk_out = NUM_DONT_CARE,
.num_ports = 1,
.shutdown = usb_serial_generic_shutdown,
};
Usb-serial.c:
int usb_serial_register(struct usb_serial_driver *driver)
{
int retval;
fixup_generic(driver); // 为 driver 赋上默认的操作函 数
if (!driver->description)
driver->description = driver->driver.name;
/* Add this device to our list of devices */
list_add(&driver->driver_list, &usb_serial_driver_list); // 加入驱动列表
retval = usb_serial_bus_register(driver); // 把该驱动注册进 usb serial bus 下
if (retval) {
err("problem %d when registering driver %s", retval, driver->description);
list_del(&driver->driver_list);
}
else
info("USB Serial support registered for %s", driver->description);
return retval;
}
其中的 fixup_generic() 函数仅仅是为 driver 赋上默认的操作函 数 .
Usb-serial.c:
#define set_to_generic_if_null(type, function) /
do { /
if (!type->function) { /
type->function = usb_serial_generic_##function; /
dbg("Had to override the " #function /
" usb serial operation with the generic one.");/
} /
} while (0)
static void fixup_generic(struct usb_serial_driver *device)
{
set_to_generic_if_null(device, open);
set_to_generic_if_null(device, write);
set_to_generic_if_null(device, close);
set_to_generic_if_null(device, write_room);
set_to_generic_if_null(device, chars_in_buffer);
set_to_generic_if_null(device, read_bulk_callback);
set_to_generic_if_null(device, write_bulk_callback);
set_to_generic_if_null(device, shutdown);
}
即通过上面的 usb_serial_register() 函数后 usb_serial_generic_device 的函数集为 :
usb_serial_generic_device.open = usb_serial_generic_open;
usb_serial_generic_device.close = usb_serial_generic_close
......
驱动 usb_serial_generic_device 将 是以后操作 tty 设备的主要函数 . 我们会在后面分析 .
bus.c:
int usb_serial_bus_register(struct usb_serial_driver *driver)
{
int retval;
driver->driver.bus = &usb_serial_bus_type; // 注册到该 bus 下
retval = driver_register(&driver->driver);
return retval;
}
最后 usb_serial_generic_register() 函数注册了一个 generic_driver 驱动 .
generic.c:
static struct usb_driver generic_driver = {
.name = "usbserial_generic",
.probe = generic_probe, // 匹配函数
.disconnect = usb_serial_disconnect,
.id_table = generic_serial_ids, // 匹配用的设备列表
.no_dynamic_id = 1, // 不支持动态匹配
};
整个初始化过程 , 乍一看一下子注册了几个驱动程序 , 几个驱动列表 , 有的支持动态匹配有的不支 持 , 感 觉很复杂 , 其实注册 generic_driver 驱动主要是为了注册一个 generic_probe 函数 , 而该函数将会在设备连上系统后被调用以来匹配设备 . 除此之外该驱动没什么用 , 而在这个初始化函数中把 vendor,product 都 保存在了 generic_device_ids 里 , 因此可以肯定以后的匹配将用这个设备列表 , 而不是 generic_serial_ids, 说的更直白些 generic_serial_ids 其实根本也没 什么用 . 真正有用的是 usb_serial_generic_device 驱动 ,
generic.c:
static int generic_probe(struct usb_interface *interface,
const struct usb_device_id *id)
{
const struct usb_device_id *id_pattern;
id_pattern = usb_match_id(interface, generic_device_ids); // 设备匹配
if (id_pattern != NULL)
return usb_serial_probe(interface, id); // 进一步匹 配
return -ENODEV;
}
如果接入系统的设备的 vendor 和 product 与我们驱动支持 的设备列表匹配则调用 usb_serial_probe 来进一步匹配 .
usb_serial_probe 函数比较长 , 我们一段段的来看
usb-serial.c:
int usb_serial_probe(struct usb_interface *interface,
const struct usb_device_id *id)
{
struct usb_device *dev = interface_to_usbdev (interface);
struct usb_serial *serial = NULL;
struct usb_serial_port *port;
struct usb_host_interface *iface_desc;
struct usb_endpoint_descriptor *endpoint;
struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
struct usb_serial_driver *type = NULL;
int retval;
int minor;
int buffer_size;
int i;
int num_interrupt_in = 0;
int num_interrupt_out = 0;
int num_bulk_in = 0;
int num_bulk_out = 0;
int num_ports = 0;
int max_endpoints;
type = search_serial_device(interface); // 获取该设备匹配的驱动
if (!type) {
dbg("none matched");
return -ENODEV;
}
......
}
首先是找到合适的驱动程序 .
usb-serial.c:
static struct usb_serial_driver *search_serial_device(struct usb_interface *iface)
{
struct list_head *p;
const struct usb_device_id *id;
struct usb_serial_driver *t;
/* Check if the usb id matches a known device */
list_for_each(p, &usb_serial_driver_list) {
t = list_entry(p, struct usb_serial_driver, driver_list);
id = usb_match_id(iface, t->id_table); // 看设备列表是否匹配
if (id != NULL) {
dbg("descriptor matches");
return t; // 返回匹配的驱动
}
}
return NULL;
}
实际上这边的匹配和 generic_probe 里的 匹配重复了 , 因为他们的匹配的设备列表是同一个 , 这边主要是为了得到匹配的驱动程序 , 根据上面的代码分析我们可以知道这里匹配的驱动 是 usb_serial_generic_device.
接着看 usb_serial_probe()
usb-serial.c:
....
serial = create_serial (dev, interface, type); // 为 该设备创建一个 usb_serial 对象
if (!serial) {
dev_err(&interface->dev, "%s - out of memory/n", __FUNCTION__);
return -ENOMEM;
}
/* if this device type has a probe function, call it */
if (type->probe) { // 从上面分析的代码可知这里的 probe 函数没有赋值
const struct usb_device_id *id;
if (!try_module_get(type->driver.owner)) {
dev_err(&interface->dev, "module get failed, exiting/n");
kfree (serial);
return -EIO;
}
id = usb_match_id(interface, type->id_table);
retval = type->probe(serial, id);
module_put(type->driver.owner);
if (retval) {
dbg ("sub driver rejected device");
kfree (serial);
return retval;
}
}
....
这段代码可知 , 主要是创建一个 usb_serial 的对象 , 用于保存该设备的详细信息 , 一般的驱动程序都会为自己 匹配的设备创建一个描用于描述该设备的对象 . 在以后的所有操作中如读写等都会直接从这个对象里获取相应的信息 .
usb-serial.c:
static struct usb_serial * create_serial (struct usb_device *dev,
struct usb_interface *interface,
struct usb_serial_driver *driver)
{
struct usb_serial *serial;
serial = kmalloc (sizeof (*serial), GFP_KERNEL); // 闯将该对象
if (!serial) {
dev_err(&dev->dev, "%s - out of memory/n", __FUNCTION__);
return NULL;
}
// 初始化该对象
memset (serial, 0, sizeof(*serial));
serial->dev = usb_get_dev(dev); // 增加 dev 的引用计数
serial->type = driver;
serial->interface = interface;
kref_init(&serial->kref);
return serial;
}
这个函数就是用来创建 usb_serial 对象的 , 并把相关信息保存在里面 .
继续看 usb_serial_probe()
usb-serial.c:
....
/* descriptor matches, let's find the endpoints needed */
/* check out the endpoints */
// 查找该设备使用的 endpoint 的描述符 , 并检查是否正确
iface_desc = interface->cur_altsetting; // 接口描述符
for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
endpoint = &iface_desc->endpoint[i].desc; // 端点描述符
if ((endpoint->bEndpointAddress & 0x80) &&
((endpoint->bmAttributes & 3) == 0x02)) {
/* we found a bulk in endpoint */ //bulk in 的端点
dbg("found bulk in on endpoint %d", i);
bulk_in_endpoint[num_bulk_in] = endpoint;
++num_bulk_in;
}
if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
((endpoint->bmAttributes & 3) == 0x02)) {
/* we found a bulk out endpoint */ //bulk out 的端点
dbg("found bulk out on endpoint %d", i);
bulk_out_endpoint[num_bulk_out] = endpoint;
++num_bulk_out;
}
if ((endpoint->bEndpointAddress & 0x80) &&
((endpoint->bmAttributes & 3) == 0x03)) {
/* we found a interrupt in endpoint */ // 中断 in 端点
dbg("found interrupt in on endpoint %d", i);
interrupt_in_endpoint[num_interrupt_in] = endpoint;
++num_interrupt_in;
}
if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
((endpoint->bmAttributes & 3) == 0x03)) {
/* we found an interrupt out endpoint */ // 中断 out 端点
dbg("found interrupt out on endpoint %d", i);
interrupt_out_endpoint[num_interrupt_out] = endpoint;
++num_interrupt_out;
}
}
.....
该段代码主要是获取该设备使用的各个类型及方向的端点描述府 , 并保存起来 , 关于端点的类型与方向可以 参考 USB 的规范 .
继续看 usb_serial_probe()
usb-serial.c:
....
#if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
/* BEGIN HORRIBLE HACK FOR PL2303 */
/* this is needed due to the looney way its endpoints are set up */
if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
(le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
(le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID))) {
if (interface != dev->actconfig->interface[0]) {
/* check out the endpoints of the other interface*/
iface_desc = dev->actconfig->interface[0]->cur_altsetting;
for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
endpoint = &iface_desc->endpoint[i].desc;
if ((endpoint->bEndpointAddress & 0x80) &&
((endpoint->bmAttributes & 3) == 0x03)) {
/* we found a interrupt in endpoint */
dbg("found interrupt in for Prolific device on separate interface");
interrupt_in_endpoint[num_interrupt_in] = endpoint;
++num_interrupt_in;
}
}
}
/* Now make sure the PL-2303 is configured correctly.
* If not, give up now and hope this hack will work
* properly during a later invocation of usb_serial_probe
*/
if (num_bulk_in == 0 || num_bulk_out == 0) {
dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not/n");
kfree (serial);
return -ENODEV;
}
}
/* END HORRIBLE HACK FOR PL2303 */
#endif
上面这段代码主要是用于特定类型设备的 (PL2303), 这里我们 不用管他 .
接着看 usb_serial_probe()
usb-serial.c:
....
/* found all that we need */
dev_info(&interface->dev, "%s converter detected/n", type->description);
#ifdef CONFIG_USB_SERIAL_GENERIC // 这个宏定义了 , 因为我们使用的是通用 USB 驱动 .
if (type == &usb_serial_generic_device) { // 这个 if 为 TRUE( 上面分析过了 )
num_ports = num_bulk_out;
if (num_ports == 0) { //bulk out 端点必须要有
dev_err(&interface->dev, "Generic device with no bulk out, not allowed./n");
kfree (serial);
return -EIO;
}
}
#endif
if (!num_ports) { // 由于走到了上面那个 if 段 , 因此这里的 num_ports 肯定不为 0
/* if this device type has a calc_num_ports function, call it */
if (type->calc_num_ports) {
if (!try_module_get(type->driver.owner)) {
dev_err(&interface->dev, "module get failed, exiting/n");
kfree (serial);
return -EIO;
}
num_ports = type->calc_num_ports (serial);
module_put(type->driver.owner);
}
if (!num_ports)
num_ports = type->num_ports;
}
// 获取一个空闲的 serial_table 项
if (get_free_serial (serial, num_ports, &minor) == NULL) {
dev_err(&interface->dev, "No more free serial devices/n");
kfree (serial);
return -ENOMEM;
}
usbserial 模块总共支持 SERIAL_TTY_MINORS 个设备 , 它为每个设备都分配了一个 serial_table 项 , 用于保存 usb_serial 对象 , 方便以后直接通过 minor 号获取 usb_serial 对象 .
usb-serial.c:
static struct usb_serial *get_free_serial (struct usb_serial *serial, int num_ports, unsigned int *minor)
{
unsigned int i, j;
int good_spot;
dbg("%s %d", __FUNCTION__, num_ports);
*minor = 0;
for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
if (serial_table[i]) // 查找一个空闲的 serial_table 项 , serial_table 是个 usb_serial 的指针数组 .
continue;
good_spot = 1;
// 从上面代码可知 , 对于 generic 的驱动 , num_ports 就等于 num_bulk_out, 而一般的设备仅有 // 一个 bulk out 的端点 , 因此这个 for 循环不会执行 .
for (j = 1; j <= num_ports-1; ++j)
if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
good_spot = 0;
i += j;
break;
}
if (good_spot == 0)
continue;
*minor = i; // 获取 minor 号
dbg("%s - minor base = %d", __FUNCTION__, *minor);
for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i)
serial_table[i] = serial; // 获取空闲的 serial_table 项 , 并把我们的 usb_serial 对象地址保
// 存在其中 .
return serial;
}
return NULL;
}
通过这个函数我们找到了一个空闲的 serial_table 项 , 并把描述我们设备的 usb_serial 对象保存 在其中 , 在以后对设备的使用中 , 我们可以轻易的通过 minor 号来找到这个 usb_serial.
接着看 usb_serial_probe()
usb-serial.c:
....
// 保存设备信息到 usb_serial 对象中 ,
serial->minor = minor;
serial->num_ports = num_ports; // 这里的 port 数量不是 endpoint 的数量 ,
serial->num_bulk_in = num_bulk_in;
serial->num_bulk_out = num_bulk_out;
serial->num_interrupt_in = num_interrupt_in;
serial->num_interrupt_out = num_interrupt_out;
/* create our ports, we need as many as the max endpoints */
/* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
// 对于 generic 的驱动来说一般都只有一个 bulk in, 一个 bulk out, 一个 interrupt in, 一个 interrupt out
max_endpoints = max(num_bulk_in, num_bulk_out);
max_endpoints = max(max_endpoints, num_interrupt_in);
max_endpoints = max(max_endpoints, num_interrupt_out);
max_endpoints = max(max_endpoints, (int)serial->num_ports);
// 到这一步 , 对于 generic 来说大多数情况下 max_endpoints 还 是为 1
serial->num_port_pointers = max_endpoints;
dbg("%s - setting up %d port structures for this device", __FUNCTION__, max_endpoints);
for (i = 0; i < max_endpoints; ++i) {
port = kmalloc(sizeof(struct usb_serial_port), GFP_KERNEL); // 分配一个 port 对象
if (!port)
goto probe_error;
// 初始化 port 对象
memset(port, 0x00, sizeof(struct usb_serial_port));
port->number = i + serial->minor;
port->serial = serial; // 保 存 usb_serial 对象 , 便于以后通过 port 对象访问到 usb_serial 对象
spin_lock_init(&port->lock);
sema_init(&port->sem, 1);
INIT_WORK(&port->work, usb_serial_port_softint, port);
serial->port[i] = port;
}
// 由上面的对 port 的初始化可知 , 每个 port 都有一套自己的工作机 制 , port 间互不干扰
/* set up the endpoint information */
for (i = 0; i < num_bulk_in; ++i) {
// 初始 化 bulk in 端点 , 并把它保存到相应的 port 里
endpoint = bulk_in_endpoint[i];
port = serial->port[i];
port->read_urb = usb_alloc_urb (0, GFP_KERNEL); // 分配 urb
if (!port->read_urb) {
dev_err(&interface->dev, "No free urbs available/n");
goto probe_error;
}
buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
port->bulk_in_size = buffer_size;
port->bulk_in_endpointAddress = endpoint->bEndpointAddress; // 保存端点地址
port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL); // 分配传输缓存
if (!port->bulk_in_buffer) {
dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer/n");
goto probe_error;
}
// 设置好该 urb.
usb_fill_bulk_urb (port->read_urb, dev,
usb_rcvbulkpipe (dev,
endpoint->bEndpointAddress),
port->bulk_in_buffer, buffer_size,
serial->type->read_bulk_callback,
port);
}
for (i = 0; i < num_bulk_out; ++i) {
// 初始化 bulk out 端点 , 并把它保存到相应的 port 里
endpoint = bulk_out_endpoint[i];
port = serial->port[i];
port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!port->write_urb) {
dev_err(&interface->dev, "No free urbs available/n");
goto probe_error;
}
buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
port->bulk_out_size = buffer_size;
port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
if (!port->bulk_out_buffer) {
dev_err(&interface->dev, "Couldn't allocate bulk_out_buffer/n");
goto probe_error;
}
usb_fill_bulk_urb (port->write_urb, dev,
usb_sndbulkpipe (dev,
endpoint->bEndpointAddress),
port->bulk_out_buffer, buffer_size,
serial->type->write_bulk_callback,
port);
}
.....
上面这段代码主要是保存设备信息到 usb_serial 中去 , 并为每个口分配一个 port, 同时设置好 port 中的项 . 对于这里的 port, 我的理解是有的设备可能有多个口 , 而每个口都有自己的一套 endpoint 用于该口的功能实现 . 因此我们要为每个口分别分 配 port 对象 , 并保存该口下的 endpoint 信息 .
接着看 usb_serial_probe()
usb-serial.c:
....
if (serial->type->read_int_callback) { // 对于 generic 驱动 , 这里的 read_int_callback 为空
for (i = 0; i < num_interrupt_in; ++i) {
// 初始化中断端点
endpoint = interrupt_in_endpoint[i];
port = serial->port[i];
port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!port->interrupt_in_urb) {
dev_err(&interface->dev, "No free urbs available/n");
goto probe_error;
}
buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
port->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
if (!port->interrupt_in_buffer) {
dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer/n");
goto probe_error;
}
usb_fill_int_urb (port->interrupt_in_urb, dev,
usb_rcvintpipe (dev,
endpoint->bEndpointAddress),
port->interrupt_in_buffer, buffer_size,
serial->type->read_int_callback, port,
endpoint->bInterval);
}
} else if (num_interrupt_in) { // 如果有 interrupt in 而没有 read_int_callback 则是错误的
dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
}
// 从上面这个 if 可以看出 generic 驱动的设备不应 该有 interrupt in 端点 , 有也可以但是这个端点将
// 不起作用 .
// 下面这个 if 和上面的这个 if 功能一模一样 .
if (serial->type->write_int_callback) {
for (i = 0; i < num_interrupt_out; ++i) {
endpoint = interrupt_out_endpoint[i];
port = serial->port[i];
port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
if (!port->interrupt_out_urb) {
dev_err(&interface->dev, "No free urbs available/n");
goto probe_error;
}
buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
port->interrupt_out_size = buffer_size;
port->interrupt_out_endpointAddress = endpoint->bEndpointAddress;
port->interrupt_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
if (!port->interrupt_out_buffer) {
dev_err(&interface->dev, "Couldn't allocate interrupt_out_buffer/n");
goto probe_error;
}
usb_fill_int_urb (port->interrupt_out_urb, dev,
usb_sndintpipe (dev,
endpoint->bEndpointAddress),
port->interrupt_out_buffer, buffer_size,
serial->type->write_int_callback, port,
endpoint->bInterval);
}
} else if (num_interrupt_out) {
dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
}
/* if this device type has an attach function, call it */
if (type->attach) { // 对于 generic 驱动 , 没有设置这个 attach 函数
if (!try_module_get(type->driver.owner)) {
dev_err(&interface->dev, "module get failed, exiting/n");
goto probe_error;
}
retval = type->attach (serial);
module_put(type->driver.owner);
if (retval < 0)
goto probe_error;
if (retval > 0) {
/* quietly accept this device, but don't bind to a serial port
* as it's about to disappear */
goto exit;
}
}
/* register all of the individual ports with the driver core */
for (i = 0; i < num_ports; ++i) {
port = serial->port[i];
port->dev.parent = &interface->dev;
port->dev.driver = NULL;
port->dev.bus = &usb_serial_bus_type; // 注册到 usb_serial_bus 上去
port->dev.release = &port_release;
snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number);
dbg ("%s - registering %s", __FUNCTION__, port->dev.bus_id);
device_register (&port->dev); // 把该设备注册到系统中去
}
usb_serial_console_init (debug, minor);
......
上面这段代码主要就是初始化 interrupt 的端点 , 并且把 port 设备挂到 usb_serial_bus 上 注册进系统 ,
接着看 usb_serial_probe()
usb-serial.c:
......
exit:
/* success */
usb_set_intfdata (interface, serial); // 在 interface 对象里保存 usb_serial 对象地址 , 以方便以后使用
return 0;
// 错误处理
probe_error:
for (i = 0; i < num_bulk_in; ++i) {
port = serial->port[i];
if (!port)
continue;
if (port->read_urb)
usb_free_urb (port->read_urb);
kfree(port->bulk_in_buffer);
}
for (i = 0; i < num_bulk_out; ++i) {
port = serial->port[i];
if (!port)
continue;
if (port->write_urb)
usb_free_urb (port->write_urb);
kfree(port->bulk_out_buffer);
}
for (i = 0; i < num_interrupt_in; ++i) {
port = serial->port[i];
if (!port)
continue;
if (port->interrupt_in_urb)
usb_free_urb (port->interrupt_in_urb);
kfree(port->interrupt_in_buffer);
}
for (i = 0; i < num_interrupt_out; ++i) {
port = serial->port[i];
if (!port)
continue;
if (port->interrupt_out_urb)
usb_free_urb (port->interrupt_out_urb);
kfree(port->interrupt_out_buffer);
}
/* return the minor range that this device had */
return_serial (serial);
/* free up any memory that we allocated */
for (i = 0; i < serial->num_port_pointers; ++i)
kfree(serial->port[i]);
kfree (serial);
return -EIO;
这样整个 probe 过程就结束了 , 或许你会奇怪 , 好像 usb_serial_bus 都 没什么用 , 而且好像没看见这个设备和 init 时的那个 tty_driver 绑定啊 , 不错 , 这个 probe 函数本身还没有作这 些工作 , 我们接着分析 .
usb_serial_probe() 函数在最后调用了 device_register (&port->dev); 把设备注册进了系统 , 在这个注册过程中 , 系统会在次为这个注册的设 备进行 probe 过程 .
我们先来了解下 probe 的过程
Driver 的 prob 的调用顺序 :
1 device_add(): 把 device 注册到相应的 bus 上去 , 并创建相应的 device file, 最后调用 bus_attach_device()
2 bus_attach_device() 调用 device_attach(dev)
3 device_attach(): 调用 bus_for_each_drv() 遍历 bus 上的每个 driver, 当找到一个 driver 则用 __device_attach() 来判断是否匹配
4 __device_attach(): 直接调用 driver_probe_device(drv, dev)
5 driver_probe_device(): 首先如果 driver 所 在总线有 match 函数则先调用这个 match 来 匹配 , 如 不匹配则直接返回错误 , 否则接着调用 really_probe(dev,drv)
6 really_probe(): 先判断 dev 所在总线是否有 probe 函数 , 有则调用它来匹配 , 失败则返回 , 正确则成功 , 如果总线没有 probe 则判断 drv 是否有 probe 函数 , 有则调用并匹配它 .
7 drv->prob(): 一般它是一类设备的 probe, 在它里面它会调用具体某个 drv 的 probe 函数 , 这个函数是在我们的驱动程序里面注册的 .
device_register() 里会调用 device_add(). 因此由 5 可知 系统会先调用总线上的 match 函数来匹配 . 对于我们的总线就是 usb_serial_bus, 它的 match 函数就是 usb_serial_device_match(), 至于为什么是这条总线 , 通过前面的代码分析 , 我们知道我们的设备也好 , 我们的驱动也好都是注册在 这条总线上的 .
下面我们就来分析 usb_serial_device_match()
Bus.c:
static int usb_serial_device_match (struct device *dev, struct device_driver *drv)
{
struct usb_serial_driver *driver;
const struct usb_serial_port *port;
/*
* drivers are already assigned to ports in serial_probe so it's
* a simple check here.
*/
port = to_usb_serial_port(dev); // 获取 usb_serial_port 对象
if (!port)
return 0;
driver = to_usb_serial_driver(drv); // 获取 usb_serial_driver 对象
if (driver == port->serial->type) // 匹配否 ?
return 1;
return 0;
}
很显然 , 通过前面的分析可知 , 这里肯定是匹配的 .
接着通过上面 probe 过程的 6 可知会调用总线的 probe 函数 , 这里就是 usb_serial_device_probe
Bus.c:
static int usb_serial_device_probe (struct device *dev)
{
struct usb_serial_driver *driver;
struct usb_serial_port *port;
int retval = 0;
int minor;
port = to_usb_serial_port(dev);
if (!port) {
retval = -ENODEV;
goto exit;
}
driver = port->serial->type;
if (driver->port_probe) {
if (!try_module_get(driver->driver.owner)) {
dev_err(dev, "module get failed, exiting/n");
retval = -EIO;
goto exit;
}
retval = driver->port_probe (port);
module_put(driver->driver.owner);
if (retval)
goto exit;
}
minor = port->number;
tty_register_device (usb_serial_tty_driver, minor, dev); // 呵呵 , 这里总算把 tty_driver 和 device 绑定
// 起来了
dev_info(&port->serial->dev->dev,
"%s converter now attached to ttyUSB%d/n",
driver->description, minor);
exit:
return retval;
}
到了这一步该设备就和 tty_driver 绑定在了一 起了 , 同时在 /dev 下也创建了相应的设备文件了 , 也就是说应用层可以使用这个设备了 .
这样整个对设备的 probe 过程才算真的完成了 .
OK, 设备从 USB 口连上系统 , 并被系统认出及 probe 的真个过程就基本完成了 , 从此以后设备就进入了就绪状态 . 下面我们就开始分析对设备的操作流程了 .
要使用设备当然要先打开这个设备了 , 应用层调用 open 系统调用来打开这个设 备 , 它 最终会跑到我们 tty_driver 的 open 函数里面
static struct tty_operations serial_ops = {
.open = serial_open,
.close = serial_close,
.write = serial_write,
.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,
.read_proc = serial_read_proc,
.tiocmget = serial_tiocmget,
.tiocmset = serial_tiocmset,
};
这里就是 serial_open 了 .
usb_serial.c:
static int serial_open (struct tty_struct *tty, struct file * filp)
{
struct usb_serial *serial;
struct usb_serial_port *port;
unsigned int portNumber;
int retval;
dbg("%s", __FUNCTION__);
/* get the serial object associated with this tty pointer */
serial = usb_serial_get_by_index(tty->index); // 获取 usb_serial 对象 , 根据上面的分析 , 不难理解
if (!serial) {
tty->driver_data = NULL;
return -ENODEV;
}
portNumber = tty->index - serial->minor;
port = serial->port[portNumber]; // 获取设备对应的 port 对象 , 这也不难理解了
if (!port)
return -ENODEV;
if (down_interruptible(&port->sem))
return -ERESTARTSYS;
++port->open_count; // 跟踪打开次数
if (port->open_count == 1) {
/* set up our port structure making the tty driver
* remember our port object, and us it */
tty->driver_data = port; // 赋值 , 为以后的操作方便引用
port->tty = tty;
/* lock this module before we call it
* this may fail, which means we must bail out,
* safe because we are called with BKL held */
if (!try_module_get(serial->type->driver.owner)) {
retval = -ENODEV;
goto bailout_kref_put;
}
/* only call the device specific open if this
* is the first time the port is opened */
retval = serial->type->open(port, filp); // 调用 usb_serial_driver 的 open 函数 , 在前面分析过了
if (retval)
goto bailout_module_put;
}
up(&port->sem);
return 0;
bailout_module_put:
module_put(serial->type->driver.owner);
bailout_kref_put:
kref_put(&serial->kref, destroy_serial);
port->open_count = 0;
up(&port->sem);
return retval;
}
可以看到这个 open 动作主要就是保存一些信息 , 以方便后面使用 , 接着调用 usb_serial_driver 的 open 函数 , 这里该 open 是 usb_serial_generic_open, 前面分析过了
generic.c:
int usb_serial_generic_open (struct usb_serial_port *port, struct file *filp)
{
struct usb_serial *serial = port->serial;
int result = 0;
dbg("%s - port %d", __FUNCTION__, port->number);
/* force low_latency on so that our tty_push actually forces the data through,
otherwise it is scheduled, and with high data rates (like with OHCI) data
can get lost. */
if (port->tty)
port->tty->low_latency = 1;
/* if we have a bulk interrupt, start reading from it */
// 如果有 bulk in 的端点的话 , 就提交这个端点的 urb, 即让系统开始在这个 端点上接收来自设备段
// 发过来的数据 , 当数据收到后会调用 serial->type->read_bulk_callback 函数 .
if (serial->num_bulk_in) {
/* Start reading from the device */
usb_fill_bulk_urb (port->read_urb, serial->dev,
usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
port->read_urb->transfer_buffer,
port->read_urb->transfer_buffer_length,
((serial->type->read_bulk_callback) ?
serial->type->read_bulk_callback :
usb_serial_generic_read_bulk_callback),
port);
result = usb_submit_urb(port->read_urb, GFP_KERNEL); // 提交
if (result)
dev_err(&port->dev, "%s - failed resubmitting read urb, error %d/n", __FUNCTION__, result);
}
return result;
}
这个函数后 , 系统就开始在 bulk in 的端点上接收数据 了 , 如 果有数据到来的话就会调用我们的回调函数 .
接下来我们来看这个回调函数 :
Generic.c:
void usb_serial_generic_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
{
struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
struct usb_serial *serial = port->serial;
struct tty_struct *tty;
unsigned char *data = urb->transfer_buffer;
int result;
dbg("%s - port %d", __FUNCTION__, port->number);
if (urb->status) { // 这次通信的状态
dbg("%s - nonzero read bulk status received: %d", __FUNCTION__, urb->status);
return;
}
usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
tty = port->tty;
if (tty && urb->actual_length) {
// 如果有数据接收到的话 , 就把它存入 tty 驱动的缓冲中去
tty_buffer_request_room(tty, urb->actual_length);
tty_insert_flip_string(tty, data, urb->actual_length);
tty_flip_buffer_push(tty);
}
/* Continue trying to always read */
// 继续下一个接收操作 .
usb_fill_bulk_urb (port->read_urb, serial->dev,
usb_rcvbulkpipe (serial->dev,
port->bulk_in_endpointAddress),
port->read_urb->transfer_buffer,
port->read_urb->transfer_buffer_length,
((serial->type->read_bulk_callback) ?
serial->type->read_bulk_callback :
usb_serial_generic_read_bulk_callback), port);
result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
if (result)
dev_err(&port->dev, "%s - failed resubmitting read urb, error %d/n", __FUNCTION__, result);
}
很明显 , 这个回调就是把从设备端收到的数据 push 到相对上层的 tty 驱动中去 , 随后 tty 子系统会把这些数据返回 给用户 .
OK, 看完接收过程后我们在来看下发送过程 .
发送过程由用户发起 , 用户可以调用 write 系统调用来发数据 , 最后会跑到 tty 驱动的 write 函数中去 .
Usb-serial.c:
static int serial_write (struct tty_struct * tty, const unsigned char *buf, int count)
{
struct usb_serial_port *port = tty->driver_data;
int retval = -EINVAL;
if (!port)
goto exit;
dbg("%s - port %d, %d byte(s)", __FUNCTION__, port->number, count);
if (!port->open_count) {
dbg("%s - port not opened", __FUNCTION__);
goto exit;
}
/* pass on to the driver specific version of this function */
retval = port->serial->type->write(port, buf, count); // 仅仅是调用 usb_serial_driver 的 write 函数
exit:
return retval;
}
这个函数 , 直接调用了 usb_serial_driver 的 write 函数 .
Generic.c:
int usb_serial_generic_write(struct usb_serial_port *port, const unsigned char *buf, int count)
{
struct usb_serial *serial = port->serial;
int result;
unsigned char *data;
dbg("%s - port %d", __FUNCTION__, port->number);
if (count == 0) {
dbg("%s - write request of 0 bytes", __FUNCTION__);
return (0);
}
/* only do something if we have a bulk out endpoint */
// 仅在有 bulk out 的端点上才能发送
if (serial->num_bulk_out) {
spin_lock(&port->lock);
if (port->write_urb_busy) {
spin_unlock(&port->lock);
dbg("%s - already writing", __FUNCTION__);
return 0;
}
port->write_urb_busy = 1;
spin_unlock(&port->lock);
// 把要发送的数据 , 发送的字节数存入 urb 中
count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
memcpy (port->write_urb->transfer_buffer, buf, count);
data = port->write_urb->transfer_buffer;
usb_serial_debug_data(debug, &port->dev, __FUNCTION__, count, data);
/* set up our urb */
usb_fill_bulk_urb (port->write_urb, serial->dev,
usb_sndbulkpipe (serial->dev,
port->bulk_out_endpointAddress),
port->write_urb->transfer_buffer, count,
((serial->type->write_bulk_callback) ?
serial->type->write_bulk_callback :
usb_serial_generic_write_bulk_callback), port);
/* send the data out the bulk port */
port->write_urb_busy = 1;
result = usb_submit_urb(port->write_urb, GFP_ATOMIC); // 提交一个发送过程
if (result) {
dev_err(&port->dev, "%s - failed submitting write urb, error %d/n", __FUNCTION__, result);
/* don't have to grab the lock here, as we will retry if != 0 */
port->write_urb_busy = 0;
} else
result = count;
return result;
}
/* no bulk out, so return 0 bytes written */
return 0;
}
该函数把用户要发送的数据封装到一个 urb 中去 , 并把该 urb 提交给系统以执行一个发 送的操作 , 发送完成后会调用 serial->type->write_bulk_callback 函数 .
接着看这个回调函数 :
Generic.c:
void usb_serial_generic_write_bulk_callback (struct urb *urb, struct pt_regs *regs)
{
struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
dbg("%s - port %d", __FUNCTION__, port->number);
port->write_urb_busy = 0;
if (urb->status) {
dbg("%s - nonzero write bulk status received: %d", __FUNCTION__, urb->status);
return;
}
usb_serial_port_softint((void *)port); // 请 求传输更多的数据
schedule_work(&port->work); // 调度一个工作
}
Usb-serial.c:
void usb_serial_port_softint(void *private)
{
struct usb_serial_port *port = private;
struct tty_struct *tty;
dbg("%s - port %d", __FUNCTION__, port->number);
if (!port)
return;
tty = port->tty;
if (!tty)
return;
tty_wakeup(tty); // 请求传输更多的数据
}
其实很简单 ,
其他的函数就不多做分析了 ,
看懂了这个模块后 , 实际上对 USB 设备的驱动也就大体知道 了其流程 .