usb-serial分析重要文件由usb-serial.c ; generic.c ; usb.c ; option.c
从module_init(usb_serial_init)开始
//按照tty驱动结构，先创建"tty_driver"对象
alloc_tty_driver(SERIAL_TTY_MINIOR) 注册总线usb-serial,之后很多驱动及设备都会注册到该总线上
bus_register(&usb_serial_bus_type) 关于 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, .drv_attrs = drv_attrs, }; 为什么没有注册这个总线设备，device_register(usb_serial_bus)?? 初始化tty_driver对象
usb_serial_tty_driver->name=.. . . . 设置tty_driver的操作函数fops tty_set_operation(usb_serial_tty_driver,&serial_ops) 向tty核心注册tty驱动
tty_register_driver(usb_serial_tty_driver) 将usb_serial_driver驱动注册到usb总线上
usb_register(usb_serial_driver) 关于usb_serial_driver static struct usb_driver usb_serial_driver = { .name = "usbserial", .probe = usb_serial_probe, .disconnect = usb_serial_disconnect, .suspend = usb_serial_suspend, .resume = usb_serial_resume, .no_dynamic_id = 1, }; 最后注册generic驱动
usb_serial_generic_register(debug) 分析usb_serial_generic_register(debug) 保存idVendor generic_device_ids[0].idVendor=vendor
保存idProduct generic_device_ids[0].idProduct=idProduct
匹配类型generic_device_ids[0].match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT;
将usb_serial_generic_device结构体（未知是驱动结构体还是设备结构体）注册到usb-serial总线上
usb_serial_register(&usb_serial_generic_device) 关于usb_serial_generic_device struct usb_serial_driver usb_serial_generic_device = {
.driver = { .owner = THIS_MODULE, .name = "generic", }, .id_table = generic_device_ids, .usb_driver = &generic_driver, .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, .throttle = usb_serial_generic_throttle, .unthrottle = usb_serial_generic_unthrottle, .resume = usb_serial_generic_resume, }; 其中，usb_serial_driver是新定义的驱动结构体
将"generic_driver"注册到usb总线上，目的是当设备插入系统后，通过generic_driver的generic_probe 来匹配设备。因此。已经注册了两个驱动进了usb总线 usb_register(&generic_driver) 关于generic_driver结构体
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, //不支持动态匹配 }; 函数 usb_serial_generic_register(int _debug)已经整体分析完，下面分析该函数里面的usb_serial_register函数 为usb_serial_driver添加新的操作功能(open,write,close,....)
fixup_generic(struct usb_serial_driver* device) 将usb_serial_driver添加到usb-serial总线上的驱动列表usb_serial_driver_list上 list_add(&driver->driver_list, &usb_serial_driver_list); 注册驱动到usb-serial总线上
usb_serial_bus_register(driver) 在usb总线上注册了两个驱动"usbserial"和"usbserial_generic",那么当插入设备的时候
究竟是匹配哪一个驱动呢??????????????????????? 现在似乎usb-serial总线和usb总线没有什么联系，好，那么就看generic_probe函数 id_pattern = usb_match_id(interface, generic_device_ids)
初步匹配 if (id_pattern != NULL)
return usb_serial_probe(interface, id); 继续匹配，寻找和其匹配的驱动 usb中的probe函数的工作
1.初始化用于控制usb设备的局部结构体
2.探测端点类型 3.保存相关局部结构体的信息 4.把设备注册到USB核心,以便与用户程序监护信息 另外一个匹配函数usn_serial_probe出场了
int usb_serial_probe(struct usb_interface *interface,const struct usb_device_id *id)
type = search_serial_device(interface);
获取该设备匹配的驱动，"struct usb_serial_driver* type" 获取到设备之后，为该设备创建一个"usb_serial"对象 serial = create_serial (dev, interface, type) (一般的驱动程序都会为自己匹配设备创建一个用于描述设备的对象，在以后的所有操作中， 如读写等都会直接从这个对象获取相应的信息) iface_desc = interface->cur_altsetting //获取设备接口的当前设置
endpoint = &iface_desc->endpoint[i].desc
检查当前接口的端点类型，并保存，对于usb_serial_generic设备，常见的端点类型为bulkin和bulkout port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL)
用struct usb_serial_port来描述一个tty端口，因为每个端口都有自己的工作模式 关于 struct usb_serial_port struct usb_serial_port { struct usb_serial *serial; struct tty_struct *tty; spinlock_t lock; struct mutex mutex; unsigned char number; unsigned char *interrupt_in_buffer;
struct urb *interrupt_in_urb; __u8 interrupt_in_endpointAddress; unsigned char *interrupt_out_buffer;
int interrupt_out_size; struct urb *interrupt_out_urb; __u8 interrupt_out_endpointAddress; unsigned char *bulk_in_buffer;
int bulk_in_size; struct urb *read_urb; __u8 bulk_in_endpointAddress; unsigned char *bulk_out_buffer;
int bulk_out_size; struct urb *write_urb; int write_urb_busy; __u8 bulk_out_endpointAddress; wait_queue_head_t write_wait;
struct work_struct work; int open_count; char throttled; char throttle_req; char console; struct device dev; }; port->serial = serial
将usb_serial对象保存到usb_serial_port中，便于通过port来访问serial 初始化bulk_in端点，保存到"usb_serial_port"（port对象中） for (i = 0; i < num_bulk_in; ++i) { 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);//创建DMA缓冲区 if (!port->bulk_in_buffer) { dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer\n"); goto probe_error; } 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);//在提交urb之前将其正确的初始化 } 同样的方法初始化bulk_out端点
----------------------------------------------------------------------------------------- 初始化输入中断interrupt_in端点
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) { dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined"); } 同样的方法初始化interrupt_out端点和attach
————————————————————————————————————————————- usbserial模块总共支持254个设备，他为每个设备分配了一个serial_table项， 用于保存"usb_serial"对象，方便以后直接通过minor号获取"usbserial"对象 serial->minor = minor
注册所有独立的ports到驱动核心 /* 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;//驱动的总线 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); retval = device_register(&port->dev); //重要，吧设备注册到usb核心，以便与用户程序交互信息 if (retval) dev_err(&port->dev, "Error registering port device, " "continuing\n"); } usb_serial_console_init (debug, minor); //初始化中断控制台
usb_set_intfdata (interface, serial);//把serial结构体保存到interface接口设备中，可以调用usb_get_intfdata来获取数据。
至此，probe函数完成了4个主要工作，probe函数也走到了尽头 --------------------------------------------------------------------------------------------
到现在usb_serial_bus都没怎么用到，也没有看到这个设备和初始化时的tty_driver 绑定，这些东西都在了probe函数最后调用的device_register中。 device_register(&port->dev); 一下分析device_driver:
int device_register(struct device *dev) { device_initialize(dev); return device_add(dev); } 1.device_add():把设备device注册到相应的总线上。并创建device_file，最后
调用bus_attach_device()函数 ->bus_attach_device调用device_attach(dev)
->bus_for_each_drv()遍历bus上的每个driver，当找到一个就用__device_attach() 来判断匹配 ->driver_probe_device(dev,drv)首先如果所有的driver所在总线由nach函数则 先调用match来匹配,如果匹配,直接调用really_probe(dev,drv) ->really_probe。判断总线，如果由probe函数则调用和匹配它 ->drv->probe:它是一类设备的probe,在他里面会调用具体某个drv的probe函数， 这个函数是在我们的驱动程序里面注册的 在该device_register里，
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, .drv_attrs = drv_attrs, }; 所以会先调用usb_serial_device_match,进行匹配
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); if (!port) return 0; driver = to_usb_serial_driver(drv);
if (driver == port->serial->type)//将设备和驱动进行匹配
return 1; return 0;
} 接下来调用probe函数，也就是usb_serial_device_probe 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; } retval = device_create_file(dev, &dev_attr_port_number);
if (retval) goto exit; minor = port->number;
tty_register_device (usb_serial_tty_driver, minor, dev); dev_info(&port->serial->dev->dev, "%s converter now attached to ttyUSB%d\n", driver->description, minor); exit:
return retval; } 其中，调用了tty_register_device将tty_driver和device绑定，注册该驱动控制的设备 到了这一步完成了tty和usb的注册，同时也在/dev目录下创建了相应的设备文件，也就是说应用层可以使用这个设备了。
分析玩整个注册过程，接下来当然时分析它的读写过程了，读写过程相对来说
会感觉容易一点，因为他们没有太多错综复杂的关系，各功能函数相对独立 要使用设备当然要先打开这个设备了，应用层调用open系统调用来打开这个设备，他最终
调用到tty_driver的open函数 static const 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函数：
serial = usb_serial_get_by_index(tty->index) //将tty指针（终端）中获取相应的usb_serial结构体上
port = serial->port[portNumber]; //获取设备对应的port对象
++port->port.count;记录打开次数
tty->driver_data=port; //保存相应的port信息到该终端(tty)的私有指针里
serial->type->open(tty,port,flip);//usb_serial_generic_device.open=usb_serial_generic_open
所以，将会调用usb_serial_generic_open函数 一下分析int usb_serial_generic_open (struct usb_serial_port *port, struct file *filp)
int usb_serial_generic_open (struct usb_serial_port *port, struct file *filp)
{ .. .. .. .. /* if we have a bulk endpoint, 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);//使用函数usb_submit_urb //将urb提交到usb_core，成功后若接受到数据将会执行 //usb_serial_generic_read_bulk_callback
if (result) dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result); } return result;
} 分析usb_serial_generic_read_bulk_callback(struct urb *urb) void usb_serial_generic_read_bulk_callback (struct urb *urb) { struct usb_serial_port *port = (struct usb_serial_port *)urb->context; unsigned char *data = urb->transfer_buffer; int status = urb->status; unsigned long flags; .. .. usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data); /* Throttle the device if requested by tty */
spin_lock_irqsave(&port->lock, flags); if (!(port->throttled = port->throttle_req)) { spin_unlock_irqrestore(&port->lock, flags); flush_and_resubmit_read_urb(port); } else { spin_unlock_irqrestore(&port->lock, flags); } } 其中，调用函数flush_and_resubmit_read_urb(port) //将数据放入tty驱动的缓冲区中 /* Push data to tty layer and resubmit the bulk read URB */
static void flush_and_resubmit_read_urb (struct usb_serial_port *port)
{ struct urb *urb = port->read_urb; struct tty_struct *tty = port->tty; int room; /* Push data to tty */
if (tty && urb->actual_length) { room = tty_buffer_request_room(tty, urb->actual_length); if (room) { tty_insert_flip_string(tty, urb->transfer_buffer, room); tty_flip_buffer_push(tty); } } resubmit_read_urb(port, GFP_ATOMIC);//继续传输
} 最后调用的函数resubmit_read_urb(port, GFP_ATOMIC);
static void resubmit_read_urb(struct usb_serial_port *port, gfp_t mem_flags)
{ struct urb *urb = port->read_urb; struct usb_serial *serial = port->serial; int result; /* Continue reading from device */
usb_fill_bulk_urb (urb, serial->dev, usb_rcvbulkpipe (serial->dev, port->bulk_in_endpointAddress), urb->transfer_buffer, 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(urb, mem_flags); if (result) dev_err(&port->dev, "%s - failed resubmitting read urb, error %d\n", __FUNCTION__, result); } 在函数里又调用了usb_submit_urb函数，起到递归的作用。
至此，打开设备和读设备的流程已经写完 最后看serial_write函数，该函数对应了usb_serial_generic_write
int usb_serial_generic_write(struct usb_serial_port *port, const unsigned char *buf, int count)
{ struct usb_serial *serial = port->serial; .. .. .. /* only do something if we have a bulk out endpoint */
if (serial->num_bulk_out) { unsigned long flags; spin_lock_irqsave(&port->lock, flags); if (port->write_urb_busy) { spin_unlock_irqrestore(&port->lock, flags); dbg("%s - already writing", __FUNCTION__); return 0; } port->write_urb_busy = 1; spin_unlock_irqrestore(&port->lock, flags); count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
//将数据存放进urb中 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 */
//初始化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; //提交urb到usb core中 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); .. .. } 当serial_write函数的urb成功提交到usb_core后，若urb被成功的传递到USB设备后，将会调用回调函数
usb_serial_generic_write_bulk_callback void usb_serial_generic_write_bulk_callback (struct urb *urb)
{ struct usb_serial_port *port = (struct usb_serial_port *)urb->context; int status = urb->status; dbg("%s - port %d", __FUNCTION__, port->number);
port->write_urb_busy = 0;
if (status) { dbg("%s - nonzero write bulk status received: %d", __FUNCTION__, status); return; } usb_serial_port_softint(port); //请求更多的传输
} |
|
|
