driver-platform-sdio-des.md 19.5 KB
Newer Older
D
duangavin123 已提交
1 2 3 4
# SDIO

## 概述

Y
yafeng_wang 已提交
5
### 功能简介
D
duangavin123 已提交
6

Y
yafeng_wang 已提交
7 8 9 10 11 12 13 14 15 16 17 18
SDIO是安全数字输入输出接口(Secure Digital Input and Output)的缩写,是从SD内存卡接口的基础上演化出来的一种外设接口。SDIO接口兼容以前的SD卡,并且可以连接支持SDIO接口的其他设备。

SDIO接口定义了操作SDIO的通用方法集合,包括:
- 打开/关闭SDIO控制器
- 独占/释放HOST
- 使能/去使能设备
- 申请/释放中断
- 读写、获取/设置公共信息

### 运作机制

在HDF框架中,SDIO的接口适配模式采用独立服务模式。在这种模式下,每一个设备对象会独立发布一个设备服务来处理外部访问,设备管理器收到API的访问请求之后,通过提取该请求的参数,达到调用实际设备对象的相应内部方法的目的。独立服务模式可以直接借助HDFDeviceManager的服务管理能力,但需要为每个设备单独配置设备节点,若设备过多可能增加内存占用。
D
duangavin123 已提交
19

20 21 22 23 24 25
SDIO总线有两端,其中一端是主机端(HOST),另一端是设备端(DEVICE)。所有的通信都是由HOST端发出命令开始的,在DEVICE端只要能解析HOST的命令,就可以同HOST进行通信了。SDIO的HOST可以连接多个DEVICE,如下图所示:
- CLK信号:HOST给DEVICE的时钟信号。
- VDD信号:电源信号。
- VSS信号:Ground信号。
- D0-3信号:4条数据线,其中,DAT1信号线复用为中断线,在1BIT模式下DAT0用来传输数据,在4BIT模式下DAT0-DAT3用来传输数据。
- CMD信号:用于HOST发送命令和DEVICE回复响应。
D
duangavin123 已提交
26

27
**图1** SDIO的HOST-DEVICE连接示意图
D
duangavin123 已提交
28

29
![image](figures/SDIO的HOST-DEVICE连接示意图.png "SDIO的HOST-DEVICE连接示意图")
D
duangavin123 已提交
30

Y
yafeng_wang 已提交
31
### 约束与限制
D
duangavin123 已提交
32

Y
yafeng_wang 已提交
33
SDIO模块API当前仅支持内核态调用。
D
duangavin123 已提交
34

Y
yafeng_wang 已提交
35
## 使用指导
D
duangavin123 已提交
36

Y
yafeng_wang 已提交
37
### 场景介绍
D
duangavin123 已提交
38

Y
yafeng_wang 已提交
39
SDIO的应用比较广泛,目前,有许多手机都支持SDIO功能,并且很多SDIO外设也被开发出来,使得手机外接外设更加容易。常见的SDIO外设有WLAN、GPS、CAMERA、蓝牙等。
D
duangavin123 已提交
40

Y
yafeng_wang 已提交
41
### 接口说明
D
duangavin123 已提交
42

Y
yafeng_wang 已提交
43
SDIO模块提供的主要接口如表1所示,具体API详见//drivers/hdf_core/framework/include/platform/sdio_if.h。
D
duangavin123 已提交
44

Y
yafeng_wang 已提交
45
**表1** SDIO驱动API接口功能介绍
D
duangavin123 已提交
46

