SDIO接口WiFi驱动浅析

阳光穿透心脏的1/2处 2022-06-09 00:10 317阅读 0赞

SDIO-Wifi模块是基于SDIO接口的符合wifi无线网络标准的[嵌入式][Link 1]模块，内置无线网络协议IEEE802.11协议栈以及TCP/IP协议栈，能够实现用户主平台数据通过SDIO口到无线网络之间的转换。SDIO具有传输数据快，兼容SD、MMC接口等特点。

对于SDIO接口的wifi，首先，它是一个sdio的卡的设备，然后具备了wifi的功能，所以，注册的时候还是先以sdio的卡的设备去注册的。然后检测到卡之后就要驱动他的wifi功能了，显然，他是用sdio的协议，通过发命令和数据来控制的。下面先简单回顾一下SDIO的相关知识：

**一、SDIO相关基础知识解析**

**1、SDIO接口**

**SDIO** 故名思义，就是 **SD 的 I/O 接口（interface）**的意思，不过这样解释可能还有点抽像。更具体的说明，SD 本来是记忆卡的标准，但是现在也可以把 SD 拿来插上一些外围接口使用，这样的技术便是 SDIO。

所以 SDIO 本身是一种相当单纯的技术，透过 SD 的 I/O 接脚来连接外部外围，并且透过 SD 上的 I/O 数据接位与这些外围传输数据，而且 SD 协会会员也推出很完整的 SDIO stack 驱动程序，使得 SDIO 外围（我们称为**SDIO 卡**）的开发与应用变得相当热门。

现在已经有非常多的手机或是手持装置都支持 SDIO 的功能（SD 标准原本就是针对 mobile device 而制定），而且许多 SDIO 外围也都被开发出来，让手机外接外围更加容易，并且开发上更有弹性（不需要内建外围）。目前常见的 SDIO 外围（SDIO 卡）有：

· Wi-Fi card（无线网络卡）

· CMOS sensor card（照相模块）

· GPS card

· GSM/GPRS modem card

· Bluetooth card

SDIO 的应用将是未来嵌入式系统最重要的接口技术之一，并且也会取代目前 GPIO 式的 SPI 接口。

**2、SDIO总线**

SDIO总线 和 USB总线 类似，SDIO也有两端，其中一端是HOST端，另一端是device端。**所有的通信都是由HOST端 发送 命令 开始的，Device端只要能解析命令，就可以相互通信**。

CLK信号:HOST给DEVICE的 时钟信号，每个时钟周期传输一个命令。

CMD信号：双向 的信号，用于传送 命令 和 反应。

DAT0-DAT3 信号:四条用于传送的数据线。

VDD信号:电源信号。

VSS1，VSS2:电源地信号。

**3、SDIO热插拔原理**

方法：设置一个 **定时器检查** 或 **插拔中断检测**

硬件：假如GPG10（EINT18）用于SD卡检测

GPG10 为高电平 即没有插入SD卡

GPG10为低电平 即插入了SD卡

**4、SDIO命令**

SDIO总线上都是HOST端发起请求，然后DEVICE端回应请求。sdio命令由6个字节组成。

a -- Command:用于开始传输的命令，是由HOST端发往DEVICE端的。其中命令是通过CMD信号线传送的。

b -- Response:回应是DEVICE返回的HOST的命令，作为Command的回应。也是通过CMD线传送的。

c -- Data:数据是双向的传送的。可以设置为1线模式，也可以设置为4线模式。数据是通过DAT0-DAT3信号线传输的。

SDIO的每次操作都是由HOST在CMD线上发起一个CMD，对于有的CMD，DEVICE需要返回Response，有的则不需要。

对于读命令，首先HOST会向DEVICE发送命令，紧接着DEVICE会返回一个握手信号，此时，当HOST收到回应的握手信号后，会将数据放在4位的数据线上，在传送数据的同时会跟随着CRC校验码。当整个读传送完毕后，HOST会再次发送一个命令，通知DEVICE操作完毕，DEVICE同时会返回一个响应。

