Skip to content

D
Docs

OpenHarmony / Docs
大约 1 年 前同步成功

通知 159
Star 292
Fork 28
D
Docs

体验新版 GitCode，发现更多精彩内容 >>

提交 ea659ced 编写于 作者: Y yinshuqing
浏览文件
操作

modify 

Signed-off-by: Nyinshuqing <yinshuqing@huawei.com>
上级 586b4a61
隐藏空白更改
内联 并排
Showing with 212 addition and 230 deletion
zh-cn/device-dev/driver/driver-platform-pin-develop.md
浏览文件 @ ea659ced
# PIN<a name="title_PINDevelop"></a> # PIN<a name="title_PinDevelop"></a>
- [概述](#section1_PINDevelop) - [概述](#section1_PinDevelop)
- [接口说明](#section2_PINDevelop) - [接口说明](#section2_PinDevelop)
- [开发步骤](#section3_PINDevelop) - [开发步骤](#section3_PinDevelop)
- [开发实例](#section4_PINDevelop) - [开发实例](#section4_PinDevelop)
## 概述 <a name="section1_PINDevelop"></a> ## 概述 <a name="section1_PinDevelop"></a>
PIN模块用于控制系统中某些设备一个或者一组引脚的状态和功能特性。在HDF框架中，PIN的接口适配模式采用无服务模式，用于不需要在用户态提供API的设备类型，或者没有用户态和内核区分的OS系统，其关联方式是DevHandle直接指向设备对象内核态地址（DevHandle是一个void类型指针）。 PIN模块用于控制系统中管脚的状态和功能特性。在HDF框架中，PIN的接口适配模式采用无服务模式，用于不需要在用户态提供API的设备类型，或者没有用户态和内核区分的OS系统，其关联方式是DevHandle直接指向设备对象内核态地址（DevHandle是一个void类型指针）。
图 1 无服务模式结构图 图 1 无服务模式结构图
![image1](figures/无服务模式结构图.png) ![image1](figures/无服务模式结构图.png)
## 接口说明<a name="section2_PINDevelop"></a> ## 接口说明<a name="section2_PinDevelop"></a>
PinCntlrMethod定义： PinCntlrMethod定义：
...@@ -31,40 +31,41 @@ struct PinCntlrMethod { ...@@ -31,40 +31,41 @@ struct PinCntlrMethod {
| 成员函数 | 入参 | 返回值 | 功能 | | 成员函数 | 入参 | 返回值 | 功能 |
| ------------ | ------------------------------------------- | ------ | ---- | | ------------ | ------------------------------------------- | ------ | ---- |
| SetPinPull | **cntlr**：结构体指针，核心层pin控制器；<br>**index**：uint32_t变量，管脚索引号；<br/>**pullType**：枚举常量，pin拉动类型； |HDF_STATUS相关状态|设置pin拉动类型| | SetPinPull | **cntlr**：结构体指针，核心层Pin控制器；<br>**index**：uint32_t变量，管脚索引号；<br/>**pullType**：枚举常量，Pin管脚推拉方式； |HDF_STATUS相关状态|设置Pin管脚推拉方式|
| GetPinPull | **cntlr**：结构体指针，核心层pin控制器；<br/>**index**：uint32_t变量，管脚索引号；<br/>**pullType**：枚举常量指针，传出pin拉动类型； | HDF_STATUS相关状态 | 获取pin拉动类型 | | GetPinPull | **cntlr**：结构体指针，核心层Pin控制器；<br/>**index**：uint32_t变量，管脚索引号；<br/>**pullType**：枚举常量指针，传出Pin管脚推拉方式； | HDF_STATUS相关状态 | 获取Pin管脚推拉方式 |
| SetPinStrength | **cntlr**：结构体指针，核心层pin控制器；<br/>**index**：uint32_t变量，管脚索引号；<br/>**strength**：uint32_t变量，pin强度值； | HDF_STATUS相关状态 | 设置pin强度 | | SetPinStrength | **cntlr**：结构体指针，核心层Pin控制器；<br/>**index**：uint32_t变量，管脚索引号；<br/>**strength**：uint32_t变量，Pin推拉强度； | HDF_STATUS相关状态 | 设置Pin推拉强度 |
| GetPinStrength | **cntlr**：结构体指针，核心层pin控制器；<br/>**index**：uint32_t变量，管脚索引号；<br/>**strength**：uint32_t变量指针，传出pin强度值； | HDF_STATUS相关状态 | 获取pin强度 | | GetPinStrength | **cntlr**：结构体指针，核心层Pin控制器；<br/>**index**：uint32_t变量，管脚索引号；<br/>**strength**：uint32_t变量指针，传出Pin推拉强度； | HDF_STATUS相关状态 | 获取Pin推拉强度 |
| SetPinFunc | **cntlr**：结构体指针，核心层pin控制器；<br/>**index**：uint32_t变量，管脚索引号；<br/>**funcName**：char指针常量，传入pin函数名称； | HDF_STATUS相关状态 | 设置pin函数 | | SetPinFunc | **cntlr**：结构体指针，核心层Pin控制器；<br/>**index**：uint32_t变量，管脚索引号；<br/>**funcName**：char指针常量，传入Pin管脚功能； | HDF_STATUS相关状态 | 设置Pin管脚功能 |
| GetPinFunc | **cntlr**：结构体指针，核心层pin控制器；<br/>**index**：uint32_t变量，管脚索引号；<br/>**funcName**：char双重指针常量，传出pin函数名称； | HDF_STATUS相关状态 | 获取pin函数 | | GetPinFunc | **cntlr**：结构体指针，核心层Pin控制器；<br/>**index**：uint32_t变量，管脚索引号；<br/>**funcName**：char双重指针常量，传出Pin管脚功能； | HDF_STATUS相关状态 | 获取Pin管脚功能 |
## 开发步骤 <a name="section3_PINDevelop"></a> ## 开发步骤 <a name="section3_PinDevelop"></a>
PIN模块适配的三个环节是配置属性文件、实例化驱动入口、以及实例化核心层接口函数。 PIN模块适配的三个环节是实例化驱动入口、配置属性文件、以及实例化核心层接口函数。
1. **实例化驱动入口：** 1. **实例化驱动入口：**
- 实例化HdfDriverEntry结构体成员。 - 实例化HdfDriverEntry结构体成员。
- 调用HDF_INIT将HdfDriverEntry实例化对象注册到HDF框架中。 - 调用HDF_INIT将HdfDriverEntry实例化对象注册到HDF框架中。
2. **配置属性文件：** 2. **配置属性文件：**
- 在device_info.hcs文件中添加deviceNode描述。 - 在device_info.hcs文件中添加deviceNode描述。
- 【可选】添加pin_config.hcs器件属性文件。 - 【可选】添加pin_config.hcs器件属性文件。
3. **实例化PIN控制器对象：** 3. **实例化PIN控制器对象：**
- 初始化PinCntlr成员。 - 初始化PinCntlr成员。
- 实例化PinCntlr成员PinCntlrMethod， - 实例化PinCntlr成员PinCntlrMethod。
>![](../public_sys-resources/icon-note.gif) **说明：** >![](../public_sys-resources/icon-note.gif) **说明：**
>实例化PinCntlr成员PinCntlrMethod，其定义和成员说明见[接口说明](#section2_PINDevelop)。 >实例化PinCntlr成员PinCntlrMethod，其定义和成员说明见[接口说明](#section2_PINDevelop)。
4. **驱动调试：** 4. **驱动调试：**
- 【可选】针对新增驱动程序，建议验证驱动基本功能，例如挂载后的信息反馈，数据传输的成功与否等。 - 【可选】针对新增驱动程序，建议验证驱动基本功能，例如挂载后的信息反馈，数据传输的成功与否等。
## 开发实例 <a name="section4_PINDevelop"></a> ## 开发实例 <a name="section4_PinDevelop"></a>
下方将以pin_hi35xx.c为示例，展示需要厂商提供哪些内容来完整实现设备功能。 下方将以pin_hi35xx.c为示例，展示需要厂商提供哪些内容来完整实现设备功能。
...@@ -80,13 +81,16 @@ PIN模块适配的三个环节是配置属性文件、实例化驱动入口、 ...@@ -80,13 +81,16 @@ PIN模块适配的三个环节是配置属性文件、实例化驱动入口、
.Bind = Hi35xxPinBind, .Bind = Hi35xxPinBind,
.Init = Hi35xxPinInit, .Init = Hi35xxPinInit,
.Release = Hi35xxPinRelease, .Release = Hi35xxPinRelease,
.moduleName = "hi35xx_pin_driver",//【必要 且与 HCS文件中里面的moduleName匹配】 .moduleName = "hi35xx_pin_driver",//【必要且与HCS文件中里面的moduleName匹配】
}; };
//调用HDF_INIT将驱动入口注册到HDF框架中 //调用HDF_INIT将驱动入口注册到HDF框架中
HDF_INIT(g_hi35xxPinDriverEntry); HDF_INIT(g_hi35xxPinDriverEntry);
``` ```
2. 完成驱动入口注册之后，下一步请在device\_info.hcs文件中添加deviceNode信息，并在 pin\_config.hcs 中配置器件属性。deviceNode信息与驱动入口注册相关，器件属性值与核心层PinCntlr成员的默认值或限制范围有密切关系。 如有更多个器件信息，则需要在device\_info文件增加deviceNode信息，以及在pin\_config文件中增加对应的器件属性**。** 2. 完成驱动入口注册之后，下一步请在device\_info.hcs文件中添加deviceNode信息，并在pin\_config.hcs中配置器件属性。deviceNode信息与驱动入口注册相关，器件属性值与核心层PinCntlr成员的默认值或限制范围有密切关系。
>![](../public_sys-resources/icon-note.gif) **说明：**
>如有更多个器件信息，则需要在device\_info文件增加deviceNode信息，以及在pin\_config文件中增加对应的器件属性。
- device\_info.hcs 配置参考。 - device\_info.hcs 配置参考。
...@@ -97,21 +101,21 @@ PIN模块适配的三个环节是配置属性文件、实例化驱动入口、 ...@@ -97,21 +101,21 @@ PIN模块适配的三个环节是配置属性文件、实例化驱动入口、
hostName = "platform_host"; hostName = "platform_host";
priority = 50; priority = 50;
device_pin :: device { device_pin :: device {
device0 :: deviceNode { //为每一个 regulator 控制器配置一个HDF设备节点，存在多个时【必须】添加，否则不用 device0 :: deviceNode { //为每一个Pin控制器配置一个HDF设备节点，存在多个时须添加，否则不用
policy = 0; //2:用户态可见,1:内核态可见,0:不需要发布服务 policy = 0; //2:用户态可见,1:内核态可见,0:不需要发布服务
priority = 10; // 驱动启动优先级 priority = 10; // 驱动启动优先级
permission = 0644; // 驱动创建设备节点权限 permission = 0644; // 驱动创建设备节点权限
/*【必要】用于指定驱动名称，需要与期望的驱动Entry中的moduleName一致；*/ /*【必要】用于指定驱动名称，需要与期望的驱动Entry中的moduleName一致；*/
moduleName = "hi35xx_pin_driver"; moduleName = "hi35xx_Pin_driver";
/*【必要】用于配置控制器私有数据，要与pin_config.hcs中对应控制器保持一致，具体的控制器信息在pin_config.hcs 中*/ /*【必要】用于配置控制器私有数据，要与Pin_config.hcs中对应控制器保持一致，具体的控制器信息在Pin_config.hcs 中*/
deviceMatchAttr = "hisilicon_hi35xx_pin_0"; deviceMatchAttr = "hisilicon_hi35xx_Pin_0";
} }
device1 :: deviceNode { device1 :: deviceNode {
policy = 0; policy = 0;
priority = 10; priority = 10;
permission = 0644; permission = 0644;
moduleName = "hi35xx_pin_driver"; moduleName = "hi35xx_Pin_driver";
deviceMatchAttr = "hisilicon_hi35xx_pin_1"; deviceMatchAttr = "hisilicon_hi35xx_Pin_1";
} }
... ...
} }
...@@ -120,38 +124,37 @@ PIN模块适配的三个环节是配置属性文件、实例化驱动入口、 ...@@ -120,38 +124,37 @@ PIN模块适配的三个环节是配置属性文件、实例化驱动入口、
} }
``` ```
- pin\_config.hcs 配置参考。 - Pin\_config.hcs 配置参考。
```c ```c
root { root {
platform { platform {
pin_config_hi35xx { Pin_config_hi35xx {
template pin_controller { //【必要】模板配置，继承该模板的节点如果使用模板中的默认值，则节点字段可以缺省 template Pin_controller { //【必要】模板配置，继承该模板的节点如果使用模板中的默认值，则节点字段可以缺省
number = 0; number = 0; //【必要】controller 编号
regStartBasePhy = 0; regStartBasePhy = 0; //【必要】寄存器物理基地址起始地址
regSize = 0; regSize = 0; //【必要】寄存器位宽
pinCount = 0; PinCount = 0; //【必要】管脚数量
match_attr = ""; match_attr = "";
template pin_desc { template Pin_desc {
pinName = ""; PinName = ""; //【必要】管脚名称
regSize = 0; init = 0; //【必要】寄存器默认值
init = 0; F0 = ""; //【必要】功能0
F0 = ""; F1 = ""; //功能1
F1 = ""; F2 = ""; //功能2
F2 = ""; F3 = ""; //功能3
F3 = ""; F4 = ""; //功能4
F4 = ""; F5 = ""; //功能5
F5 = "";
} }
} }
controller_0 :: pin_controller { controller_0 :: Pin_controller {
number = 0; number = 0;
regStartBasePhy = 0x10FF0000; regStartBasePhy = 0x10FF0000;
regSize = 0x48; regSize = 0x48;
pinCount = 18; PinCount = 18;
match_attr = "hisilicon_hi35xx_pin_0"; match_attr = "hisilicon_hi35xx_Pin_0";
T1 :: pin_desc { T1 :: Pin_desc {
pinName = "T1"; PinName = "T1";
init = 0x0600; init = 0x0600;
F0 = "EMMC_CLK"; F0 = "EMMC_CLK";
F1 = "SFC_CLK"; F1 = "SFC_CLK";
...@@ -159,17 +162,17 @@ PIN模块适配的三个环节是配置属性文件、实例化驱动入口、 ...@@ -159,17 +162,17 @@ PIN模块适配的三个环节是配置属性文件、实例化驱动入口、
} }
... ...
} }
...//存在多个设备时【必须】添加，否则不用 ...//每个Pin控制器对应一个controller节点，如存在多个Pin控制器，请依次添加对应的controller节点。
} }
} }
} }
``` ```
3. 完成驱动入口注册之后，最后一步就是以核心层PinCntlr对象的初始化为核心，包括厂商自定义结构体（传递参数和数据），实例化PinCntlr成员PinCntlrMethod（让用户可以通过接口来调用驱动底层函数），实现HdfDriverEntry成员函数（Bind，Init，Release）。 3. 完成驱动入口注册之后，最后一步就是对核心层PinCntlr对象的初始化，包括厂商自定义结构体（传递参数和数据），实例化PinCntlr成员PinCntlrMethod（让用户可以通过接口来调用驱动底层函数），实现HdfDriverEntry成员函数（Bind，Init，Release）。
- 自定义结构体参考。 - 自定义结构体参考。
从驱动的角度看，自定义结构体是参数和数据的载体，而且pin\_config.hcs文件中的数值会被HDF读入通过DeviceResourceIface来初始化结构体成员，一些重要数值也会传递给核心层对象，例如设备号等。 从驱动的角度看，PinCntlr结构体是参数和数据的载体，HDF框架通过DeviceResourceIface将pin\_config.hcs文件中的数值读入其中。
```c ```c
// PinCntlr是核心层控制器结构体，其中的成员在Init函数中会被赋值 // PinCntlr是核心层控制器结构体，其中的成员在Init函数中会被赋值
...@@ -178,23 +181,23 @@ PIN模块适配的三个环节是配置属性文件、实例化驱动入口、 ...@@ -178,23 +181,23 @@ PIN模块适配的三个环节是配置属性文件、实例化驱动入口、
struct HdfDeviceObject *device; struct HdfDeviceObject *device;
struct PinCntlrMethod *method; struct PinCntlrMethod *method;
struct DListHead node; struct DListHead node;
OsalSpinlock spin; OsalSPinlock sPin;
uint16_t number; uint16_t number;
uint16_t pinCount; uint16_t PinCount;
struct PinDesc *pins; struct PinDesc *Pins;
void *priv; void *priv;
}; };
struct PinDesc { struct PinDesc {
const char *pinName; //pin名称 const char *PinName; //Pin管脚名
void *priv; void *priv;
}; };
``` ```
- PinCntlr成员回调函数结构体PinCntlrMethod的实例化，其他成员在Init函数中初始化。 - 实例化PinCntlr成员PinCntlrMethod，其他成员在Init函数中初始化。
```c ```c
// pin_hi35xx.c 中的示例：钩子函数的填充 // Pin_hi35xx.c 中的示例：钩子函数的填充
static struct PinCntlrMethod g_method = { static struct PinCntlrMethod g_method = {
.SetPinPull = Hi35xxPinSetPull, .SetPinPull = Hi35xxPinSetPull,
.GetPinPull = Hi35xxPinGetPull, .GetPinPull = Hi35xxPinGetPull,
...@@ -213,7 +216,7 @@ PIN模块适配的三个环节是配置属性文件、实例化驱动入口、 ...@@ -213,7 +216,7 @@ PIN模块适配的三个环节是配置属性文件、实例化驱动入口、
返回值： 返回值：
HDF\_STATUS相关状态 （下表为部分展示，如需使用其他状态，可见//drivers/framework/include/utils/hdf\_base.h中HDF\_STATUS 定义）。 HDF\_STATUS相关状态 （下表为部分展示，如需使用其他状态，可见/drivers/framework/include/utils/hdf\_base.h中HDF\_STATUS 定义）。
**表 2** HDF\_STATUS相关状态 **表 2** HDF\_STATUS相关状态
...@@ -256,59 +259,58 @@ PIN模块适配的三个环节是配置属性文件、实例化驱动入口、 ...@@ -256,59 +259,58 @@ PIN模块适配的三个环节是配置属性文件、实例化驱动入口、
</tbody> </tbody>
</table> </table>
函数说明：
初始化自定义结构体和PinCntlr成员，并通过调用核心层PinCntlrAdd函数挂载Pin控制器。
```c
static int32_t Hi35xxPinInit(struct HdfDeviceObject *device)
{
...
struct Hi35xxPinCntlr *hi35xx = NULL;
...
ret = Hi35xxPinCntlrInit(device, hi35xx); //读取hcs文件信息
...
DEV_RES_NODE_FOR_EACH_CHILD_NODE(device->property, childNode) {
ret = Hi35xxPinParsePinNode(childNode, hi35xx, index); //【必要】实现如下
...
}
hi35xx->cntlr.method = &g_method; //实例化ops
ret = PinCntlrAdd(&hi35xx->cntlr); //挂载控制器
...
}
static int32_t Hi35xxPinParsePinNode(const struct DeviceResourceNode *node,
struct Hi35xxPinCntlr *hi35xx,
int32_t index)
{
...
hi35xx->cntlr.Pins[index].PinName = hi35xx->desc[index].PinName; //实例化PinName
hi35xx->cntlr.Pins[index].priv = (void *)node; //实例化节点
...
}
```c
函数说明：
初始化自定义结构体对象，初始化PinCntlr成员，调用核心层PinCntlrAdd函数。
static int32_t Hi35xxPinInit(struct HdfDeviceObject *device)
{
...
struct Hi35xxPinCntlr *hi35xx = NULL;
...
ret = Hi35xxPinCntlrInit(device, hi35xx); //读取hcs文件信息
...
DEV_RES_NODE_FOR_EACH_CHILD_NODE(device->property, childNode) {
ret = Hi35xxPinParsePinNode(childNode, hi35xx, index); //【必要】实现如下
...
}
hi35xx->cntlr.method = &g_method; //实例化ops
ret = PinCntlrAdd(&hi35xx->cntlr); //挂载控制器
...
}
static int32_t Hi35xxPinParsePinNode(const struct DeviceResourceNode *node,
struct Hi35xxPinCntlr *hi35xx,
int32_t index)
{
...
hi35xx->cntlr.pins[index].pinName = hi35xx->desc[index].pinName; //实例化pinName
hi35xx->cntlr.pins[index].priv = (void *)node; //实例化节点
...
}
```
- Release 函数参考 - Release 函数参考
入参： 入参：
HdfDeviceObject 是整个驱动对外暴露的接口参数，具备 HCS 配置文件的信息。 HdfDeviceObject 是整个驱动对外暴露的接口参数，具备 HCS 配置文件的信息。
返回值： 返回值：
无。 无。
函数说明： 函数说明：
释放内存和删除控制器，该函数需要在驱动入口结构体中赋值给 Release 接口， 当HDF框架调用Init函数初始化驱动失败时，可以调用 Release 释放驱动资源。 释放内存和删除控制器，该函数需要在驱动入口结构体中赋值给 Release 接口， 当HDF框架调用Init函数初始化驱动失败时，可以调用 Release 释放驱动资源。
```c ```c
static void Hi35xxPinRelease(struct HdfDeviceObject *device) static void Hi35xxPinRelease(struct HdfDeviceObject *device)
{ {
struct PinCntlr *cntlr = NULL; struct PinCntlr *cntlr = NULL;
... ...
PinCntlrRemove(cntlr);//【必要】调用核心层函数，释放PinCntlr的设备和服务 PinCntlrRemove(cntlr);//【必要】调用核心层函数，释放PinCntlr的设备和服务
... ...
} }
``` ```
zh-cn/device-dev/driver/driver-platform-regulator-des.md.md
浏览文件 @ ea659ced
...@@ -9,9 +9,9 @@ ...@@ -9,9 +9,9 @@
- [使能](#section3.4_REGULATOR_des) - [使能](#section3.4_REGULATOR_des)
- [禁用](#section3.5_REGULATOR_des) - [禁用](#section3.5_REGULATOR_des)
- [强制禁用](#section3.6_REGULATOR_des) - [强制禁用](#section3.6_REGULATOR_des)
- [设置REGULATOR设备电压](#section3.7_REGULATOR_des) - [设置REGULATOR电压输出电压范围](#section3.7_REGULATOR_des)
- [获取REGULATOR设备电压](#section3.8_REGULATOR_des) - [获取REGULATOR设备电压](#section3.8_REGULATOR_des)
- [设置REGULATOR设备电流](#section3.9_REGULATOR_des) - [设置REGULATOR设备输出电流范围](#section3.9_REGULATOR_des)
- [获取REGULATOR设备电流](#section3.10_REGULATOR_des) - [获取REGULATOR设备电流](#section3.10_REGULATOR_des)
- [获取REGULATOR设备状态](#section3.11_REGULATOR_des) - [获取REGULATOR设备状态](#section3.11_REGULATOR_des)
- [使用实例](#section4_REGULATOR_des) - [使用实例](#section4_REGULATOR_des)
...@@ -22,13 +22,13 @@ ...@@ -22,13 +22,13 @@
- REGULATOR接口定义了操作REGULATOR设备的通用方法集合，包括： - REGULATOR接口定义了操作REGULATOR设备的通用方法集合，包括：
- REGULATOR设备句柄获取和销毁。 - REGULATOR设备句柄获取和销毁。
- REGULATOR电压、电流的设置。 - REGULATOR设备电压、电流的设置。
- REGULATOR使能和关闭。 - REGULATOR设备使能和关闭。
- REGULATOR电压、电流和状态的获取 - REGULATOR设备电压、电流和状态的获取
## 接口说明<a name="section2_REGULATOR_des"></a> ## 接口说明<a name="section2_REGULATOR_des"></a>
**表1** REGULATOR设备API接口功能介绍 **表1** REGULATOR设备API功能介绍
<a name="table1_REGULATOR_des"></a> <a name="table1_REGULATOR_des"></a>
...@@ -65,22 +65,22 @@ ...@@ -65,22 +65,22 @@
<td>强制禁用REGULATOR</td> <td>强制禁用REGULATOR</td>
</tr> </tr>
<tr height="19" style="height:14.25pt"> <tr height="19" style="height:14.25pt">
<td rowspan="2" height="38" class="xl65" style="height:28.5pt">设置/获取REGULATOR电压</td> <td rowspan="2" height="38" class="xl65" style="height:28.5pt">设置/获取REGULATOR输出电压</td>
<td>RegulatorSetVoltage</td> <td>RegulatorSetVoltage</td>
<td>设置REGULATOR电压</td> <td>设置REGULATOR输出电压</td>
</tr> </tr>
<tr height="19" style="height:14.25pt"> <tr height="19" style="height:14.25pt">
<td height="19" style="height:14.25pt">RegulatorGetVoltage</td> <td height="19" style="height:14.25pt">RegulatorGetVoltage</td>
<td>获取REGULATOR电压</td> <td>获取REGULATOR输出电压</td>
</tr> </tr>
<tr height="19" style="height:14.25pt"> <tr height="19" style="height:14.25pt">
<td rowspan="2" height="38" class="xl65" style="height:28.5pt">设置/获取REGULATOR电流</td> <td rowspan="2" height="38" class="xl65" style="height:28.5pt">设置/获取REGULATOR输出电流</td>
<td>RegulatorSetCurrent</td> <td>RegulatorSetCurrent</td>
<td>设置REGULATOR电流</td> <td>设置REGULATOR输出电流</td>
</tr> </tr>
<tr height="19" style="height:14.25pt"> <tr height="19" style="height:14.25pt">
<td height="19" style="height:14.25pt">RegulatorGetCurrent</td> <td height="19" style="height:14.25pt">RegulatorGetCurrent</td>
<td>获取REGULATOR电流</td> <td>获取REGULATOR输出电流</td>
</tr> </tr>
<tr height="19" style="height:14.25pt"> <tr height="19" style="height:14.25pt">
<td height="19" class="xl66" style="height:14.25pt">获取REGULATOR状态</td> <td height="19" class="xl66" style="height:14.25pt">获取REGULATOR状态</td>
...@@ -96,7 +96,6 @@ ...@@ -96,7 +96,6 @@
<!--[endif]--> <!--[endif]-->
</tbody></table> </tbody></table>
>![](../public_sys-resources/icon-note.gif) **说明：** >![](../public_sys-resources/icon-note.gif) **说明：**
>REGULATOR当前仅限内核态使用，不支持在用户态使用。 >REGULATOR当前仅限内核态使用，不支持在用户态使用。
...@@ -115,7 +114,7 @@ ...@@ -115,7 +114,7 @@
### 获取REGULATOR设备句柄<a name="section3.2_REGULATOR_des"></a> ### 获取REGULATOR设备句柄<a name="section3.2_REGULATOR_des"></a>
在操作REGULATOR设备时，首先要调用RegulatorOpen获取REGULATOR设备句柄，该函数会返回指定设备号的REGULATOR设备句柄。 在操作REGULATOR设备时，首先要调用RegulatorOpen获取REGULATOR设备句柄，该函数会返回指定设备名称的REGULATOR设备句柄。
```c ```c
DevHandle RegulatorOpen(const char *name); DevHandle RegulatorOpen(const char *name);
...@@ -218,7 +217,7 @@ int32_t RegulatorDisable(DevHandle handle); ...@@ -218,7 +217,7 @@ int32_t RegulatorDisable(DevHandle handle);
```c ```c
int32_t ret; int32_t ret;
/*禁用REGULATOR设备*/ /*禁用REGULATOR设备，如果REGULATOR设备状态为常开，或存在REGULATOR设备子节点未禁用，则禁用失败*/
ret = RegulatorDisable(handle); ret = RegulatorDisable(handle);
if (ret != 0) { if (ret != 0) {
/*错误处理*/ /*错误处理*/
...@@ -247,15 +246,15 @@ int32_t RegulatorForceDisable(DevHandle handle); ...@@ -247,15 +246,15 @@ int32_t RegulatorForceDisable(DevHandle handle);
```c ```c
int32_t ret; int32_t ret;
/*强制禁用REGULATOR设备*/ /*强制禁用REGULATOR设备，无论REGULATOR设备的状态是常开还是子节点已使能，REGULATOR设备都会被禁用*/
ret = RegulatorForceDisable(handle); ret = RegulatorForceDisable(handle);
if (ret != 0) { if (ret != 0) {
/*错误处理*/ /*错误处理*/
} }
``` ```
### 设置REGULATOR电压<a name="section3.7_REGULATOR_des"></a> ### 设置REGULATOR输出电压范围<a name="section3.7_REGULATOR_des"></a>
设置REGULATOR电压。 设置REGULATOR电压输出电压范围。
```c ```c
int32_t RegulatorSetVoltage(DevHandle handle, uint32_t minUv, uint32_t maxUv); int32_t RegulatorSetVoltage(DevHandle handle, uint32_t minUv, uint32_t maxUv);
...@@ -279,7 +278,7 @@ int32_t ret; ...@@ -279,7 +278,7 @@ int32_t ret;
int32_t minUv = 0; //最小电压为0Uv int32_t minUv = 0; //最小电压为0Uv
int32_t maxUv = 20000; //最大电压为20000Uv int32_t maxUv = 20000; //最大电压为20000Uv
/*设置REGULATOR电压*/ /*设置REGULATOR电压输出电压范围*/
ret = RegulatorSetVoltage(handle, minUv, maxUv); ret = RegulatorSetVoltage(handle, minUv, maxUv);
if (ret != 0) { if (ret != 0) {
/*错误处理*/ /*错误处理*/
...@@ -317,9 +316,9 @@ if (ret != 0) { ...@@ -317,9 +316,9 @@ if (ret != 0) {
``` ```
### 设置REGULATOR电流<a name="section3.9_REGULATOR_des"></a> ### 设置REGULATOR输出电流范围<a name="section3.9_REGULATOR_des"></a>
设置REGULATOR电流。 设置REGULATOR输出电流范围。
```c ```c
int32_t RegulatorSetCurrent(DevHandle handle, uint32_t minUa, uint32_t maxUa); int32_t RegulatorSetCurrent(DevHandle handle, uint32_t minUa, uint32_t maxUa);
...@@ -340,10 +339,10 @@ int32_t RegulatorSetCurrent(DevHandle handle, uint32_t minUa, uint32_t maxUa); ...@@ -340,10 +339,10 @@ int32_t RegulatorSetCurrent(DevHandle handle, uint32_t minUa, uint32_t maxUa);
```c ```c
int32_t ret; int32_t ret;
int32_t minUa = 0; //最小电压为0Ua int32_t minUa = 0; //最小电流为0Ua
int32_t maxUa = 200; //最大电压为200Ua int32_t maxUa = 200; //最大电流为200Ua
/*设置REGULATOR电流*/ /*设置REGULATOR输出电流范围*/
ret = RegulatorSetCurrent(handle, minUa, maxUa); ret = RegulatorSetCurrent(handle, minUa, maxUa);
if (ret != 0) { if (ret != 0) {
/*错误处理*/ /*错误处理*/
...@@ -413,7 +412,7 @@ if (ret != 0) { ...@@ -413,7 +412,7 @@ if (ret != 0) {
## 使用实例<a name="section4_REGULATOR_des"></a> ## 使用实例<a name="section4_REGULATOR_des"></a>
REGULATOR设备完整的使用示例如下所示，首先获取REGULATOR设备句柄，然后使能，设置电压、电流，获取电压、电流、状态，禁用，最后销毁REGULATOR设备句柄。 REGULATOR设备完整的使用示例如下所示，首先获取REGULATOR设备句柄，然后使能，设置电压，获取电压、状态，禁用，最后销毁REGULATOR设备句柄。
```c ```c
void RegulatorTestSample(void) void RegulatorTestSample(void)
...@@ -441,7 +440,7 @@ void RegulatorTestSample(void) ...@@ -441,7 +440,7 @@ void RegulatorTestSample(void)
int32_t minUv = 0; //最小电压为0Uv int32_t minUv = 0; //最小电压为0Uv
int32_t maxUv = 20000; //最大电压为20000Uv int32_t maxUv = 20000; //最大电压为20000Uv
/*设置REGULATOR电压*/ /*设置REGULATOR输出电压范围*/
ret = RegulatorSetVoltage(handle, minUv, maxUv); ret = RegulatorSetVoltage(handle, minUv, maxUv);
if (ret != 0) { if (ret != 0) {
HDF_LOGE("RegulatorSetVoltage: failed, ret %d\n", ret); HDF_LOGE("RegulatorSetVoltage: failed, ret %d\n", ret);
...@@ -457,25 +456,6 @@ void RegulatorTestSample(void) ...@@ -457,25 +456,6 @@ void RegulatorTestSample(void)
goto _ERR; goto _ERR;
} }
int32_t minUa = 0; //最小电压为0Ua
int32_t maxUa = 200; //最大电压为200Ua
/*设置REGULATOR电流*/
ret = RegulatorSetCurrent(handle, minUa, maxUa);
if (ret != 0) {
HDF_LOGE("RegulatorSetCurrent: failed, ret %d\n", ret);
goto _ERR;
}
uint32_t regCurrent;
/*获取REGULATOR电流*/
ret = RegulatorGetCurrent(handle, &regCurrent);
if (ret != 0) {
HDF_LOGE("RegulatorGetCurrent: failed, ret %d\n", ret);
goto _ERR;
}
uint32_t status; uint32_t status;
/*获取REGULATOR状态*/ /*获取REGULATOR状态*/
......
zh-cn/device-dev/driver/driver-platform-regulator-develop.md
浏览文件 @ ea659ced
...@@ -42,15 +42,15 @@ struct RegulatorMethod { ...@@ -42,15 +42,15 @@ struct RegulatorMethod {
| enable | **node**：结构体指针，核心层regulator节点； | HDF_STATUS相关状态 | 使能 | | enable | **node**：结构体指针，核心层regulator节点； | HDF_STATUS相关状态 | 使能 |
| disable | **node**：结构体指针，核心层regulator节点； | HDF_STATUS相关状态 | 禁用 | | disable | **node**：结构体指针，核心层regulator节点； | HDF_STATUS相关状态 | 禁用 |
| forceDisable | **node**：结构体指针，核心层regulator节点； | HDF_STATUS相关状态 | 强制禁用 | | forceDisable | **node**：结构体指针，核心层regulator节点； | HDF_STATUS相关状态 | 强制禁用 |
| setVoltage | **node**：结构体指针，核心层regulator节点；<br>**minUv**：uint32_t变量，最小电压；<br>**maxUv**：uint32_t变量，最大电压； | HDF_STATUS相关状态 | 设置电压 | | setVoltage | **node**：结构体指针，核心层regulator节点；<br>**minUv**：uint32_t变量，最小电压；<br>**maxUv**：uint32_t变量，最大电压； | HDF_STATUS相关状态 | 设置输出电压范围 |
| getVoltage | **node**：结构体指针，核心层regulator节点；<br>**voltage**：uint32_t指针，传出电压值； | HDF_STATUS相关状态 | 获取电压 | | getVoltage | **node**：结构体指针，核心层regulator节点；<br>**voltage**：uint32_t指针，传出电压值； | HDF_STATUS相关状态 | 获取电压 |
| setCurrent | **node**：结构体指针，核心层regulator节点；<br>**minUa**：uint32_t变量，最小电流；<br>**maxUa**：uint32_t变量，最大电流； | HDF_STATUS相关状态 | 设置电流 | | setCurrent | **node**：结构体指针，核心层regulator节点；<br>**minUa**：uint32_t变量，最小电流；<br>**maxUa**：uint32_t变量，最大电流； | HDF_STATUS相关状态 | 设置输出电流范围 |
| getCurrent | **node**：结构体指针，核心层regulator节点；<br>**regCurrent**：uint32_t指针，传出电流值； | HDF_STATUS相关状态 | 获取电流 | | getCurrent | **node**：结构体指针，核心层regulator节点；<br>**regCurrent**：uint32_t指针，传出电流值； | HDF_STATUS相关状态 | 获取电流 |
| getStatus | **node**：结构体指针，核心层regulator节点；<br>**status**：uint32_t指针，传出状态值； | HDF_STATUS相关状态 | 获取状态 | | getStatus | **node**：结构体指针，核心层regulator节点；<br>**status**：uint32_t指针，传出状态值； | HDF_STATUS相关状态 | 获取设备状态 |
## 开发步骤 <a name="section3_REGULATORDevelop"></a> ## 开发步骤 <a name="section3_REGULATORDevelop"></a>
REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入口、以及实例化核心层接口函数。 REGULATOR模块适配的三个环节是实例化驱动入口、配置属性文件、以及实例化核心层接口函数。
1. **实例化驱动入口：** 1. **实例化驱动入口：**
...@@ -66,7 +66,7 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入 ...@@ -66,7 +66,7 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入
- 初始化RegulatorNode成员。 - 初始化RegulatorNode成员。
- 实例化RegulatorNode成员RegulatorMethod， - 实例化RegulatorNode成员RegulatorMethod。
>![](../public_sys-resources/icon-note.gif) **说明：** >![](../public_sys-resources/icon-note.gif) **说明：**
>实例化RegulatorNode成员RegulatorMethod，其定义和成员说明见[接口说明](#section2_REGULATORDevelop)。 >实例化RegulatorNode成员RegulatorMethod，其定义和成员说明见[接口说明](#section2_REGULATORDevelop)。
...@@ -87,7 +87,7 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入 ...@@ -87,7 +87,7 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入
```c ```c
struct HdfDriverEntry g_regulatorDriverEntry = { struct HdfDriverEntry g_regulatorDriverEntry = {
.moduleVersion = 1, .moduleVersion = 1,
.moduleName = "virtual_regulator_driver",//【必要 且与 HCS文件中里面的moduleName匹配】 .moduleName = "virtual_regulator_driver",//【必要且与HCS文件中里面的moduleName匹配】
.Init = VirtualRegulatorInit, .Init = VirtualRegulatorInit,
.Release = VirtualRegulatorRelease, .Release = VirtualRegulatorRelease,
}; };
...@@ -95,7 +95,10 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入 ...@@ -95,7 +95,10 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入
HDF_INIT(g_regulatorDriverEntry); HDF_INIT(g_regulatorDriverEntry);
``` ```
2. 完成驱动入口注册之后，下一步请在device\_info.hcs文件中添加deviceNode信息，并在 regulator\_config.hcs 中配置器件属性。deviceNode信息与驱动入口注册相关，器件属性值与核心层RegulatorNode成员的默认值或限制范围有密切关系。 如有更多个器件信息，则需要在device\_info文件增加deviceNode信息，以及在regulator\_config文件中增加对应的器件属性**。** 2. 完成驱动入口注册之后，下一步请在device\_info.hcs文件中添加deviceNode信息，并在regulator\_config.hcs中配置器件属性。deviceNode信息与驱动入口注册相关，器件属性值与核心层RegulatorNode成员的默认值或限制范围有密切关系。
>![](W:\docs\zh-cn\device-dev\public_sys-resources\icon-note.gif) **说明：**
>如有更多个器件信息，则需要在device\_info文件增加deviceNode信息，以及在regulator\_config文件中增加对应的器件属性。
- device\_info.hcs 配置参考。 - device\_info.hcs 配置参考。
...@@ -106,8 +109,8 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入 ...@@ -106,8 +109,8 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入
hostName = "platform_host"; hostName = "platform_host";
priority = 50; priority = 50;
device_regulator :: device { device_regulator :: device {
device0 :: deviceNode { //为每一个 regulator 控制器配置一个HDF设备节点，存在多个时【必须】添加，否则不用 device0 :: deviceNode { //为每一个REGULATOR控制器配置一个HDF设备节点，存在多个时添加，否则不用
policy = 1; // 等于1，向内核态发布服务 policy = 1; // 2:用户态可见,1:内核态可见,0:不需要发布服务
priority = 50; // 驱动启动优先级 priority = 50; // 驱动启动优先级
permission = 0644; // 驱动创建设备节点权限 permission = 0644; // 驱动创建设备节点权限
/*【必要】用于指定驱动名称，需要与期望的驱动Entry中的moduleName一致；*/ /*【必要】用于指定驱动名称，需要与期望的驱动Entry中的moduleName一致；*/
...@@ -158,7 +161,8 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入 ...@@ -158,7 +161,8 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入
minUa = 0; minUa = 0;
maxUa = 0; maxUa = 0;
} }
controller_0x130d0001 :: regulator_controller { //存在多个设备时【必须】添加，否则不用 /*每个Regulator控制器对应一个controller节点，如存在多个Regulator控制器，请依次添加对应的controller节点。*/
controller_0x130d0001 :: regulator_controller {
device_num = 1; device_num = 1;
name = "regulator_adapter_2"; name = "regulator_adapter_2";
devName = "regulator_adapter_consumer01"; devName = "regulator_adapter_consumer01";
...@@ -174,11 +178,11 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入 ...@@ -174,11 +178,11 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入
} }
``` ```
3. 完成驱动入口注册之后，最后一步就是以核心层RegulatorNode对象的初始化为核心，包括厂商自定义结构体（传递参数和数据），实例化RegulatorNode成员RegulatorMethod（让用户可以通过接口来调用驱动底层函数），实现HdfDriverEntry成员函数（Bind，Init，Release）。 3. 完成驱动入口注册之后，最后一步就是对核心层RegulatorNode对象的初始化，包括厂商自定义结构体（传递参数和数据），实例化RegulatorNode成员RegulatorMethod（让用户可以通过接口来调用驱动底层函数），实现HdfDriverEntry成员函数（Bind，Init，Release）。
- 自定义结构体参考。 - 自定义结构体参考。
从驱动的角度看，自定义结构体是参数和数据的载体，而且regulator\_config.hcs文件中的数值会被HDF读入通过DeviceResourceIface来初始化结构体成员，一些重要数值也会传递给核心层对象，例如设备名称等。 从驱动的角度看，RegulatorNode结构体是参数和数据的载体，HDF框架通过DeviceResourceIface将regulator\_config.hcs文件中的数值读入其中。
```c ```c
// RegulatorNode是核心层控制器结构体，其中的成员在Init函数中会被赋值 // RegulatorNode是核心层控制器结构体，其中的成员在Init函数中会被赋值
...@@ -194,10 +198,10 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入 ...@@ -194,10 +198,10 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入
const char *name; /* regulator 名称 */ const char *name; /* regulator 名称 */
const char *parentName; /* regulator 父节点名称 */ const char *parentName; /* regulator 父节点名称 */
struct RegulatorConstraints constraints; /* regulator 约束信息 */ struct RegulatorConstraints constraints; /* regulator 约束信息 */
uint32_t minUv; /* 最小电压值 */ uint32_t minUv; /* 最小输出电压值 */
uint32_t maxUv; /* 最大电压值 */ uint32_t maxUv; /* 最大输出电压值 */
uint32_t minUa; /* 最小电流值 */ uint32_t minUa; /* 最小输出电流值 */
uint32_t maxUa; /* 最大电流值 */ uint32_t maxUa; /* 最大输出电流值 */
uint32_t status; /* regulator的状态，开或关 */ uint32_t status; /* regulator的状态，开或关 */
int useCount; int useCount;
int consumerRegNums; /* regulator用户数量 */ int consumerRegNums; /* regulator用户数量 */
...@@ -207,14 +211,14 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入 ...@@ -207,14 +211,14 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入
struct RegulatorConstraints { struct RegulatorConstraints {
uint8_t alwaysOn; /* regulator是否常开 */ uint8_t alwaysOn; /* regulator是否常开 */
uint8_t mode; /* 模式：电压或者电流 */ uint8_t mode; /* 模式：电压或者电流 */
uint32_t minUv; /* 最小可设置电压 */ uint32_t minUv; /* 最小可设置输出电压 */
uint32_t maxUv; /* 最大可设置电压 */ uint32_t maxUv; /* 最大可设置输出电压 */
uint32_t minUa; /* 最小可设置电流 */ uint32_t minUa; /* 最小可设置输出电流 */
uint32_t maxUa; /* 最大可设置电流 */ uint32_t maxUa; /* 最大可设置输出电流 */
}; };
``` ```
- RegulatorNode成员回调函数结构体RegulatorMethod的实例化，其他成员在Init函数中初始化。 - 实例化RegulatorNode成员RegulatorMethod，其他成员在Init函数中初始化。
```c ```c
// regulator_virtual.c 中的示例：钩子函数的填充 // regulator_virtual.c 中的示例：钩子函数的填充
...@@ -279,61 +283,57 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入 ...@@ -279,61 +283,57 @@ REGULATOR模块适配的三个环节是配置属性文件、实例化驱动入
</tr> </tr>
</tbody> </tbody>
</table> </table>
函数说明：
初始化自定义结构体和RegulatorNode成员，并通过调用核心层RegulatorNodeAdd函数挂载Regulator控制器。
```c
函数说明： ```c
static int32_t VirtualRegulatorInit(struct HdfDeviceObject *device)
初始化自定义结构体对象，初始化RegulatorNode成员，调用核心层RegulatorNodeAdd函数。
static int32_t VirtualRegulatorInit(struct HdfDeviceObject *device)
{
int32_t ret;
const struct DeviceResourceNode *childNode = NULL;
...
DEV_RES_NODE_FOR_EACH_CHILD_NODE(device->property, childNode) {
ret = VirtualRegulatorParseAndInit(device, childNode);//【必要】实现见下
...
}
...
}
static int32_t VirtualRegulatorParseAndInit(struct HdfDeviceObject *device, const struct DeviceResourceNode *node)
{
int32_t ret;
struct RegulatorNode *regNode = NULL;
(void)device;
regNode = (struct RegulatorNode *)OsalMemCalloc(sizeof(*regNode));//加载hcs文件
...
ret = VirtualRegulatorReadHcs(regNode, node);//读取hcs文件信息
...
regNode->priv = (void *)node; //实例化节点
regNode->ops = &g_method; //实例化ops
ret = RegulatorNodeAdd(regNode); //挂载节点
...
}
```
- Release 函数参考
入参：
HdfDeviceObject 是整个驱动对外暴露的接口参数，具备 HCS 配置文件的信息。
返回值：
无。
函数说明：
释放内存和删除控制器，该函数需要在驱动入口结构体中赋值给 Release 接口， 当HDF框架调用Init函数初始化驱动失败时，可以调用 Release 释放驱动资源。
```c
static void VirtualRegulatorRelease(struct HdfDeviceObject *device)
{ {
int32_t ret;
const struct DeviceResourceNode *childNode = NULL;
...
DEV_RES_NODE_FOR_EACH_CHILD_NODE(device->property, childNode) {
ret = VirtualRegulatorParseAndInit(device, childNode);//【必要】实现见下
...
}
... ...
RegulatorNodeRemoveAll();//【必要】调用核心层函数，释放RegulatorNode的设备和服务
} }
```
static int32_t VirtualRegulatorParseAndInit(struct HdfDeviceObject *device, const struct DeviceResourceNode *node)
{
int32_t ret;
struct RegulatorNode *regNode = NULL;
(void)device;
regNode = (struct RegulatorNode *)OsalMemCalloc(sizeof(*regNode));//加载HCS文件
...
ret = VirtualRegulatorReadHcs(regNode, node);//读取HCS文件信息
...
regNode->priv = (void *)node; //实例化节点
regNode->ops = &g_method; //实例化ops
ret = RegulatorNodeAdd(regNode); //挂载节点
...
}
- Release 函数参考
入参：
HdfDeviceObject是整个驱动对外暴露的接口参数，其包含了HCS配置文件中的相关配置信息。
返回值：
无。
函数说明：
释放内存和删除控制器，该函数需要在驱动入口结构体中赋值给Release接口，当HDF框架调用Init函数初始化驱动失败时，可以调用Release释放驱动资源。
```c
static void VirtualRegulatorRelease(struct HdfDeviceObject *device)
{
...
RegulatorNodeRemoveAll();//【必要】调用核心层函数，释放RegulatorNode的设备和服务
}
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或