Y
yafeng_wang 已提交
47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
|  接口名  | 接口描述 |
| -------- | -------- |
| DevHandle SdioOpen(int16_t mmcBusNum, struct SdioFunctionConfig \*config) | 打开指定总线号的SDIO控制器 |
| void SdioClose(DevHandle handle) | 关闭SDIO控制器 |
| int32_t SdioReadBytes(DevHandle handle, uint8_t \*data, uint32_t addr, uint32_t size) | 从指定地址开始,增量读取指定长度的数据 |
| int32_t SdioWriteBytes(DevHandle handle, uint8_t \*data, uint32_t addr, uint32_t size) | 从指定地址开始,增量写入指定长度的数据 |
| int32_t SdioReadBytesFromFixedAddr(DevHandle handle, uint8_t \*data, uint32_t addr, uint32_t size, uint32_t scatterLen) | 从固定地址读取指定长度的数据 |
| int32_t SdioWriteBytesToFixedAddr(DevHandle handle, uint8_t \*data, uint32_t addr, uint32_t size, uint32_t scatterLen) | 向固定地址写入指定长度的数据 |
| int32_t SdioReadBytesFromFunc0(DevHandle handle, uint8_t \*data, uint32_t addr, uint32_t size) | 从SDIO function 0的指定地址空间读取指定长度的数据 |
| int32_t SdioWriteBytesToFunc0(DevHandle handle, uint8_t \*data, uint32_t addr, uint32_t size) | 向SDIO function 0的指定地址空间写入指定长度的数据 |
| int32_t SdioSetBlockSize(DevHandle handle, uint32_t blockSize) | 设置块的大小 |
| int32_t SdioGetCommonInfo(DevHandle handle, SdioCommonInfo \*info, SdioCommonInfoType infoType) | 获取公共信息 |
| int32_t SdioSetCommonInfo(DevHandle handle, SdioCommonInfo \*info, SdioCommonInfoType infoType) | 设置公共信息 |
| int32_t SdioFlushData(DevHandle handle) | 刷新数据 |
| void SdioClaimHost(DevHandle handle) | 独占Host |
| void SdioReleaseHost(DevHandle handle) | 释放Host |
| int32_t SdioEnableFunc(DevHandle handle) | 使能SDIO功能设备 |
| int32_t SdioDisableFunc(DevHandle handle) | 去使能SDIO功能设备 |
| int32_t SdioClaimIrq(DevHandle handle, SdioIrqHandler \*irqHandler) | 申请中断 |
| int32_t SdioReleaseIrq(DevHandle handle) | 释放中断 |
D
duangavin123 已提交
67 68 69 70 71 72 73

### 使用流程

使用SDIO的一般流程如下图所示。

  **图2** SDIO使用流程图

74
  ![image](figures/SDIO使用流程图.png "SDIO使用流程图")
D
duangavin123 已提交
75

Y
yafeng_wang 已提交
76
#### 打开SDIO控制器
W
wenjun 已提交
77 78 79

在使用SDIO进行通信前,首先要调用SdioOpen获取SDIO控制器的设备句柄,该函数会返回指定总线号的SDIO控制器的设备句柄。

Y
yafeng_wang 已提交
80
```c
D
duangavin123 已提交
81 82 83 84
DevHandle SdioOpen(int16_t mmcBusNum, struct SdioFunctionConfig *config);
```

  **表2** SdioOpen函数的参数和返回值描述
W
wenjun 已提交
85

D
duangavin123 已提交
86 87 88 89 90 91 92 93 94
| 参数 | 参数描述 | 
| -------- | -------- |
| mmcBusNum | 总线号 | 
| config | SDIO功能配置信息 | 
| **返回值** | **返回值描述** | 
| NULL | 获取SDIO控制器的设备句柄失败 | 
| 设备句柄 | SDIO控制器的设备句柄 | 

  打开SDIO控制器的示例如下:
Y
yafeng_wang 已提交
95 96

```c
N
NEEN 已提交
97
DevHandle handle = NULL;
D
duanxichao 已提交
98 99 100 101
struct SdioFunctionConfig config;
config.funcNr = 1;
config.vendorId = 0x123;
config.deviceId = 0x456;
W
wenjun 已提交
102
/* 打开总线号为1的SDIO控制器 */
D
duanxichao 已提交
103
handle = SdioOpen(1, &config);
W
wenjun 已提交
104 105 106 107 108
if (handle == NULL) {
    HDF_LOGE("SdioOpen: failed!\n");
}
```