对于写命令，首先HOST会向DEVICE发送命令，紧接着DEVICE会返回一个握手信号，此时，当HOST收到回应的握手信号后，会将数据放在4位的数据线上，在传送数据的同时会跟随着CRC校验码。当整个写传送完毕后，HOST会再次发送一个命令，通知DEVICE操作完毕，DEVICE同时会返回一个响应。

**二、SDIO接口驱动**

前面讲到，SDIO接口的wifi，首先，它是一个sdio的卡的设备，然后具备了wifi的功能，所以SDIO接口的WiFi驱动就是在wifi驱动外面套上了一个SDIO驱动的外壳，SDIO驱动仍然符合**设备驱动的分层与分离思想**：

设备驱动层（wifi 设备）

核心层（向上向下提供接口）

主机驱动层 （实现SDIO驱动）

下面先分析SDIO接口驱动的实现，看几个重要的[数据结构][Link 2]（用于核心层与主机驱动层 的数据交换处理）。

\[ /include/[Linux][]/mmc/host.h \]

struct mmc\_host 用来描述卡控制器

struct mmc\_card 用来描述卡

struct mmc\_driver 用来描述 mmc 卡驱动

struct sdio\_func 用来描述 功能设备

struct mmc\_host\_ops 用来描述卡控制器操作接口函数功能，用于从 主机控制器层向 core 层注册操作函数，从而将core 层与具体的主机控制器隔离。也就是说 core 要操作主机控制器，就用这个 ops 当中给的函数指针操作，不能直接调用具体主控制器的函数。

HOST层驱动分析在 前面的系列文章中 [Linux SD卡驱动开发(二) —— SD 卡驱动分析HOST篇][Linux SD_ _ SD _HOST] 有详细阐述，下面只简单回顾一下一些重要函数处理

**1、编写Host层驱动**

这里参考的是S3C24XX的HOST驱动程序 /drivers/mmc/host/s3cmci.c

**\[cpp\]** [view plain][] [copy][view plain]

1.  **static****struct** platform\_driver s3cmci\_driver = \{ 
2.   .driver = \{ 
3.   .name = "s3c-sdi", //名称和平台设备定义中的对应
4.   .owner = THIS\_MODULE, 
5.   .pm = s3cmci\_pm\_ops, 
6.   \}, 
7.   .id\_table = s3cmci\_driver\_ids, 
8.   .probe = s3cmci\_probe, //平台设备探测接口函数
9.   .remove = \_\_devexit\_p(s3cmci\_remove), 
10.  .shutdown = s3cmci\_shutdown, 
11. \}; 
12. 
13. s3cmci\_probe(**struct** platform\_device \*pdev) 
14. \{ 
15. //....
16. **struct** mmc\_host \*mmc; 
17.  mmc = mmc\_alloc\_host(**sizeof**(**struct** s3cmci\_host), &pdev->dev); //分配mmc\_host结构体
18. 
19. //.....
20. \} 
21. 
22. /\*注册中断处理函数s3cmci\_irq,来处理数据收发过程引起的各种中断\*/
23. request\_irq(host->irq, s3cmci\_irq, 0, DRIVER\_NAME, host) //注册中断处理函数s3cmci\_irq
24. 
25. /\*注册中断处理s3cmci\_irq\_cd函数,来处理热拨插引起的中断，中断触发的形式为上升沿、下降沿触发\*/
26. request\_irq(host->irq\_cd, s3cmci\_irq\_cd,IRQF\_TRIGGER\_RISING |IRQF\_TRIGGER\_FALLING, DRIVER\_NAME, host) 
27. 
28. mmc\_add\_host(mmc); //initialise host hardware //向MMC core注册host驱动
29. \----> device\_add(&host->class\_dev); //添加设备到mmc\_bus\_type总线上的设备链表中
30. \----> mmc\_start\_host(host); //启动mmc host
31. 
32. /\*MMC drivers should call this when they detect a card has been inserted or removed.检测sd卡是否插上或移除\*/
33.  \---->mmc\_detect\_change(host, 0); 
34. 
35. /\*Schedule delayed work in the MMC work queue.调度延时工作队列\*/
36.  mmc\_schedule\_delayed\_work(&host->detect, delay);

