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