Y
yafeng_wang 已提交
109
#### 独占HOST
W
wenjun 已提交
110 111 112

获取到SDIO控制器的设备句柄之后,需要先独占HOST才能进行SDIO后续的一系列操作,独占HOST函数如下所示:

Y
yafeng_wang 已提交
113
```c
D
duangavin123 已提交
114 115 116 117 118 119 120 121
void SdioClaimHost(DevHandle handle);
```

  **表3** SdioClaimHost函数的参数描述

| 参数 | 参数描述 | 
| -------- | -------- |
| handle | SDIO控制器的设备句柄 | 
W
wenjun 已提交
122 123 124

独占HOST示例如下:

Y
yafeng_wang 已提交
125
```c
W
wenjun 已提交
126 127 128
SdioClaimHost(handle); /* 独占HOST */
```

Y
yafeng_wang 已提交
129
#### 使能SDIO设备
W
wenjun 已提交
130 131 132

在访问寄存器之前,需要先使能SDIO设备,使能SDIO设备的函数如下所示:

Y
yafeng_wang 已提交
133
```c
D
duangavin123 已提交
134 135 136 137 138 139 140 141 142 143 144
int32_t SdioEnableFunc(DevHandle handle);
```

  **表4** SdioEnableFunc函数的参数和返回值描述

| 参数 | 参数描述 | 
| -------- | -------- |
| handle | SDIO控制器的设备句柄 | 
| **返回值** | **返回值描述** | 
| 0 | SDIO使能成功 | 
| 负数 | SDIO使能失败 | 
W
wenjun 已提交
145 146 147

使能SDIO设备的示例如下:

Y
yafeng_wang 已提交
148
```c
W
wenjun 已提交
149 150 151 152 153 154 155 156
int32_t ret;
/* 使能SDIO设备 */
ret = SdioEnableFunc(handle);
if (ret != 0) {
    HDF_LOGE("SdioEnableFunc: failed, ret %d\n", ret);
}
```

Y
yafeng_wang 已提交
157
#### 注册SDIO中断
W
wenjun 已提交
158 159 160

在通信之前,还需要注册SDIO中断,注册SDIO中断函数如下图所示:

Y
yafeng_wang 已提交
161
```c
D
duangavin123 已提交
162 163
int32_t SdioClaimIrq(DevHandle handle, SdioIrqHandler *handler);
```
W
wenjun 已提交
164

D
duangavin123 已提交
165 166 167 168 169 170 171 172 173 174 175
  **表5** SdioClaimIrq函数的参数和返回值描述

| 参数 | 参数描述 | 
| -------- | -------- |
| handle | SDIO控制器的设备句柄 | 
| handler | 中断服务函数指针 | 
| **返回值** | **返回值描述** | 
| 0 | 注册中断成功 | 
| 负数 | 注册中断失败 | 

  注册SDIO中的示例如下:
Y
yafeng_wang 已提交
176 177

```c
W
wenjun 已提交
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195
/* 中断服务函数需要根据各自平台的情况去实现 */
static void SdioIrqFunc(void *data)
{
    if (data == NULL) {
        HDF_LOGE("SdioIrqFunc: data is NULL.\n");
        return;
    }
    /* 需要开发者自行添加具体实现 */
}

int32_t ret;
/* 注册SDIO中断 */
ret = SdioClaimIrq(handle, SdioIrqFunc);
if (ret != 0) {
    HDF_LOGE("SdioClaimIrq: failed, ret %d\n", ret);
}
```

Y
yafeng_wang 已提交
196
#### 进行SDIO通信
D
duangavin123 已提交
197 198 199 200 201

- 向SDIO设备增量写入指定长度的数据

  对应的接口函数如下所示:

