Skip to content

D
Docs

OpenHarmony / Docs
9 个月 前同步成功

通知 158
Star 292
Fork 28
D
Docs

前往新版Gitcode，体验更适合开发者的 AI 搜索 >>

未验证 提交 67d15e35 编写于 作者: O openharmony_ci 提交者： Gitee
浏览文件
操作

!1219 【轻量级 PR】：【同步】【驱动】SPI章节修改文件路径、删除多余符号、修改表格中英文符号、将接口说明整理为单独模块。 

Merge pull request !1219 from liyan/N/A
上级 ced63797 ad9a4de1
隐藏空白更改
内联 并排
Showing with 299 addition and 282 deletion
zh-cn/device-dev/driver/driver-platform-spi-develop.md
浏览文件 @ 67d15e35
# SPI # SPI
- [概述](#1) - [概述](#1)
- [开发步骤](#2) - [接口说明](#2)
- [开发实例](#3) - [开发步骤](#3)
- [开发实例](#4)
## 概述 <a name="1"></a> ## 概述 <a name="1"></a>
...@@ -13,7 +14,30 @@ SPI是串行外设接口（Serial Peripheral Interface）的缩写，在HDF框 ...@@ -13,7 +14,30 @@ SPI是串行外设接口（Serial Peripheral Interface）的缩写，在HDF框
图 1 独立服务模式结构图 图 1 独立服务模式结构图
![image1](figure/独立服务模式.png) ![image1](figure/独立服务模式.png)
## 开发步骤 <a name="2"></a> ## 接口说明 <a name="2"></a>
SpiCntlrMethod定义
```c
struct SpiCntlrMethod {
int32_t (*GetCfg)(struct SpiCntlr *cntlr, struct SpiCfg *cfg);
int32_t (*SetCfg)(struct SpiCntlr *cntlr, struct SpiCfg *cfg);
int32_t (*Transfer)(struct SpiCntlr *cntlr, struct SpiMsg *msg, uint32_t count);
int32_t (*Open)(struct SpiCntlr *cntlr);
int32_t (*Close)(struct SpiCntlr *cntlr);
};
```
表1 SpiCntlrMethod结构体成员的回调函数功能说明
|成员函数|入参|返回值|功能|
|-|-|-|-|
|Transfer |**cntlr**：结构体指针，核心层spi控制器；<br />**msg**：结构体指针，Spi消息；<br />**count**：uint32_t，消息个数 |HDF_STATUS相关状态|传输消息|
|SetCfg |**cntlr**：结构体指针，核心层spi控制器；<br />**cfg**：结构体指针，Spi属性 |HDF_STATUS相关状态|设置控制器属性 |
|GetCfg |**cntlr**：结构体指针，核心层spi控制器；<br />**cfg**：结构体指针，Spi属性 |HDF_STATUS相关状态|获取控制器属性 |
|Open |**cntlr**：结构体指针，核心层spi控制器； |HDF_STATUS相关状态|打开SPI |
|Close |**cntlr**：结构体指针，核心层spi控制器； |HDF_STATUS相关状态|关闭SPI |
## 开发步骤 <a name="3"></a>
SPI模块适配HDF框架的三个环节是配置属性文件，实例化驱动入口，以及填充核心层接口函数。 SPI模块适配HDF框架的三个环节是配置属性文件，实例化驱动入口，以及填充核心层接口函数。
...@@ -29,34 +53,15 @@ SPI模块适配HDF框架的三个环节是配置属性文件，实例化驱动 ...@@ -29,34 +53,15 @@ SPI模块适配HDF框架的三个环节是配置属性文件，实例化驱动
3. **实例化SPI控制器对象：** 3. **实例化SPI控制器对象：**
- 初始化SpiCntlr成员。 - 初始化SpiCntlr成员。
- 实例化SpiCntlr成员SpiCntlrMethod，其定义和成员说明见下 - 实例化SpiCntlr成员SpiCntlrMethod。
>![](../public_sys-resources/icon-note.gif) **说明：**
>实例化SpiCntlr成员SpiCntlrMethod，其定义和成员说明见[接口说明](#2)。
4. **驱动调试：** 4. **驱动调试：**
- 【可选】针对新增驱动程序，建议验证驱动基本功能，例如spi控制状态，中断响应情况等。 - 【可选】针对新增驱动程序，建议验证驱动基本功能，例如spi控制状态，中断响应情况等。
> ![](../public_sys-resources/icon-note.gif) **说明：**
> ## 开发实例 <a name="4"></a>
> SpiCntlrMethod定义
> ```c
> struct SpiCntlrMethod {
> int32_t (*GetCfg)(struct SpiCntlr *cntlr, struct SpiCfg *cfg);
> int32_t (*SetCfg)(struct SpiCntlr *cntlr, struct SpiCfg *cfg);
> int32_t (*Transfer)(struct SpiCntlr *cntlr, struct SpiMsg *msg, uint32_t count);
> int32_t (*Open)(struct SpiCntlr *cntlr);
> int32_t (*Close)(struct SpiCntlr *cntlr);
> };
> ```
> 表1 SpiCntlrMethod结构体成员的回调函数功能说明
>
> |成员函数|入参|返回值|功能|
> |-|-|-|-|
> |Transfer |**cntlr**: 结构体指针,核心层spi控制器 ;<br />**msg**: 结构体指针,Spi消息;<br />**count**: uint32_t,消息个数 |HDF_STATUS相关状态|传输消息|
> |SetCfg |**cntlr**: 结构体指针,核心层spi控制器 ;<br />**cfg**: 结构体指针,Spi属性 |HDF_STATUS相关状态|设置控制器属性 |
> |GetCfg |**cntlr**: 结构体指针,核心层spi控制器 ;<br />**cfg**: 结构体指针,Spi属性 |HDF_STATUS相关状态|获取控制器属性 |
> |Open |**cntlr**: 结构体指针,核心层spi控制器 ; |HDF_STATUS相关状态|打开SPI |
> |Close |**cntlr**: 结构体指针,核心层spi控制器 ; |HDF_STATUS相关状态|关闭SPI |
## 开发实例 <a name="3"></a>
下方将以spi_hi35xx.c为示例，展示需要厂商提供哪些内容来完整实现设备功能。 下方将以spi_hi35xx.c为示例，展示需要厂商提供哪些内容来完整实现设备功能。
...@@ -64,7 +69,7 @@ SPI模块适配HDF框架的三个环节是配置属性文件，实例化驱动 ...@@ -64,7 +69,7 @@ SPI模块适配HDF框架的三个环节是配置属性文件，实例化驱动
一般在加载驱动时HDF会先调用Bind函数，再调用Init函数加载该驱动。当Init调用异常时，HDF框架会调用Release释放驱动资源并退出。 一般在加载驱动时HDF会先调用Bind函数，再调用Init函数加载该驱动。当Init调用异常时，HDF框架会调用Release释放驱动资源并退出。
- SPI驱动入口参考 SPI驱动入口参考：
```c ```c
struct HdfDriverEntry g_hdfSpiDevice = { struct HdfDriverEntry g_hdfSpiDevice = {
...@@ -81,275 +86,287 @@ SPI模块适配HDF框架的三个环节是配置属性文件，实例化驱动 ...@@ -81,275 +86,287 @@ SPI模块适配HDF框架的三个环节是配置属性文件，实例化驱动
2. 完成驱动入口注册之后，下一步请在device_info.hcs文件中添加deviceNode信息，并在 spi_config.hcs 中配置器件属性。deviceNode信息与驱动入口注册相关，器件属性值与核心层SpiCntlr 成员的默认值或限制范围有密切关系。 2. 完成驱动入口注册之后，下一步请在device_info.hcs文件中添加deviceNode信息，并在 spi_config.hcs 中配置器件属性。deviceNode信息与驱动入口注册相关，器件属性值与核心层SpiCntlr 成员的默认值或限制范围有密切关系。
**本例只有一个SPI控制器，如有多个器件信息，则需要在device_info文件增加deviceNode信息，以及在spi_config文件中增加对应的器件属性**。 **本例只有一个SPI控制器，如有多个器件信息，则需要在device_info文件增加deviceNode信息，以及在spi_config文件中增加对应的器件属性**。
- device_info.hcs 配置参考 - device_info.hcs 配置参考
```c ```c
root { root {
device_info { device_info {
match_attr = "hdf_manager"; match_attr = "hdf_manager";
platform :: host { platform :: host {
hostName = "platform_host"; hostName = "platform_host";
priority = 50; priority = 50;
device_spi :: device { //为每一个 SPI 控制器配置一个HDF设备节点 device_spi :: device { //为每一个 SPI 控制器配置一个HDF设备节点
device0 :: deviceNode { device0 :: deviceNode {
policy = 1; policy = 1;
priority = 60; priority = 60;
permission = 0644; permission = 0644;
moduleName = "HDF_PLATFORM_SPI"; moduleName = "HDF_PLATFORM_SPI";
serviceName = "HDF_PLATFORM_SPI_0"; serviceName = "HDF_PLATFORM_SPI_0";
deviceMatchAttr = "hisilicon_hi35xx_spi_0"; deviceMatchAttr = "hisilicon_hi35xx_spi_0";
} }
device1 :: deviceNode { device1 :: deviceNode {
policy = 1; policy = 1;
priority = 60; priority = 60;
permission = 0644; permission = 0644;
moduleName = "HDF_PLATFORM_SPI"; // 【必要】用于指定驱动名称，该字段的值必须和驱动入口结构的moduleName值一致 moduleName = "HDF_PLATFORM_SPI"; // 【必要】用于指定驱动名称，该字段的值必须和驱动入口结构的moduleName值一致
serviceName = "HDF_PLATFORM_SPI_1"; // 【必要且唯一】驱动对外发布服务的名称 serviceName = "HDF_PLATFORM_SPI_1"; // 【必要且唯一】驱动对外发布服务的名称
deviceMatchAttr = "hisilicon_hi35xx_spi_1";// 需要与设备hcs文件中的 match_attr 匹配 deviceMatchAttr = "hisilicon_hi35xx_spi_1";// 需要与设备hcs文件中的 match_attr 匹配
} }
... ...
} }
} }
} }
} }
``` ```
- spi_config.hcs 配置参考 - spi_config.hcs 配置参考
```c ```c
root { root {
platform { platform {
spi_config {//每一个SPI控制器配置私有数据 spi_config {//每一个SPI控制器配置私有数据
template spi_controller {//模板公共参数， 继承该模板的节点如果使用模板中的默认值， 则节点字段可以缺省 template spi_controller {//模板公共参数， 继承该模板的节点如果使用模板中的默认值， 则节点字段可以缺省
serviceName = ""; serviceName = "";
match_attr = ""; match_attr = "";
transferMode = 0; // 数据传输模式：中断传输(0),流控传输(1),DMA传输(2) transferMode = 0; // 数据传输模式：中断传输(0),流控传输(1),DMA传输(2)
busNum = 0; // 总线号 busNum = 0; // 总线号
clkRate = 100000000; clkRate = 100000000;
bitsPerWord = 8; // 传输位宽 bitsPerWord = 8; // 传输位宽
mode = 19; // SPI 数据的输入输出模式 mode = 19; // SPI 数据的输入输出模式
maxSpeedHz = 0; // 最大时钟频率 maxSpeedHz = 0; // 最大时钟频率
minSpeedHz = 0; // 最小时钟频率 minSpeedHz = 0; // 最小时钟频率
speed = 2000000; // 当前消息传输速度 speed = 2000000; // 当前消息传输速度
fifoSize = 256; // FIFO大小 fifoSize = 256; // FIFO大小
numCs = 1; // 片选号 numCs = 1; // 片选号
regBase = 0x120c0000; // 地址映射需要 regBase = 0x120c0000; // 地址映射需要
irqNum = 100; // 中断号 irqNum = 100; // 中断号
REG_CRG_SPI = 0x120100e4; // CRG_REG_BASE(0x12010000) + 0x0e4 REG_CRG_SPI = 0x120100e4; // CRG_REG_BASE(0x12010000) + 0x0e4
CRG_SPI_CKEN = 0; CRG_SPI_CKEN = 0;
CRG_SPI_RST = 0; CRG_SPI_RST = 0;
REG_MISC_CTRL_SPI = 0x12030024; // MISC_REG_BASE(0x12030000) + 0x24 REG_MISC_CTRL_SPI = 0x12030024; // MISC_REG_BASE(0x12030000) + 0x24
MISC_CTRL_SPI_CS = 0; MISC_CTRL_SPI_CS = 0;
MISC_CTRL_SPI_CS_SHIFT = 0; MISC_CTRL_SPI_CS_SHIFT = 0;
} }
controller_0x120c0000 :: spi_controller { controller_0x120c0000 :: spi_controller {
busNum = 0; //【必要】总线号 busNum = 0; //【必要】总线号
CRG_SPI_CKEN = 0x10000; // (0x1 << 16) 0:close clk, 1:open clk CRG_SPI_CKEN = 0x10000; // (0x1 << 16) 0:close clk, 1:open clk
CRG_SPI_RST = 0x1; // (0x1 << 0) 0:cancel reset, 1:reset CRG_SPI_RST = 0x1; // (0x1 << 0) 0:cancel reset, 1:reset
match_attr = "hisilicon_hi35xx_spi_0";//【必要】需要和device_info.hcs中的deviceMatchAttr值一致 match_attr = "hisilicon_hi35xx_spi_0";//【必要】需要和device_info.hcs中的deviceMatchAttr值一致
} }
controller_0x120c1000 :: spi_controller { controller_0x120c1000 :: spi_controller {
busNum = 1; busNum = 1;
CRG_SPI_CKEN = 0x20000; // (0x1 << 17) 0:close clk, 1:open clk CRG_SPI_CKEN = 0x20000; // (0x1 << 17) 0:close clk, 1:open clk
CRG_SPI_RST = 0x2; // (0x1 << 1) 0:cancel reset, 1:reset CRG_SPI_RST = 0x2; // (0x1 << 1) 0:cancel reset, 1:reset
match_attr = "hisilicon_hi35xx_spi_1"; match_attr = "hisilicon_hi35xx_spi_1";
regBase = 0x120c1000; //【必要】地址映射需要 regBase = 0x120c1000; //【必要】地址映射需要
irqNum = 101; //【必要】中断号 irqNum = 101; //【必要】中断号
} }
... ...
// 【可选】可新增，但需要在 device_info.hcs 添加对应的节点 // 【可选】可新增，但需要在 device_info.hcs 添加对应的节点
} }
} }
} }
``` ```
3. 完成驱动入口注册之后，最后一步就是以核心层SpiCntlr对象的初始化为核心，包括厂商自定义结构体（传递参数和数据），实例化SpiCntlr成员SpiCntlrMethod（让用户可以通过接口来调用驱动底层函数），实现HdfDriverEntry成员函数（Bind，Init，Release） 3. 完成驱动入口注册之后，最后一步就是以核心层SpiCntlr对象的初始化为核心，包括厂商自定义结构体（传递参数和数据），实例化SpiCntlr成员SpiCntlrMethod（让用户可以通过接口来调用驱动底层函数），实现HdfDriverEntry成员函数（Bind，Init，Release）
- 自定义结构体参考 - 自定义结构体参考
> 从驱动的角度看，自定义结构体是参数和数据的载体，而且spi_config.hcs文件中的数值会被HDF读入通过DeviceResourceIface来初始化结构体成员，一些重要数值也会传递给核心层对象，例如设备号、总线号等。 从驱动的角度看，自定义结构体是参数和数据的载体，而且spi_config.hcs文件中的数值会被HDF读入通过DeviceResourceIface来初始化结构体成员，一些重要数值也会传递给核心层对象，例如设备号、总线号等。
```c ```c
struct Pl022 {//对应于hcs中的参数 struct Pl022 {//对应于hcs中的参数
struct SpiCntlr *cntlr; struct SpiCntlr *cntlr;
struct DListHead deviceList; struct DListHead deviceList;
struct OsalSem sem; struct OsalSem sem;
volatile unsigned char *phyBase; volatile unsigned char *phyBase;
volatile unsigned char *regBase; volatile unsigned char *regBase;
uint32_t irqNum; uint32_t irqNum;
uint32_t busNum; uint32_t busNum;
uint32_t numCs; uint32_t numCs;
uint32_t curCs; uint32_t curCs;
uint32_t speed; uint32_t speed;
uint32_t fifoSize; uint32_t fifoSize;
uint32_t clkRate; uint32_t clkRate;
uint32_t maxSpeedHz; uint32_t maxSpeedHz;
uint32_t minSpeedHz; uint32_t minSpeedHz;
uint32_t regCrg; uint32_t regCrg;
uint32_t clkEnBit; uint32_t clkEnBit;
uint32_t clkRstBit; uint32_t clkRstBit;
uint32_t regMiscCtrl; uint32_t regMiscCtrl;
uint32_t miscCtrlCsShift; uint32_t miscCtrlCsShift;
uint32_t miscCtrlCs; uint32_t miscCtrlCs;
uint16_t mode; uint16_t mode;
uint8_t bitsPerWord; uint8_t bitsPerWord;
uint8_t transferMode; uint8_t transferMode;
}; };
//SpiCntlr是核心层控制器结构体，其中的成员在Init函数中会被赋值 //SpiCntlr是核心层控制器结构体，其中的成员在Init函数中会被赋值
struct SpiCntlr { struct SpiCntlr {
struct IDeviceIoService service; struct IDeviceIoService service;
struct HdfDeviceObject *device; struct HdfDeviceObject *device;
uint32_t busNum; uint32_t busNum;
uint32_t numCs; uint32_t numCs;
uint32_t curCs; uint32_t curCs;
struct OsalMutex lock; struct OsalMutex lock;
struct SpiCntlrMethod *method; struct SpiCntlrMethod *method;
struct DListHead list; struct DListHead list;
void *priv; void *priv;
}; };
``` ```
- **【重要】** SpiCntlr成员回调函数结构体SpiCntlrMethod的实例化，其他成员在Init函数中初始化 - **【重要】** SpiCntlr成员回调函数结构体SpiCntlrMethod的实例化，其他成员在Init函数中初始化
```c ```c
// spi_hi35xx.c 中的示例：钩子函数的填充 // spi_hi35xx.c 中的示例：钩子函数的填充
struct SpiCntlrMethod g_method = { struct SpiCntlrMethod g_method = {
.Transfer = Pl022Transfer, .Transfer = Pl022Transfer,
.SetCfg = Pl022SetCfg, .SetCfg = Pl022SetCfg,
.GetCfg = Pl022GetCfg, .GetCfg = Pl022GetCfg,
.Open = Pl022Open, .Open = Pl022Open,
.Close = Pl022Close, .Close = Pl022Close,
}; };
``` ```
- **Bind 函数参考**
入参：
HdfDeviceObject是整个驱动对外暴露的接口参数，具备HCS配置文件的信息 。
返回值：
HDF_STATUS相关状态。
函数说明：
- **Bind 函数参考** 将SpiCntlr对象同HdfDeviceObject进行了关联。
> **入参：**
> HdfDeviceObject 是整个驱动对外暴露的接口参数，具备 HCS 配置文件的信息
>
> **返回值：**
> HDF_STATUS相关状态
>
> **函数说明：**
> 将 SpiCntlr 对象同 HdfDeviceObject 进行了关联
```c ```c
static int32_t HdfSpiDeviceBind(struct HdfDeviceObject *device) static int32_t HdfSpiDeviceBind(struct HdfDeviceObject *device)
{ {
... ...
return (SpiCntlrCreate(device) == NULL) ? HDF_FAILURE : HDF_SUCCESS; return (SpiCntlrCreate(device) == NULL) ? HDF_FAILURE : HDF_SUCCESS;
} }
struct SpiCntlr *SpiCntlrCreate(struct HdfDeviceObject *device) struct SpiCntlr *SpiCntlrCreate(struct HdfDeviceObject *device)
{ {
struct SpiCntlr *cntlr = NULL; //创建核心层 SpiCntlr 对象 struct SpiCntlr *cntlr = NULL; //创建核心层 SpiCntlr 对象
... ...
cntlr = (struct SpiCntlr *)OsalMemCalloc(sizeof(*cntlr));//非配内存 cntlr = (struct SpiCntlr *)OsalMemCalloc(sizeof(*cntlr));//非配内存
... ...
cntlr->device = device; //使HdfDeviceObject与SpiCntlr可以相互转化的前提 cntlr->device = device; //使HdfDeviceObject与SpiCntlr可以相互转化的前提
device->service = &(cntlr->service);//使HdfDeviceObject与SpiCntlr可以相互转化的前提 device->service = &(cntlr->service);//使HdfDeviceObject与SpiCntlr可以相互转化的前提
(void)OsalMutexInit(&cntlr->lock); //锁初始化 (void)OsalMutexInit(&cntlr->lock); //锁初始化
DListHeadInit(&cntlr->list); //添加对应的节点 DListHeadInit(&cntlr->list); //添加对应的节点
cntlr->priv = NULL; cntlr->priv = NULL;
return cntlr; return cntlr;
} }
``` ```
- **Init函数参考**
入参：
HdfDeviceObject 是整个驱动对外暴露的接口参数，具备 HCS 配置文件的信息
返回值：
HDF_STATUS相关状态（下表为部分展示，如需使用其他状态，可见/drivers/framework/include/utils/hdf_base.h中HDF_STATUS定义）
- **Init函数参考**
> **入参：**
> HdfDeviceObject 是整个驱动对外暴露的接口参数，具备 HCS 配置文件的信息
>
> **返回值：**
> HDF_STATUS相关状态 （下表为部分展示，如需使用其他状态，可见//drivers/framework/include/utils/hdf_base.h中HDF_STATUS 定义）
>
> |状态(值)|问题描述|
> |:-|:-:|
> |HDF_ERR_INVALID_OBJECT|控制器对象非法|
> |HDF_ERR_MALLOC_FAIL |内存分配失败|
> |HDF_ERR_INVALID_PARAM |参数非法|
> |HDF_ERR_IO |I/O 错误|
> |HDF_SUCCESS |初始化成功|
> |HDF_FAILURE |初始化失败|
>
> **函数说明：**
> 初始化自定义结构体对象，初始化SpiCntlr成员。
```c |状态(值)|问题描述|
//挂载init的 |:-|:-:|
static int32_t HdfSpiDeviceInit(struct HdfDeviceObject *device) |HDF_ERR_INVALID_OBJECT|控制器对象非法|
{ |HDF_ERR_MALLOC_FAIL |内存分配失败|
int32_t ret; |HDF_ERR_INVALID_PARAM |参数非法|
struct SpiCntlr *cntlr = NULL; |HDF_ERR_IO |I/O 错误|
... |HDF_SUCCESS |初始化成功|
cntlr = SpiCntlrFromDevice(device);//这里有HdfDeviceObject到SpiCntlr的强制转化，通过service成员，赋值见Bind函数 |HDF_FAILURE |初始化失败|
//return (device == NULL) ? NULL : (struct SpiCntlr *)device->service;
... 函数说明：
ret = Pl022Init(cntlr, device);//【必要】填充厂商自定义操作对象，示例见下 初始化自定义结构体对象，初始化SpiCntlr成员。
...
ret = Pl022Probe(cntlr->priv);
...
return ret;
}
static int32_t Pl022Init(struct SpiCntlr *cntlr, const struct HdfDeviceObject *device)
{ ```c
int32_t ret; //挂载init的
struct Pl022 *pl022 = NULL; static int32_t HdfSpiDeviceInit(struct HdfDeviceObject *device)
... {
pl022 = (struct Pl022 *)OsalMemCalloc(sizeof(*pl022));//申请内存 int32_t ret;
... struct SpiCntlr *cntlr = NULL;
ret = SpiGetBaseCfgFromHcs(pl022, device->property); //填充busNum, numCs, speed, fifoSize, clkRate, ...
cntlr = SpiCntlrFromDevice(device);//这里有HdfDeviceObject到SpiCntlr的强制转化，通过service成员，赋值见Bind函数
//return (device == NULL) ? NULL : (struct SpiCntlr *)device->service;
...
ret = Pl022Init(cntlr, device);//【必要】填充厂商自定义操作对象，示例见下
...
ret = Pl022Probe(cntlr->priv);
...
return ret;
}
static int32_t Pl022Init(struct SpiCntlr *cntlr, const struct HdfDeviceObject *device)
{
int32_t ret;
struct Pl022 *pl022 = NULL;
...
pl022 = (struct Pl022 *)OsalMemCalloc(sizeof(*pl022));//申请内存
...
ret = SpiGetBaseCfgFromHcs(pl022, device->property); //填充busNum, numCs, speed, fifoSize, clkRate,
//mode, bitsPerWord, transferMode参数值 //mode, bitsPerWord, transferMode参数值
... ...
ret = SpiGetRegCfgFromHcs(pl022, device->property); //填充regBase, phyBase, irqNum, regCrg, clkEnBit, ret = SpiGetRegCfgFromHcs(pl022, device->property); //填充regBase, phyBase, irqNum, regCrg, clkEnBit,
//clkRstBit, regMiscCtrl, regMiscCtrl, miscCtrlCs, //clkRstBit, regMiscCtrl, regMiscCtrl, miscCtrlCs,
//miscCtrlCsShift参数值 //miscCtrlCsShift参数值
... ...
//计算最大,最小速度对应的频率 //计算最大,最小速度对应的频率
pl022->maxSpeedHz = (pl022->clkRate) / ((SCR_MIN + 1) * CPSDVSR_MIN); pl022->maxSpeedHz = (pl022->clkRate) / ((SCR_MIN + 1) * CPSDVSR_MIN);
pl022->minSpeedHz = (pl022->clkRate) / ((SCR_MAX + 1) * CPSDVSR_MAX); pl022->minSpeedHz = (pl022->clkRate) / ((SCR_MAX + 1) * CPSDVSR_MAX);
DListHeadInit(&pl022->deviceList);//初始化DList链表 DListHeadInit(&pl022->deviceList);//初始化DList链表
pl022->cntlr = cntlr; //使Pl022与SpiCntlr可以相互转化的前提 pl022->cntlr = cntlr; //使Pl022与SpiCntlr可以相互转化的前提
cntlr->priv = pl022; //使Pl022与SpiCntlr可以相互转化的前提 cntlr->priv = pl022; //使Pl022与SpiCntlr可以相互转化的前提
cntlr->busNum = pl022->busNum; //挂载总线号 cntlr->busNum = pl022->busNum; //挂载总线号
cntlr->method = &g_method; //SpiCntlrMethod的实例化对象的挂载 cntlr->method = &g_method; //SpiCntlrMethod的实例化对象的挂载
... ...
ret = Pl022CreatAndInitDevice(pl022); ret = Pl022CreatAndInitDevice(pl022);
if (ret != 0) { if (ret != 0) {
Pl022Release(pl022); //初始化失败就释放Pl022对象 Pl022Release(pl022); //初始化失败就释放Pl022对象
return ret; return ret;
} }
return 0; return 0;
} }
``` ```
- **Release函数参考** - **Release函数参考**
> **入参：** 入参：
> HdfDeviceObject 是整个驱动对外暴露的接口参数，具备 HCS 配置文件的信息
> HdfDeviceObject 是整个驱动对外暴露的接口参数，具备 HCS 配置文件的信息
> **返回值：**
> 无 返回值：
>
> **函数说明：** 无
> 释放内存和删除控制器，该函数需要在驱动入口结构体中赋值给 Release 接口， 当HDF框架调用Init函数初始化驱动失败时，可以调用 Release 释放驱动资源。所有强制转换获取相应对象的操作**前提**是在Init函数中具备对应赋值的操作。
```c 函数说明：
static void HdfSpiDeviceRelease(struct HdfDeviceObject *device)
{ 释放内存和删除控制器，该函数需要在驱动入口结构体中赋值给 Release 接口， 当HDF框架调用Init函数初始化驱动失败时，可以调用 Release 释放驱动资源。所有强制转换获取相应对象的操作**前提**是在Init函数中具备对应赋值的操作。
struct SpiCntlr *cntlr = NULL;
...
cntlr = SpiCntlrFromDevice(device);//这里有HdfDeviceObject到SpiCntlr的强制转化，通过service成员，赋值见Bind函数 ```c
// return (device==NULL) ?NULL:(struct SpiCntlr *)device->service; static void HdfSpiDeviceRelease(struct HdfDeviceObject *device)
... {
if (cntlr->priv != NULL) { struct SpiCntlr *cntlr = NULL;
Pl022Remove((struct Pl022 *)cntlr->priv);//这里有SpiCntlr到Pl022的强制转化 ...
} cntlr = SpiCntlrFromDevice(device);//这里有HdfDeviceObject到SpiCntlr的强制转化，通过service成员，赋值见Bind函数
SpiCntlrDestroy(cntlr); //释放Pl022对象 // return (device==NULL) ?NULL:(struct SpiCntlr *)device->service;
} ...
``` if (cntlr->priv != NULL) {
Pl022Remove((struct Pl022 *)cntlr->priv);//这里有SpiCntlr到Pl022的强制转化
}
SpiCntlrDestroy(cntlr); //释放Pl022对象
}
```
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或