搜索host->detected得到以下信息：

\[/drivers/mmc/core/host.c\]

**\[cpp\]** [view plain][] [copy][view plain]

1.  NIT\_DELAYED\_WORK(&host->detect, mmc\_rescan); 
2.  
3.  mmc\_rescan(**struct** work\_struct \*work) 
4.  \---->mmc\_bus\_put(host);//card 从bus上移除时，释放它占有的总线空间
5.  
6.  /\*判断当前mmc host控制器是否被占用,当前mmc控制器如果被占用,那么 host->claimed = 1;否则为0
7.   \*如果为1,那么会在while(1)循环中调用schedule切换出自己,当占用mmc控制器的操作完成之后,执行 \*mmc\_release\_host()的时候,会激活登记到等待队列&host->wq中的其他 程序获得mmc主控制器的使用权
8.   \*/
9.  mmc\_claim\_host(host); 
10.  mmc\_rescan\_try\_freq(host, max(freqs\[i\], host->f\_min)； 
11. 
12. **static****int** mmc\_rescan\_try\_freq(**struct** mmc\_host \*host, unsigned freq) 
13. \{ 
14.  … 
15. /\* Order's important: probe SDIO, then SD, then MMC \*/
16. **if** (!mmc\_attach\_sdio(host)) 
17. **return** 0; 
18. **if** (!mmc\_attach\_sd(host)) 
19. **return** 0; 
20. **if** (!mmc\_attach\_mmc(host)) 
21. **return** 0; 
22.  …. 
23. \} 
24. 
25. mmc\_attach\_sdio(**struct** mmc\_host \*host) //匹配sdio接口卡
26.  \--->mmc\_attach\_bus(host, &mmc\_sdio\_ops); 
27. 
28. /\*当card与总线上的驱动匹配，就初始化card\*/
29. mmc\_sdio\_init\_card(host, host->ocr, NULL, 0); 
30.  \--->card = mmc\_alloc\_card(host, NULL);//分配一个card结构体
31.  mmc\_set\_bus\_mode(host, MMC\_BUSMODE\_PUSHPULL); //设置mmc\_bus的工作模式
32. 
33. **struct** sdio\_func \*sdio\_func\[SDIO\_MAX\_FUNCS\]; //SDIO functions (devices)
34. 
35. sdio\_init\_func(host->card, i + 1); 
36.  \--->func = sdio\_alloc\_func(card); //分配struct sdio\_fun（sdio功能设备）结构体
37.  mmc\_io\_rw\_direct（）; 
38.  card->sdio\_func\[fn - 1\] = func; 
39. 
40. mmc\_add\_card(host->card); //将具体的sdio设备挂载到mmc\_bus\_types 总线
41. sdio\_add\_func(host->card->sdio\_func\[i\]); //将sdio功能设备挂载到sdio\_bus\_types总线

这里一系列函数调用在前面的SD驱动蚊帐中已经阐述过了，不再详细阐述

**2、SDIO设备的热插拔**

当插拔SDIO设备，会触发中断通知到CPU，然后执行卡检测中断处理函数在这个中断服务函数中，mmc\_detect\_change->mmc\_schedule\_delayed\_work(&host->detect,delay), INIT\_DELAYED\_WORK(&host->detect, mmc\_rescan)会调度mmc\_rescan函数延时调度工作队列，这样也会触发SDIO设备的初始化流程，检测到有效的SDIO设备后，会将它注册到系统中去。

**\[cpp\]** [view plain][] [copy][view plain]

1.  **static** irqreturn\_t s3cmci\_irq\_cd(**int** irq, **void** \*dev\_id) 
2.  \{ 
3.  **struct** s3cmci\_host \*host = (**struct** s3cmci\_host \*)dev\_id; 
4.   ........ 
5.   mmc\_detect\_change(host->mmc, msecs\_to\_jiffies(500)); 
6.  
7.  **return** IRQ\_HANDLED; 
8.  \}

**三、wifi 驱动部分解析**

wifi驱动的通用的软件[架构][Link 3]

1. 分为两部分，上面为主机端驱动，下面是我们之前所说的firmware

2. 其中固件部分的主要工作是：因为天线接受和发送回来的都是802.11帧的帧，而主机接受和传送出来的数据都必须是802.3的帧，所以必须由firmware来负责802.3的帧和802.11帧之间的转换

3. 当天线收到数据，并被firmware处理好后会放在一个buffer里，并产生一个中断，主机在收到中断后就去读这个buffer。

SDIO设备的驱动由sdio\_driver结构体定义，sdio\_driver其实是driver的封装。通过sdio\_register\_driver函数将SDIO设备驱动加载进内核，其实就是挂载到sdio\_bus\_type总线上去。

**1、设备驱动的注册与匹配**

\[Drivers/net/wireless/libertas/if\_sdio.c\]

**\[cpp\]** [view plain][] [copy][view plain]

1.  /\* SDIO function device driver\*/
2.  
3.  **struct** sdio\_driver \{ 
4.  **char** \*name; //设备名
5.  **const****struct** sdio\_device\_id \*id\_table; //设备驱动ID
6.  **int** (\*probe)(**struct** sdio\_func \*, **const****struct** sdio\_device\_id \*);//匹配函数
7.  **void** (\*remove)(**struct** sdio\_func \*); 
8.  **struct** device\_driver drv; 
9.  \};

**下面是具体函数的填充：**

**\[cpp\]** [view plain][] [copy][view plain]

1.  /\*if\_sdio.c\*/
2.  
3.  **static****struct** sdio\_driver if\_sdio\_driver = \{ 
4.   .name = "libertas\_sdio", 
5.   .id\_table = if\_sdio\_ids, //用于设备与驱动的匹配
6.   .probe = if\_sdio\_probe, 
7.   .remove = if\_sdio\_remove, 
8.   .drv = \{ 
9.   .pm = &if\_sdio\_pm\_ops, 
10.  \} 
11. \};

设备注册函数

**\[cpp\]** [view plain][] [copy][view plain]

1.  /\*\*
2.   \* sdio\_register\_driver - register a function driver
3.   \* @drv: SDIO function driver
4.   \*/
5.  
6.  **int** sdio\_register\_driver(**struct** sdio\_driver \*drv) 
7.  \{ 
8.   drv->drv.name = drv->name; 
9.   drv->drv.bus = &sdio\_bus\_type; //设置driver的bus为sdio\_bus\_type
10. **return** driver\_register(&drv->drv); 
11. \}

总线函数

**\[cpp\]** [view plain][] [copy][view plain]

1.  **static****struct** bus\_type sdio\_bus\_type = \{ 
2.   .name = "sdio", 
3.   .dev\_attrs = sdio\_dev\_attrs, 
4.   .match = sdio\_bus\_match, 
5.   .uevent = sdio\_bus\_uevent, 
6.   .probe = sdio\_bus\_probe, 
7.   .remove = sdio\_bus\_remove, 
8.   .pm = SDIO\_PM\_OPS\_PTR, 
9.  \};

注意：设备或者驱动注册到系统中的过程中，都会调用相应bus上的匹配函数来进行匹配合适的驱动或者设备，对于sdio设备的匹配是由**sdio\_bus\_match**和**sdio\_bus\_probe**函数来完成。

**\[cpp\]** [view plain][] [copy][view plain]

1.  **static****int** sdio\_bus\_match(**struct** device \*dev, **struct** device\_driver \*drv) 
2.  \{ 
3.  **struct** sdio\_func \*func = dev\_to\_sdio\_func(dev); 
4.  **struct** sdio\_driver \*sdrv = to\_sdio\_driver(drv); 
5.  **if** (sdio\_match\_device(func, sdrv)) 
6.  **return** 1; 
7.  
8.  **return** 0; 
9.  \} 
10. 
11. **static****const****struct** sdio\_device\_id \*sdio\_match\_device(**struct** sdio\_func \*func, 
12. **struct** sdio\_driver \*sdrv) 
13. \{ 
14. **const****struct** sdio\_device\_id \*ids; 
15.  ids = sdrv->id\_table; 
16. 
17. **if** (sdio\_match\_one(func, ids)) 
18. **return** ids; 
19. \}

由以上匹配过程来看，通过匹配id\_table 和 sdio\_driver设备驱动中id，来匹配合适的驱动或设备。最终会调用.probe函数，来完成相关操作。

**2、If\_sdio\_probe函数**

当检测到sdio卡插入了之后就会调用**If\_sdio\_probe**，而当卡被移除后就会调用**I****f\_sdio\_remove**。

![Center][]

下面先看下**If\_sdio\_probe**t函数，if\_sdio\_prob 函数 主要做了两件事

**\[cpp\]** [view plain][] [copy][view plain]

1.  **static****struct** sdio\_driver if\_sdio\_driver = \{ 
2.   .name = "libertas\_sdio", 
3.   .id\_table = if\_sdio\_ids, //用于设备和驱动的匹配
4.   .probe = if\_sdio\_probe, 
5.   .remove = if\_sdio\_remove, 
6.   .drv = \{ 
7.   .pm = &if\_sdio\_pm\_ops, 
8.   \}, 
9.  \}; 
10. 
11. 
12. 1 //定义一个 if\_sdio card的结构体
13. **struct** if\_sdio\_card \*card; 
14. **struct** if\_sdio\_packet \*packet; //sdio 包的结构体 
15. **struct** mmc\_host \*host = func->card->host; 
16. 
17. // 查询是否有指定的功能寄存器在mmc
18. //\_sdio\_card中
19. **for** (i = 0;i < func->card->num\_info;i++) \{ 
20. **if** (sscanf(func->card->info\[i\], 
21. "802.11 SDIO ID: %x", &model) == 1) 
22. 
23. //在这里进行片选 选择到我们使用的marvell 8686 的设备
24. **case** MODEL\_8686: 
25.  card->scratch\_reg = IF\_SDIO\_SCRATCH; 
26. 
27. 
28. //创建sdio 的工作队列 
29. card->workqueue = create\_workqueue("libertas\_sdio"); 
30. //调用下面的函数
31. INIT\_WORK(&card->packet\_worker, if\_sdio\_host\_to\_card\_worker); 
32. 
33. 
34. //主机到卡的工作队列
35. **static****void** if\_sdio\_host\_to\_card\_worker(**struct** work\_struct \*work) 
36. 
37. /\* Check if we support this card 选择我们所支持的卡的类型\*/
38. //赋值为sd8686\_helper.bin sd8686.bin
39. /\*fw\_table 中的 MODEL\_8686, "sd8686\_helper.bin", "sd8686.bin" \},?/ 
40. **for** (i = 0; i < ARRAY\_SIZE(fw\_table); i++) \{ 
41. **if** (card->model == fw\_table\[i\].model) 
42. **break**; 
43.  \} 
44.  \{ MODEL\_8688, "libertas/sd8688\_helper.bin", "libertas/sd8688.bin" \}, 
45. 
46. 
47. //申请一个host
48. sdio\_claim\_host(func); 
49. //使能sdio 的功能 寄存器
50. ret = sdio\_enable\_func(func); 
51. **if** (ret) 
52. **goto** release; 
53. 
54. 2//申请 sdio 的中断 当有数据 ,命令 或者是事件 的时间执行中断
55. ret = sdio\_claim\_irq(func, if\_sdio\_interrupt); 
56. ret = if\_sdio\_card\_to\_host(card); //从无线网卡接收到数据 或者说是上报数据
57. ret = if\_sdio\_handle\_data(card, card->buffer + 4, chunk - 4); //接收数据的处理 
58. ret = if\_sdio\_handle\_cmd(card, card->buffer + 4, chunk - 4); //处理申请的命令中断
59. ret = if\_sdio\_handle\_event(card, card->buffer + 4, chunk - 4);//处理申请的事件中断
60. 
61. 
62. //添加网络结构体 分配设备并注册
63. priv = lbs\_add\_card(card, &func->dev); 
64. 
65. //分配Ethernet设备并注册 
66.  wdev = lbs\_cfg\_alloc(dmdev); 
67. //802无线网的具体的操作函数 
68. wdev->wiphy = wiphy\_new(&lbs\_cfg80211\_ops, **sizeof**(**struct** lbs\_private)); 
69. 
70. 
71. //分配网络设备是整个网络部分操作的
72. //的核心结构体
73. dev = alloc\_netdev(0, "wlan%d", ether\_setup); //实例化wlan0的属性
74. dev->ieee80211\_ptr = wdev; 
75.  dev->ml\_priv = priv; 
76. //设置设备的物理地址 
77.  SET\_NETDEV\_DEV(dev, dmdev); 
78.  wdev->netdev = dev; 
79.  priv->dev = dev; 
80. //初始化网络设备 ops. 看门狗 
81.  dev->netdev\_ops = &lbs\_netdev\_ops; //网络设备的具体的操作函数 
82.  dev->watchdog\_timeo = 5 \* HZ; 
83.  dev->ethtool\_ops = &lbs\_ethtool\_ops; 
84.  dev->flags |= IFF\_BROADCAST | IFF\_MULTICAST; //广播或者多播
85. 
86. 
87. 
88. //启动一个内核线程来管理这个网络设备的数据发送,事件的处理(卡的拔出)和一些命令的处理 
89.  priv->main\_thread = kthread\_run(lbs\_thread, dev, "lbs\_main"); 
90. //初始化相关的工作队列
91.  priv->work\_thread = create\_singlethread\_workqueue("lbs\_worker"); 
92.  INIT\_WORK(&priv->mcast\_work, lbs\_set\_mcast\_worker); 
93.  priv->wol\_criteria = EHS\_REMOVE\_WAKEUP; 
94.  priv->wol\_gpio = 0xff; 
95.  priv->wol\_gap = 20; 
96.  priv->ehs\_remove\_supported = **true**; 
97. 
98. 
99. //设置私有变量 
100. //设置主机发送数据到卡
101.  priv->hw\_host\_to\_card = if\_sdio\_host\_to\_card; 
102.  priv->enter\_deep\_sleep = if\_sdio\_enter\_deep\_sleep; 
103.  priv->exit\_deep\_sleep = if\_sdio\_exit\_deep\_sleep; 
104.  priv->reset\_deep\_sleep\_wakeup = if\_sdio\_reset\_deep\_sleep\_wakeup; 
105.  sdio\_claim\_host(func); 
106. 
107. //启动卡设备 
108.  ret = lbs\_start\_card(priv); 
109. **if** (lbs\_cfg\_register(priv)) 
110. 
111.  ret = register\_netdev(priv->dev); 
112.  err = register\_netdevice(dev); 
113. 
114. 
115. //具体的wifi设备驱动功能 
116. //网络设备操作的具体函数 
117. **static****const****struct** net\_device\_ops lbs\_netdev\_ops = \{ 
118.  .ndo\_open = lbs\_dev\_open, //打开
119.  .ndo\_stop = lbs\_eth\_stop, //停止
120.  .ndo\_start\_xmit = lbs\_hard\_start\_xmit, //开始发送数据
121.  .ndo\_set\_mac\_address = lbs\_set\_mac\_address, //设置mac地址 
122.  .ndo\_tx\_timeout = lbs\_tx\_timeout, //发送超时
123.  .ndo\_set\_multicast\_list = lbs\_set\_multicast\_list, //多播地址
124.  .ndo\_change\_mtu = eth\_change\_mtu, //最大传输单元
125.  .ndo\_validate\_addr = eth\_validate\_addr, //判断地址的有效性

**3、数据的接收,通过中断的方式来解决**

网络设备接收数据的主要方法是由中断引发设备的中断处理函数，中断处理函数判断中断的类型，如果为接收中断，则读取接收到的数据，分配sk\_buff数据结构和数据缓冲区，并将接收的数据复制到数据缓存区，并调用netif\_rx()函数将sk\_buff传递给上层协议。

搜索if\_sdio\_interrupt，可知道它是在if\_sdio.c文件中if\_sdio\_probe()函数中sdio\_claim\_irq(func, if\_sdio\_interrupt) ，func->irq\_handler = if\_sdio\_interrupt。当s3cmci\_irq中断处理函数的S3C2410\_SDIIMSK\_SDIOIRQ 中断被触发时将调用if\_sdio\_interrupt()函数，进行接收数据。

**\[cpp\]** [view plain][] [copy][view plain]

1.  **static****void** if\_sdio\_interrupt(**struct** sdio\_func \*func) 
2.  
3.  ret = if\_sdio\_card\_to\_host(card); //从无线网卡接收到数据 或者说是上报数据
4.  //读取端口上的数据 ,放到card的buffer中 
5.   ret = sdio\_readsb(card->func, card->buffer, card->ioport, chunk); 
6.  1.在这里一方面处理中断 还有2 
7.  **switch** (type) \{ //处理cmd data event的请求 
8.  **case** MVMS\_CMD: 
9.   ret = if\_sdio\_handle\_cmd(card, card->buffer + 4, chunk - 4); //处理申请的命令中断
10. **if** (ret) 
11. **goto** out; 
12. **break**; 
13. **case** MVMS\_DAT: 
14.  ret = if\_sdio\_handle\_data(card, card->buffer + 4, chunk - 4);//处理申请的数据中断 
15. **if** (ret) 
16. **goto** out; 
17. **break**; 
18. **case** MVMS\_EVENT: 
19.  ret = if\_sdio\_handle\_event(card, card->buffer + 4, chunk - 4);//处理申请的事件中断
20. 
21. //读取包的过程 
22.  lbs\_process\_rxed\_packet(card->priv, skb); 
23. 
24. //如果是中断 ,就把skb这个包提交给协议层,这个函数是
25. //协议层提供的 netif\_rx(skb)
26. **if** (in\_interrupt()) 
27.  netif\_rx(skb); //提交给协议层 
28. 
29. 
30. 2//读取端口上的数据 ,放到card的buffer中 
31.  ret = sdio\_readsb(card->func, card->buffer, card->ioport, chunk); 
32. //读取地址,目的地址,数量 等
33. **int** sdio\_readsb(**struct** sdio\_func \*func, **void** \*dst, unsigned **int** addr, **int** count) 
34. 
35. **return** sdio\_io\_rw\_ext\_helper(func, 0, addr, 0, dst, count); 
36. 
37.  ret = mmc\_io\_rw\_extended(func->card, write,func->num, addr, incr\_addr, buf,blocks, func->cur\_blksize); 
38.  cmd.arg = write ? 0x80000000 : 0x00000000; 
39. 
40. //wait for request 
41.  mmc\_wait\_for\_req(card->host, &mrq); 
42.  开始应答 
43.  mmc\_start\_request(host, mrq); 
44.  wait\_for\_completion(&complete); 
45. 
46.  host->ops->request(host, mrq);

**4、** **数据发送**

**\[cpp\]** [view plain][] [copy][view plain]

1.  //IP层通过dev\_queue\_xmit()将数据交给网络设备协议接口层,网络接口层通过netdevice中的注册函数的数据发送函数
2.  **int** dev\_queue\_xmit(**struct** sk\_buff \*skb) 
3.  
4.  **if** (!netif\_tx\_queue\_stopped(txq)) \{ 
5.   \_\_this\_cpu\_inc(xmit\_recursion); 
6.  //设备硬件开始发送 
7.   rc = dev\_hard\_start\_xmit(skb, dev, txq); 
8.  //调用wifi网络中的ops 
9.  
10.  rc = ops->ndo\_start\_xmit(skb, dev); 
11. 
12.  dev->netdev\_ops = &lbs\_netdev\_ops; //设备的操作函数 
13. 
14. //处理sdio firware数据和内核的数据main\_thread 主线程 
15.  priv->main\_thread = kthread\_run(lbs\_thread, dev, "lbs\_main"); 
16. 
17. //调用host\_to\_card 即if\_sdio\_card\_to\_host函数。 
18. **int** ret = priv->hw\_host\_to\_card(priv, MVMS\_DAT,priv->tx\_pending\_buf,priv->tx\_pending\_len); 
19. 为什么是if\_sdio\_to\_host呢 ?因为在prob函数中定义了这一个 
20. //设置主机发送数据到卡
21.  priv->hw\_host\_to\_card = if\_sdio\_host\_to\_card; 
22. 
23. **static****int** if\_sdio\_host\_to\_card(**struct** lbs\_private \*priv,u8 type, u8 \*buf, u16 nb) 
24. //把buf中的数据 copy到sdio 包中,在对sdio 的包进行处理
25.  memcpy(packet->buffer + 4, buf, nb); 
26. //创建工作队列 
27.  queue\_work(card->workqueue, &card->packet\_worker); 
28. //初始化队列 
29.  INIT\_WORK(&card->packet\_worker, if\_sdio\_host\_to\_card\_worker); 
30. 
31. //sdio的写数据 
32.  ret = sdio\_writesb(card->func, card->ioport, packet->buffer, packet->nb); 
33. //mmc写扩展口 
34.  ret = mmc\_io\_rw\_extended(func->card, write,func->num, addr, incr\_addr, buf,blocks, func->cur\_blksize); 
35. 
36. //wait for request 
37.  mmc\_wait\_for\_req(card->host, &mrq); 
38. 
39.  mrq->done\_data = &complete; 
40.  mrq->done = mmc\_wait\_done; 
41.  mmc\_start\_request(host, mrq); 
42. //完成等待 写数据结束 
43.  wait\_for\_completion(&complete); 
44. 
45. 
46.  host->ops->request(host, mrq); 
47. //到底结束 发送数据

**5、移除函数**

当sdio卡拔除时，驱动会调用该函数，完成相应操作。如释放占有的资源，禁止func功能函数，释放host。

**\[cpp\]** [view plain][] [copy][view plain]

1.  if\_sdio\_remove(**struct** sdio\_func \*func) 
2.  \---->lbs\_stop\_card(card->priv); 
3.   lbs\_remove\_card(card->priv); 
4.   \---->kthread\_stop(priv->main\_thread); //终止内核线程
5.  
6.   lbs\_free\_adapter(priv); 
7.   lbs\_cfg\_free(priv); 
8.   free\_netdev(dev); 
9.  
10.  flush\_workqueue(card->workqueue); //刷新工作队列
11.  destroy\_workqueue(card->workqueue); 
12.  sdio\_claim\_host(func); 
13.  sdio\_release\_irq(func); 
14.  sdio\_disable\_func(func); 
15.  sdio\_release\_host(func); 
16.

[Link 1]: http://lib.csdn.net/base/embeddeddevelopment
[Link 2]: http://lib.csdn.net/base/datastructure
[Linux]: http://lib.csdn.net/base/linux
[Linux SD_ _ SD _HOST]: http://blog.csdn.net/zqixiao_09/article/details/51039595
[view plain]: http://blog.csdn.net/zqixiao_09/article/details/51105877#
[Link 3]: http://lib.csdn.net/base/architecture
[Center]: /images/20220609/6aa21dc29c474855af7a0c7a1fbb8197.png