Y
yafeng_wang 已提交
202
  ```c
D
duangavin123 已提交
203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219
  int32_t SdioWriteBytes(DevHandle handle, uint8_t *data, uint32_t addr, uint32_t size);
  ```

  **表6** SdioWriteBytes函数的参数和返回值描述

  | 参数 | 参数描述 | 
  | -------- | -------- |
  | handle | SDIO控制器的设备句柄 | 
  | data | 待写入数据的指针 | 
  |   addr | 待写入数据的起始地址 | 
  | size | 待写入数据的长度 | 
  | **返回值** | **返回值描述** | 
  | 0 | SDIO写数据成功 | 
  | 负数 | SDIO写数据失败 | 

  向SDIO设备增量写入指定长度的数据的示例如下:

Y
yafeng_wang 已提交
220
  ```c
D
duangavin123 已提交
221 222 223 224 225 226 227 228 229 230 231 232 233 234
  int32_t ret;
  uint8_t wbuff[] = {1,2,3,4,5};
  uint32_t addr = 0x100 + 0x09;
  /* 向SDIO设备起始地址0x109,增量写入5个字节的数据 */
  ret = SdioWriteBytes(handle, wbuff, addr, sizeof(wbuff) / sizeof(wbuff[0]));
  if (ret != 0) {
      HDF_LOGE("SdioWriteBytes: failed, ret %d\n", ret);
  }
  ```

- 从SDIO设备增量读取指定长度的数据

  对应的接口函数如下所示:

Y
yafeng_wang 已提交
235
  ```c
D
duangavin123 已提交
236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252
  int32_t SdioReadBytes(DevHandle handle, uint8_t *data, uint32_t addr, uint32_t size);
  ```

  **表7** SdioReadBytes函数的参数和返回值描述

  | 参数 | 参数描述 | 
  | -------- | -------- |
  | handle | SDIO控制器的设备句柄 | 
  | data | 接收读取数据的指针 | 
  | addr | 待读取数据的起始地址 | 
  | size | 待读取数据的长度 | 
  | **返回值** | **返回值描述** | 
  | 0 | SDIO读数据成功 | 
  | 负数 | SDIO读数据失败 | 

  从SDIO设备增量读取指定长度的数据的示例如下:

Y
yafeng_wang 已提交
253
  ```c
D
duangavin123 已提交
254 255 256 257 258 259 260 261 262 263 264
  int32_t ret;
  uint8_t rbuff[5] = {0};
  uint32_t addr = 0x100 + 0x09;
  /* 从SDIO设备起始地址0x109,增量读取5个字节的数据 */
  ret = SdioReadBytes(handle, rbuff, addr, 5);
  if (ret != 0) {
      HDF_LOGE("SdioReadBytes: failed, ret %d\n", ret);
  }
  ```

- 向SDIO设备的固定地址写入指定长度的数据
Y
yafeng_wang 已提交
265

D
duangavin123 已提交
266
  对应的接口函数如下所示:
W
wenjun 已提交
267

Y
yafeng_wang 已提交
268
  ```c
D
duangavin123 已提交
269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285
  int32_t SdioWriteBytesToFixedAddr(DevHandle handle, uint8_t *data, uint32_t addr, uint32_t size, uint32_t scatterLen);
  ```

    **表8** SdioWriteBytesToFixedAddr函数的参数和返回值描述
  
  | 参数 | 参数描述 | 
  | -------- | -------- |
  | handle | SDIO控制器的设备句柄 | 
  | data | 待写入数据的指针 | 
  | addr | 待写入数据的固定地址 | 
  | size | 待写入数据的长度 | 
  | scatterLen | 集散表的长度。如果该字段不为0,则data为集散表类型。 | 
  | **返回值** | **返回值描述** | 
  | 0 | SDIO写数据成功 | 
  | 负数 | SDIO写数据失败 | 

  向SDIO设备的固定地址写入指定长度的数据的示例如下:
W
wenjun 已提交
286

Y
yafeng_wang 已提交
287
  ```c
D
duangavin123 已提交
288 289 290 291 292 293 294 295 296 297 298
  int32_t ret;
  uint8_t wbuff[] = {12345};
  uint32_t addr = 0x100 + 0x09;
  /* 向SDIO设备固定地址0x109写入5个字节的数据 */
  ret = SdioWriteBytesToFixedAddr(handle, wbuff, addr, sizeof(wbuff) / sizeof(wbuff[0]), 0);
  if (ret != 0) {
      HDF_LOGE("SdioWriteBytesToFixedAddr: failed, ret %d\n", ret);
  }
  ```

- 从SDIO设备的固定地址读取指定长度的数据
Y
yafeng_wang 已提交
299

D
duangavin123 已提交
300
  对应的接口函数如下所示:
W
wenjun 已提交
301

Y
yafeng_wang 已提交
302
  ```c
D
duangavin123 已提交
303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319
  int32_t SdioReadBytesFromFixedAddr(DevHandle handle, uint8_t *data, uint32_t addr, uint32_t size, uint32_t scatterLen);
  ```

    **表9** SdioReadBytesFromFixedAddr函数的参数和返回值描述
  
  | 参数 | 参数描述 | 
  | -------- | -------- |
  | handle | SDIO控制器的设备句柄 | 
  | data | 接收读取数据的指针 | 
  | addr | 待读取数据的起始地址 | 
  | size | 待读取数据的长度 | 
  | scatterLen | 集散表的长度。如果该字段不为0,则data为集散表类型。 | 
  | **返回值** | **返回值描述** | 
  | 0 | SDIO读数据成功 | 
  | 负数 | SDIO读数据失败 | 

  从SDIO设备的固定地址读取指定长度的数据的示例如下:
W
wenjun 已提交
320

Y
yafeng_wang 已提交
321
  ```c
D
duangavin123 已提交
322 323 324 325 326 327 328 329 330 331 332 333 334 335
  int32_t ret;
  uint8_t rbuff[5] = {0};
  uint32_t addr = 0x100 + 0x09;
  /* 从SDIO设备固定地址0x109中读取5个字节的数据 */
  ret = SdioReadBytesFromFixedAddr(handle, rbuff, addr, 5, 0);
  if (ret != 0) {
      HDF_LOGE("SdioReadBytesFromFixedAddr: failed, ret %d\n", ret);
  }
  ```

- 向SDIO function 0的指定地址空间写入指定长度的数据

  当前只支持写入一个字节的数据,对应的接口函数如下所示:

Y
yafeng_wang 已提交
336
  ```c
D
duangavin123 已提交
337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353
  int32_t SdioWriteBytesToFunc0(DevHandle handle, uint8_t *data, uint32_t addr, uint32_t size);
  ```

  **表10** SdioWriteBytesToFunc0函数的参数和返回值描述

  | 参数 | 参数描述 | 
  | -------- | -------- |
  | handle | SDIO控制器的设备句柄 | 
  | data | 待写入数据的指针 | 
  | addr | 待写入数据的起始地址 | 
  | size | 待写入数据的长度 | 
  | **返回值** | **返回值描述** | 
  | 0 | SDIO写数据成功 | 
  | 负数 | SDIO写数据失败 | 

  向SDIO function 0的指定地址空间写入指定长度的数据的示例如下:

Y
yafeng_wang 已提交
354
  ```c
D
duangavin123 已提交
355 356 357 358 359 360 361 362 363 364 365 366 367
  int32_t ret;
  uint8_t wbuff = 1;
  /* 向SDIO function 0地址0x2中写入1字节的数据 */
  ret = SdioWriteBytesToFunc0(handle, &wbuff, 0x2, 1);
  if (ret != 0) {
      HDF_LOGE("SdioWriteBytesToFunc0: failed, ret %d\n", ret);
  }
  ```

