usb_serial部分分析4

最新推荐文章于 2022-04-14 14:53:55 发布
最新推荐文章于 2022-04-14 14:53:55 发布
阅读量975 收藏 2
点赞数
分类专栏： USB

转自http://blog.csdn.net/aaronychen/article/details/3555885

接着看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过程.

 


qingkongyeyue
关注
专栏目录
Linux的USB-Serial 代码跟踪
新时代农民工
03-30 4286
我们在Linux dev目录看到的ttyUSB*一系列的终端，这些读写在Linux底层是如何处理的呢？ 首先看USB serial 核心层，kernel\drivers\usb\serial\usb-serial.c文件里面实现 static void __exit usb_serial_exit(void) { usb_serial_console_exit();
usb-serial.c
06-27 700
这两周都在调GPS， 用的是usb转串口的pl2303芯片，所以涉及到了usb-serial驱动，见解如下。int usb_serial_register(struct usb_serial_driver *driver) { /* must be called with BKL held */ int retval; if (usb_disabled())
USB-serial驱动分析(usb转串口)
热门推荐
xmzzy2012的专栏
01-05 2万+
转自：http://blog.csdn.net/istone107/article/details/8123482  在linux 内核中，有一个叫 usbserial 的模块可用作 usb modem 的驱动并能良好的工作, 所以详细 的分析下 usbserial 模块的源码(2.6.31)。对于那些仅仅是用 USB 来通信, 在上层可看作 tty 设备, 不属 于任何 USB 设备类型,
usb-serial-1
openCpu
01-19 4455
1. 插入华为e261 [root@medconn]# usb 1-1.3: usbfs: process 919 (3g-modem) did not claim interface 0 before use usb 1-1.3: USB disconnect, address 3 usb 1-1.3: new full speed USB device using s3c2410-ohci
usb转串口——u_serial.c_1
qq_20376499的博客
11-19 776
static int gs_buf_alloc(struct gs_buf *gb, unsigned size) { gb->buf_buf = kmalloc(size, GFP_KERNEL); if (gb->buf_buf == NULL) return -ENOMEM; gb->buf_size = size; gb->buf_put = gb->buf_buf; gb->buf_get = gb->buf_buf; return .
Quectel_Linux_USB_Serial_Option_Driver_20210205.tgz
09-17
USB串行选项驱动则是其中的一部分，负责处理USB接口与串行端口之间的交互。 2. **USB串行选项驱动** USB串行选项驱动是一种将USB设备模拟为串行（UART）设备的驱动程序。这种驱动使得Linux系统能将Quectel模块视为...
wdf_kmdf_basic_src.zip_SERIAL_USB-IF _kmdf_serial port_wdf usb
09-19
在驱动开发中，与USB-IF相关的部分通常涉及USB设备的识别、枚举、数据传输和电源管理。KMDF（Kernel-Mode Driver Framework）是WDF的一个子集，用于构建内核模式驱动程序，它为USB设备驱动提供了一种结构化的方法来...
NIOS_II.rar_nios usb_usb nios_usb oscilloscope_数字示波器_频谱分析仪
09-20
USB（Universal Serial Bus）接口在现代电子设备中无处不在，提供了高速的数据传输能力。在嵌入式系统中，实现USB功能能够使设备与个人计算机或其他设备进行通信，极大地扩展了其应用范围。在描述中提到的代码中，...
FPGAluojidaima.rar_100m_DRAM_USB 分析_逻辑分析_逻辑分析仪
07-14
标题"FPGAluojidaima.rar_100m_DRAM_USB 分析_逻辑分析_逻辑分析仪"指的是一个基于FPGA实现的100MHz带宽的逻辑分析仪项目，该分析仪具备对DRAM（动态随机存取内存）和USB（通用串行总线）信号进行分析的能力。...
T3_USB_OUT.rar_FPGA USB_T3_USB_OUT
07-14
标题中的"T3_USB_OUT.rar_FPGA USB_T3_USB_OUT"暗示了这个压缩包内容与FPGA（Field-Programmable Gate Array，现场可编程门阵列）和USB（Universal Serial Bus，通用串行总线）接口的设计有关，特别是使用了CY7C...
usb_serial部分分析3
qingkongyeyue的博客
07-01 730
转自http://blog.csdn.net/aaronychen/article/details/3555885 generic.c: static int generic_probe(struct usb_interface *interface,                             const struct usb_device_id *id) {     
通过修改内核提高3G上网卡设备速率(usbserial.c)
CROB's Blog
02-12 5345
由于linux内核中usbserial模块是为低速usb设备所设计，无法应对目前的3G无线USB上网卡设备的高速模式，所以虽然在linux下可正常拔号，最高速度仍然只能达到62K/s，为解决此问题可通过修改linux内核代码中的usbserial来完成。 参考链接: http://www.linuxsir.org/bbs/thread350300.html由于以上链接是基于2.6.28
usb转串口——u_serial.c_2
qq_20376499的博客
11-23 743
将数据送到tty层，由tty继续处理，数据在req的buffer里面。 static void gs_rx_push(unsigned long _port) { struct gs_port *port = (void *)_port; struct tty_struct *tty; struct list_head *queue = &port->read_queue; bool disconnect = false; bool do_push = fa...
usb-serial分析
04-24 7514
重要文件由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部分分析2
qingkongyeyue的博客
07-01 1060
转自http://blog.csdn.net/aaronychen/article/details/3555885 好了,是时候分析usbserial模块了.   我们知道当把一个模块加载进系统时会调用这个模块里的一个由module_init()声明的一个初始化函数. usbserial当然也不另外, usb-serial.c: module_init(usb_serial_i
linux 修改 usb-serial.c 提升3G上网速度
连志安
07-08 1480
Linux原有的USB驱动是针对低速USB设计的，，它的缓存开的太小。因此，3G上网卡的网速并没有达到evdo的正常速度。 在没有修改内核源码之前：root@DayDream:/home# ping 114.114.114.114 PING 114.114.114.114 (114.114.114.114): 56 data bytes 64 bytes from 114.114.114.114:
linux 3g 模块总usb总断开链接,USB 3G卡热插拔那些事3------usb serial驱动
weixin_35462903的博客
05-12 308
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 *p...
openwrt系统 3G 4G模块配置
liupin2008的博客
04-14 1948
openwrt系统 3G 4G模块网络配置文件，主要配置文件/etc/config/network： config interface ‘wan’         option device ‘/dev/cdc-wdm0’         option proto ‘qmi’         option service ‘umts’        
Linux下USB串口： PL2303调试
御风牧云的代码笔记
01-11 2818
一、CONFIG配置 Linux Kernel 早在2.6的版本已经加入了对USB Serial设备的支持，只需要在CONFIG文件中添加对该设备的支持即可。 CONFIG_USB_SERIAL=y CONFIG_USB_SERIAL_CONSOLE=y CONFIG_USB_SERIAL_PL2303=y 添加该支持后，连接PL2303串口，可以看到dev下已经有了对应的节点：ttyUS...
Linux USB-SERIAL驱动详解与代码分析
- `console.c`: 如果`CONFIG_USB_SERIAL_CONSOLE`启用，这部分代码提供串口控制台功能，允许通过USB-Serial接口进行系统调试。 深入研究这些源代码，可以了解到USB设备如何被识别、初始化，以及如何在Linux内核中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值