- 从SDIO function 0的指定地址空间读取指定长度的数据

  当前只支持读取一个字节的数据,对应的接口函数如下所示:

Y
yafeng_wang 已提交
368
  ```c
D
duangavin123 已提交
369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
  int32_t SdioReadBytesFromFunc0(DevHandle handle, uint8_t *data, uint32_t addr, uint32_t size);
  ```

  **表11** SdioReadBytesFromFunc0函数的参数和返回值描述

  | 参数 | 参数描述 | 
  | -------- | -------- |
  | handle | SDIO控制器的设备句柄 | 
  | data | 接收读取数据的指针 | 
  | addr | 待读取数据的起始地址 | 
  | size | 待读取数据的长度 | 
  | **返回值** | **返回值描述** | 
  | 0 | SDIO读数据成功 | 
  | 负数 | SDIO读数据失败 | 

  从SDIO function 0的指定地址空间读取指定长度的数据的示例如下:

Y
yafeng_wang 已提交
386
  ```c
D
duangavin123 已提交
387 388 389 390 391 392 393 394 395
  int32_t ret;
  uint8_t rbuff;
  /* 从SDIO function 0设备地址0x2中读取1字节的数据 */
  ret = SdioReadBytesFromFunc0(handle, &rbuff, 0x2, 1);
  if (ret != 0) {
      HDF_LOGE("SdioReadBytesFromFunc0: failed, ret %d\n", ret);
  }
  ```

Y
yafeng_wang 已提交
396
#### 释放SDIO中断
W
wenjun 已提交
397

D
duangavin123 已提交
398
通信完成之后,需要释放SDIO中断,函数如下所示:
W
wenjun 已提交
399

D
duangavin123 已提交
400
int32_t SdioReleaseIrq(DevHandle handle);
W
wenjun 已提交
401

D
duangavin123 已提交
402
  **表12** SdioReleaseIrq函数的参数和返回值描述
W
wenjun 已提交
403

D
duangavin123 已提交
404 405 406 407 408 409
| 参数 | 参数描述 | 
| -------- | -------- |
| handle | SDIO控制器的设备句柄 | 
| **返回值** | **返回值描述** | 
| 0 | 释放SDIO中断成功 | 
| 负数 | 释放SDIO中断失败 | 
W
wenjun 已提交
410 411 412

释放SDIO中断的示例如下:

Y
yafeng_wang 已提交
413
```c
W
wenjun 已提交
414 415 416 417 418 419 420 421
int32_t ret;
/* 释放SDIO中断 */
ret = SdioReleaseIrq(handle);
if (ret != 0) {
    HDF_LOGE("SdioReleaseIrq: failed, ret %d\n", ret);
}
```

Y
yafeng_wang 已提交
422
#### 去使能SDIO设备
W
wenjun 已提交
423 424 425

通信完成之后,还需要去使能SDIO设备,函数如下所示:

D
duangavin123 已提交
426 427 428 429 430 431 432 433 434 435
int32_t SdioDisableFunc(DevHandle handle);

  **表13** SdioDisableFunc函数的参数和返回值描述

| 参数 | 参数描述 | 
| -------- | -------- |
| handle | SDIO控制器的设备句柄 | 
| **返回值** | **返回值描述** | 
| 0 | 去使能SDIO设备成功 | 
| 负数 | 去使能SDIO设备失败 | 
W
wenjun 已提交
436 437 438

去使能SDIO设备的示例如下:

Y
yafeng_wang 已提交
439
```c
W
wenjun 已提交
440 441 442 443 444 445 446 447
int32_t ret;
/* 去使能SDIO设备 */
ret = SdioDisableFunc(handle);
if (ret != 0) {
    HDF_LOGE("SdioDisableFunc: failed, ret %d\n", ret);
}
```

Y
yafeng_wang 已提交
448
#### 释放HOST
W
wenjun 已提交
449 450 451

通信完成之后,还需要释放去HOST,函数如下所示:

Y
yafeng_wang 已提交
452
```c
D
duangavin123 已提交
453 454 455 456 457 458 459 460
void SdioReleaseHost(DevHandle handle);
```

  **表14** SdioReleaseHost函数的参数描述

| 参数 | 参数描述 | 
| -------- | -------- |
| handle | SDIO控制器的设备句柄 | 
W
wenjun 已提交
461 462 463

释放HOST的示例如下:

Y
yafeng_wang 已提交
464
```c
W
wenjun 已提交
465 466 467
SdioReleaseHost(handle); /* 释放HOST */
```

Y
yafeng_wang 已提交
468
#### 关闭SDIO控制器
W
wenjun 已提交
469 470 471

SDIO通信完成之后,最后需要关闭SDIO控制器,函数如下所示:

Y
yafeng_wang 已提交
472
```c
D
duangavin123 已提交
473 474
void SdioClose(DevHandle handle);
```
W
wenjun 已提交
475 476 477

该函数会释放掉申请的资源。

D
duangavin123 已提交
478 479 480 481 482
  **表15** SdioClose函数的参数描述

| 参数 | 参数描述 | 
| -------- | -------- |
| handle | SDIO控制器的设备句柄 | 
W
wenjun 已提交
483 484 485

关闭SDIO控制器的示例如下:

Y
yafeng_wang 已提交
486
```c
W
wenjun 已提交
487 488 489
SdioClose(handle); /* 关闭SDIO控制器 */
```

Y
yafeng_wang 已提交
490
### 使用实例
D
duangavin123 已提交
491

Y
yafeng_wang 已提交
492
本例拟对Hi3516DV300开发板上SDIO设备进行操作。
D
duangavin123 已提交
493

Y
yafeng_wang 已提交
494
SDIO设备完整的使用示例如下所示,首先打开总线号为1的SDIO控制器,然后独占HOST、使能设备、注册中断,接着进行SDIO通信(读写等),通信完成之后,释放中断、去使能设备、释放HOST,最后关闭SDIO控制器。
D
duangavin123 已提交
495
  
Y
yafeng_wang 已提交
496
```c
D
duangavin123 已提交
497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523
#include "hdf_log.h"
#include "sdio_if.h"

#define TEST_FUNC_NUM 1              /* 本测试用例中,使用编号为1的I/O function */
#define TEST_FBR_BASE_ADDR 0x100     /* 编号为1的I/O function的FBR基地址 */
#define TEST_ADDR_OFFSET 9           /* 本测试用例中,需要读写的寄存器的地址偏移 */
#define TEST_DATA_LEN 3              /* 本测试用例中,读写数据的长度 */
#define TEST_BLOCKSIZE 2             /* 本测试用例中,数据块的大小,单位字节 */

/* 中断服务函数,需要根据各自平台的情况去实现 */
static void SdioIrqFunc(void *data)
{
    if (data == NULL) {
        HDF_LOGE("SdioIrqFunc: data is NULL.\n");
        return;
    }
    /* 需要开发者自行添加具体的实现 */
}

void SdioTestSample(void)
{
    int32_t ret;  
    DevHandle handle = NULL;
    uint8_t data[TEST_DATA_LEN] = {0};
    struct SdioFunctionConfig config = {1, 0x123, 0x456};
    uint8_t val;
    uint32_t addr;
Y
yafeng_wang 已提交
524

D
duangavin123 已提交
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619
    /* 打开总线号为1的SDIO设备 */
    handle = SdioOpen(1, &config);
    if (handle == NULL) {
        HDF_LOGE("SdioOpen: failed!\n");
        return;
    }
    /* 独占HOST */
    SdioClaimHost(handle);
    /* 使能SDIO设备 */
    ret = SdioEnableFunc(handle);
    if (ret != 0) {
        HDF_LOGE("SdioEnableFunc: failed, ret %d\n", ret);
        goto ENABLE_ERR;
    }
    /* 注册中断 */
    ret = SdioClaimIrq(handle, SdioIrqFunc);
    if (ret != 0) {
        HDF_LOGE("SdioClaimIrq: failed, ret %d\n", ret);
        goto CLAIM_IRQ_ERR;
    }
    /* 设置块大小为2字节 */
    ret = SdioSetBlockSize(handle, TEST_BLOCKSIZE);
    if (ret != 0) {
        HDF_LOGE("SdioSetBlockSize: failed, ret %d\n", ret);
        goto COMM_ERR;
    }
    /* 从SDIO设备增量地址读取3字节的数据 */
    addr = TEST_FBR_BASE_ADDR * TEST_FUNC_NUM + TEST_ADDR_OFFSET;
    ret = SdioReadBytes(handle, data, addr, TEST_DATA_LEN);
    if (ret != 0) {
        HDF_LOGE("SdioReadBytes: failed, ret %d\n", ret);
        goto COMM_ERR;
    }
    /* 向SDIO设备增量地址写入3字节的数据 */
    ret = SdioWriteBytes(handle, data, addr, TEST_DATA_LEN);
    if (ret != 0) {
        HDF_LOGE("SdioWriteBytes: failed, ret %d\n", ret);
        goto COMM_ERR;
    }
    /* 从SDIO设备读取1字节的数据 */
    ret = SdioReadBytes(handle, &val, addr, 1);
    if (ret != 0) {
        HDF_LOGE("SdioReadBytes: failed, ret %d\n", ret);
        goto COMM_ERR;
    }
    /* 向SDIO设备写入1字节的数据 */
    ret = SdioWriteBytes(handle, &val, addr, 1);
    if (ret != 0) {
        HDF_LOGE("SdioWriteBytes: failed, ret %d\n", ret);
        goto COMM_ERR;
    }
    /* 从SDIO设备固定地址读取3字节的数据 */
    ret = SdioReadBytesFromFixedAddr(handle, data, addr, TEST_DATA_LEN, 0);
    if (ret != 0) {
        HDF_LOGE("SdioReadBytesFromFixedAddr: failed, ret %d\n", ret);
        goto COMM_ERR;
    }
    /* 向SDIO设备固定地址写入1字节的数据 */
    ret = SdioWriteBytesToFixedAddr(handle, data, addr, 1, 0);
    if (ret != 0) {
        HDF_LOGE("SdioWriteBytesToFixedAddr: failed, ret %d\n", ret);
        goto COMM_ERR;
    }
    /* 从SDIO function 0读取1字节的数据 */
    addr = 0x02;
    ret = SdioReadBytesFromFunc0(handle, &val, addr, 1);
    if (ret != 0) {
        HDF_LOGE("SdioReadBytesFromFunc0: failed, ret %d\n", ret);
        goto COMM_ERR;
    }
    /* 向SDIO function 0写入1字节的数据 */
    ret = SdioWriteBytesToFunc0(handle, &val, addr, 1);
    if (ret != 0) {
        HDF_LOGE("SdioWriteBytesToFunc0: failed, ret %d\n", ret);
        goto COMM_ERR;
    }
COMM_ERR:
    /* 释放中断 */
    ret = SdioReleaseIrq(handle);
    if (ret != 0) {
        HDF_LOGE("SdioReleaseIrq: failed, ret %d\n", ret);
    }
CLAIM_IRQ_ERR:
    /* 去使能SDIO设备 */
    ret = SdioDisableFunc(handle);
    if (ret != 0) {
        HDF_LOGE("SdioDisableFunc: failed, ret %d\n", ret);
    }
ENABLE_ERR:
    /* 释放HOST */
    SdioReleaseHost(handle);
    /* 关闭SDIO设备 */
    SdioClose(handle); 
}
```