Hi3516驱动开发

驱动框架介绍

驱动子系统

内核驱动是软件与硬件交互的桥梁，通过文件系统接口访问OpenHarmony内核的硬件资源，是用户与内核之间、进程与进程之间通信的一种方式。每类驱动代表一种能力，用户可以根据需求选择对应驱动，完成数据的传输。OpenHarmony驱动子系统采用C面向对象编程模型构建，通过平台解耦、内核解耦，兼容不同内核，提供了归一化的驱动平台底座，旨在为开发者提供更精准、更高效的开发环境，力求做到一次开发，多系统部署。

1、架构

OpenHarmony驱动框架采用主从架构设计模式，围绕着框架、模型、能力库和工具四个维度能力展开构建。

2、目录

drivers
├── adapter               #适配平台差异性的代码
├── framework             #驱动框架核心代码
└── peripheral            #外设驱动代码
└── liteos                #hievent和tzdrivert驱动代码。hievent：事件日志管理驱动；tzdrivert：用于ree/tee切换、通讯，提供应用层访问的设备节点

3、驱动框架交互流程

驱动框架完成大部分驱动加载的动作，用户只需注册自己所需的接口和配置，然后驱动框架就会解析配置的内容，完成驱动加载和初始化动作。

4、安装

OpenHarmony驱动主要部署在内核态，当前主要采用静态链接方式，随内核子系统编译和系统镜像打包。

5、HDF驱动加载的过程

HDF Framework

1、简介

HDF Framework提供包括驱动框架、配置管理、配置解析、驱动通用框架模型、硬件通用平台能力接口等，驱动框架的架构图：

2、目录

/drivers/framework
├── ability        #提供驱动开发的能力支持，如消息模型库等
│   ├── config     #配置解析代码
│   └── sbuf       #数据序列化代码
├── core           #实现驱动框架的核心代码
│   ├── adapter    #实现对内核操作接口适配，提供抽象化的接口供开发者使用
│   ├── common     #驱动框架公共基础代码
│   ├── host       #驱动宿主环境模块
│   ├── manager    #驱动框架管理模块
│   └── shared     #host和manager共享模块代码
├── include        #驱动框架对外提供能力的头文件
│   ├── config     #提供配置解析能力的头文件
│   ├── core       #驱动框架对外提供的头文件
│   ├── net        #网络数据操作相关的头文件
│   ├── osal       #系统适配相关接口的头文件
│   ├── platform   #平台设备相关接口的头文件
│   ├── utils      #驱动框架公共能力的头文件
│   └── wifi       #WLAN对外提供能力的头文件
├── model          #提供驱动通用框架模型
│   ├── display    #显示框架模型
│   ├── input      #输入框架模型
│   ├── network    #WLAN框架模型
│   └── sensor     #Sensor驱动模型
├── support        #提系统的基础能力 
│   └── platform   #平台设备驱动框架及访问接口，范围包括GPIO、I2C、SPI等
├── tools          #hdf框架工具相关的源码
│   └── hc-gen     #配置管理工具源码
└── utils          #提供基础数据结构和算法等

HDF适配

HDF适配主要实现OpenHarmony驱动子系统内核或用户态驱动框架的代码和编译脚本，提供驱动框架的能力。

2、目录

/drivers/adapter
├── khdf/linux          #提供驱动框架对Linux内核依赖适配
├── khdf/liteos         #提供驱动框架对LiteOS-A内核依赖适配
├── khdf/liteos_m       #提供驱动框架对LiteOS-M内核依赖适配
├── uhdf                #提供用户态驱动接口对系统依赖适配
└── uhdf2               #提供用户态驱动框架对系统依赖适配

linux khdf

1、简介

drivers/adapter/khdf/linux下提供OpenHarmony驱动子系统适配linux内核的代码和编译脚本，在linux内核中部署OpenHarmony驱动框架。

2、目录

/drivers/adapter/khdf/linux
├── config               #linux内核下编译配置解析代码的编译脚本
├── hcs                  #linux内核下HDF的配置管理目录
├── manager              #linux内核下启动适配启动HDF框架代码
├── model                #驱动模型适配linux代码
│   ├── display          #显示驱动模型
│   ├── input            #输入驱动模型
│   ├── network          #wifi驱动模型
│   └── sensor           #传感器驱动模型
├── network              #适配linux内核网络代码
├── osal                 #适配linux内核的posix接口
├── platform             #平台设备接口适配linux内核代码
│   ├── emmc             #emmc操作接口
│   ├── gpio             #gpio接口
│   ├── i2c              #i2c接口
│   ├── mipi_dsi         #mipi dsi接口
│   ├── pwm              #pwm接口
│   ├── rtc              #rtc接口
│   ├── sdio             #sdio接口
│   ├── spi              #spi接口
│   ├── uart             #uart接口
│   └── watchdog         #watchdog接口

peripheral

1、简介

peripheral主要包含各外设器件驱动相关的HDI（Hardware Driver Interface）接口、HAL实现、驱动模型及测试用例等，根据模块划分不同目录，具体模块的相关信息可参阅各模块子目录下的readme。

2、目录

代码目录为 /drivers/peripheral，其中包含的各子目录简介如下。

• audio：Audio HDI接口的定义，用于管理声卡驱动的加载和卸载、创建音频播放对象3及录音对象、选择音频场景、设置音频属性及音量、控制音频播放及录音的启停等。
• codec：Codec HDI接口的定义，这些接口对上层服务提供媒体编解码的驱动能力。
• display：Display HDI 接口定义及其默认实现，对上层图形服务提供显示驱动能力，包括显示图层的管理、显示内存的管理及硬件图形加速。
• format：Format HDI接口定义，此类接口对上层服务提供媒体文件复用和解复用的驱动能力。
• input：Input HDI接口定义及其实现，对上层输入系统服务提供操作input设备的驱动能力，包括input设备管理、业务流控制、数据上报等。
• sensor：Sensor HDI接口定义与实现，接口主要包括所有Sensor信息查询、Sensor启停、Sensor订阅/去订阅、Sensor参数配置等稳定的接口，简化服务开发。
• wlan：WLAN HDI接口定义与实现，包括创建和销毁HAL层和WLAN驱动的通道、获取本设备支持的WLAN特性等。

HDF

1、HDF驱动开发简介

HDF框架以组件化的驱动模型作为核心设计思路，为开发者提供更精细化的驱动管理，让驱动开发和部署更加规范。HDF框架将一类设备驱动放在同一个host里面，开发者也可以将驱动功能分层独立开发和部署，支持一个驱动多个node，HDF框架管理驱动模型如下图所示：

基于HDF（Hardware Driver Foundation驱动框架）开发驱动，用户只需注册自己所需的接口和配置，然后驱动框架就会解析配置的内容，完成驱动加载和初始化动作。

开发者基于HDF驱动框架开发的驱动主要包含三大部分：

1、驱动程序部分----完成驱动的功能逻辑。

2、驱动配置信息----指示驱动的加载信息内容。

3、驱动资源配置----配置驱动的硬件配置信息。

驱动程序主要是完成驱动功能的逻辑代码：

对于开发者首先看到的是驱动入口部分，驱动入口部分通过DriverEntry进行描述。

其中主要包含Bind, Init 和Release三个接口。

struct HdfDriverEntry g_deviceSample = {
    .moduleVersion = 1,
    .moduleName = "sample_driver", 
    .Bind = SampleDriverBind,
    .Init = SampleDriverInit,
    .Release = SampleDriverRelease,
};

Bind接口描述：该接口的作用主要是完成驱动设备和设备服务接口的bind动作。

int32_t SampleDriverBind(struct HdfDeviceObject *deviceObject)
{
    // TODO: Bind device service to device object.
    // And you can also initialize device resources here.
    return HDF_SUCCESS;
}

Init接口描述：当框架完成设备绑定动作后，就开始调用驱动初始化接口，当初始化成功后，驱动框架根据配置文件决定是否对外创建设备服务接口，还是只是对当前服务接口可见。如果Init初始化失败的话，驱动框架就会主动释放创建的设备接口等信息。

int32_t SampleDriverInit(struct HdfDeviceObject *deviceObject)
{
    // TODO: Init hardware or other resources here.
    return HDF_SUCCESS;
}

Release接口描述：当用户需要卸载驱动时，驱动框架先通过该接口通知驱动程序释放资源。然后在执行其他内部资源释放。

void SampleDriverRelease(struct HdfDeviceObject *deviceObject)
{
    // Release all resources.
    return;
}

2、驱动加载

HDF驱动加载包括按需加载和按序加载。

• 按需加载

  HDF框架支持驱动在系统启动过程中默认加载，或者在系统启动之后动态加载。

  typedef enum {    DEVICE_PRELOAD_ENABLE = 0,    DEVICE_PRELOAD_ENABLE_STEP2,    DEVICE_PRELOAD_DISABLE,    DEVICE_PRELOAD_INVALID} DevicePreload;
  

  配置文件中preload 字段配成 0 （DEVICE_PRELOAD_ENABLE ），则系统启动过程中默认加载；配成1（DEVICE_PRELOAD_ENABLE_STEP2），当系统支持快启的时候，则在系统系统完成之后再加载这一类驱动，否则和DEVICE_PRELOAD_ENABLE 含义相同；

  配成2（DEVICE_PRELOAD_DISABLE），则系统启动过程中默认不加载，支持后续动态加载，当用户态获取驱动服务（参考消息机制）时，如果驱动服务不存在时，HDF框架会尝试动态加载该驱动。

• 按序加载

  HDF框架支持驱动在系统启动的过程中按照驱动的优先级进行加载。

  配置文件中的priority（取值范围为整数0到200）是用来表示host和驱动的优先级，不同的host内的驱动，host的priority值越小，驱动加载优先级越高；同一个host内驱动的priority值越小，加载优先级越高。

3、驱动服务管理

HDF框架可以集中管理驱动服务，开发者可直接通过HDF框架对外提供的能力接口获取驱动相关的服务。

4、驱动消息机制

HDF框架提供统一的驱动消息机制，支持用户态应用向内核态驱动发送消息，也支持内核态驱动向用户态应用发送消息。

驱动开发步骤

驱动实现

驱动实现包含驱动业务代码和驱动入口注册，具体写法如下：

• 驱动业务代码

  #include "hdf_device_desc.h"  // HDF框架对驱动开放相关能力接口的头文件#include "hdf_log.h"          // HDF 框架提供的日志接口头文件#define HDF_LOG_TAG "sample_driver"   // 打印日志所包含的标签，如果不定义则用默认定义的HDF_TAG标签//驱动对外提供的服务能力，将相关的服务接口绑定到HDF框架int32_t HdfSampleDriverBind(struct HdfDeviceObject *deviceObject){    HDF_LOGD("Sample driver bind success");    return 0;}// 驱动自身业务初始的接口int32_t HdfSampleDriverInit(struct HdfDeviceObject *deviceObject){    HDF_LOGD("Sample driver Init success");    return 0;}// 驱动资源释放的接口void HdfSampleDriverRelease(struct HdfDeviceObject *deviceObject){    HDF_LOGD("Sample driver release success");    return;}
  

• 驱动入口注册到HDF框架

  // 定义驱动入口的对象，必须为HdfDriverEntry（在hdf_device_desc.h中定义）类型的全局变量struct HdfDriverEntry g_sampleDriverEntry = {    .moduleVersion = 1,    .moduleName = "sample_driver",    .Bind = HdfSampleDriverBind,    .Init = HdfSampleDriverInit,    .Release = HdfSampleDriverRelease,};// 调用HDF_INIT将驱动入口注册到HDF框架中，在加载驱动时HDF框架会先调用Bind函数,再调用Init函数加载该驱动，当Init调用异常时，HDF框架会调用Release释放驱动资源并退出。HDF_INIT(g_sampleDriverEntry);
  

驱动编译

• 驱动代码的编译必须要使用HDF框架提供的Makefile模板进行编译。

  include $(LITEOSTOPDIR)/../../drivers/adapter/lite/khdf/lite.mk #导入hdf预定义内容，必需MODULE_NAME :=    #生成的结果文件LOCAL_INCLUDE :=  #本驱动的头文件目录LOCAL_SRCS :=     #本驱动的源代码文件LOCAL_CFLAGS ：=  #自定义的编译选项include $(HDF_DRIVER) #导入模板makefile完成编译
  

• 编译结果文件链接到内核镜像，添加到device目录下的lite.mk里面，示例如下：

  LITEOS_BASELIB +=  -lxxx  #链接生成的静态库LIB_SUBDIRS    +=         #驱动代码Makefile的目录
  

驱动配置

HDF使用HCS作为配置描述源码，HCS详细介绍参考配置管理介绍。

驱动配置包含两部分，HDF框架定义的驱动设备描述和驱动的私有配置信息，具体写法如下：

• 驱动设备描述（必选）

  HDF框架加载驱动所需要的信息来源于HDF框架定义的驱动设备描述，因此基于HDF框架开发的驱动必须要在HDF框架定义的device_info.hcs配置文件中添加对应的设备描述，驱动的设备描述填写如下所示：

  root {    device_info {        match_attr = "hdf_manager";        template host {       // host模板，继承该模板的节点（如下sample_host）如果使用模板中的默认值，则节点字段可以缺省            hostName = "";            priority = 100;            template device {                template deviceNode {                    policy = 0;                    priority = 100;                    preload = 0;                    permission = 0664;                    moduleName = "";                    serviceName = "";                    deviceMatchAttr = "";                }            }        }        sample_host :: host{            hostName = "host0";    // host名称，host节点是用来存放某一类驱动的容器            priority = 100;        // host启动优先级（0-200），值越大优先级越低，建议默认配100，优先级相同则不保证host的加载顺序            device_sample :: device {        // sample设备节点                device0 :: deviceNode {      // sample驱动的DeviceNode节点                    policy = 1;              // policy字段是驱动服务发布的策略，在驱动服务管理章节有详细介绍                    priority = 100;          // 驱动启动优先级（0-200），值越大优先级越低，建议默认配100，优先级相同则不保证device的加载顺序                    preload = 0;             // 驱动按需加载字段，在本章节最后的说明有详细介绍                    permission = 0664;       // 驱动创建设备节点权限                    moduleName = "sample_driver";   // 驱动名称，该字段的值必须和驱动入口结构的moduleName值一致                    serviceName = "sample_service";    // 驱动对外发布服务的名称，必须唯一                    deviceMatchAttr = "sample_config"; // 驱动私有数据匹配的关键字，必须和驱动私有数据配置表中的match_attr值相等                }            }        }    }}
  

• 驱动私有配置信息（可选）

  如果驱动有私有配置，则可以添加一个驱动的配置文件，用来填写一些驱动的默认配置信息，HDF框架在加载驱动的时候，会将对应的配置信息获取并保存在HdfDeviceObject 中的property里面，通过Bind和Init（参考驱动开发）传递给驱动，驱动的配置信息示例如下：

  root {    SampleDriverConfig {        sample_version = 1;        sample_bus = "I2C_0";        match_attr = "sample_config";   //该字段的值必须和device_info.hcs中的deviceMatchAttr值一致    }}
  

  配置信息定义之后，需要将该配置文件添加到板级配置入口文件hdf.hcs（这一块可以通过OpenHarmony驱动子系统在DevEco集成驱动开发套件工具一键式配置，具体使用方法参考驱动开发套件中的介绍），示例如下：

  #include "device_info/device_info.hcs"#include "sample/sample_config.hcs"
  

驱动开发示例

下面基于HDF框架，提供一个简单的UART（Universal Asynchronous Receiver/Transmitter）平台驱动开发样例，包含配置文件的添加，驱动代码的实现以及用户态程序和驱动交互的流程。驱动程序源码位于vendor/huawei/hdf/sample目录

添加配置

HCS(HDF Configuration Source)是HDF驱动框架的配置描述源码，内容以Key-Value为主要形式。它实现了配置代码与驱动代码解耦，便于开发者进行配置管理。

HC-GEN**(HDF Configuration Generator)**是HCS配置转换工具，可以将HDF配置文件转换为软件可读取的文件格式：

在弱性能环境中，转换为配置树源码，驱动可直接调用C代码获取配置。

在高性能环境中，转换为HCB(HDF Configuration Binary)二进制文件，驱动可使用HDF框架提供的配置解析接口获取配置。

设备配置文件和驱动配置文件的路径定义在板级配置入口文件hdf.hcs（vendor\hisilicon\hispark_taurus\config\hdf.hcs）

#include "../../../../device/hisilicon/hispark_taurus/sdk_liteos/config/i2c/i2c_config.hcs"#include "../../../../device/hisilicon/hispark_taurus/sdk_liteos/config/gpio/gpio_config.hcs"#include "../../../../device/hisilicon/hispark_taurus/sdk_liteos/config/uart/uart_config.hcs"#include "../../../../device/hisilicon/hispark_taurus/sdk_liteos/config/sdio/sdio_config.hcs"#include "../../../../device/hisilicon/hispark_taurus/sdk_liteos/config/emmc/emmc_config.hcs"#include "../../../../device/hisilicon/hispark_taurus/sdk_liteos/config/watchdog/watchdog_config.hcs"#include "../../../../device/hisilicon/hispark_taurus/sdk_liteos/config/usb/usb_config.hcs"#include "../../../../device/hisilicon/hispark_taurus/sdk_liteos/config/rtc/rtc_config.hcs"#include "../../../../device/hisilicon/hispark_taurus/sdk_liteos/config/spi/spi_config.hcs"#include "../../../../device/hisilicon/hispark_taurus/sdk_liteos/config/pwm/pwm_config.hcs"#include "../../../../device/hisilicon/hispark_taurus/sdk_liteos/config/dmac/dmac_config.hcs"#include "device_info/device_info.hcs"#include "wifi/wlan_platform.hcs"#include "wifi/wlan_chip_hi3881.hcs"#include "lcd/lcd_config.hcs"#include "input/input_config.hcs"#include "sensor/sensor_config.hcs"root {    module = "hisilicon,hi35xx_chip";}

1、在HDF框架的驱动配置文件（例如device\hisilicon\hispark_taurus\sdk_liteos\config\uart\uart_config.hcs）中添加该驱动的配置信息，如下所示：

root {    platform {        uart_sample {            num = 5;            base = 0x120a0000;  // UART base register address            irqNum = 38;            baudrate = 115200;            uartClk = 24000000; // 24 M            wlen = 0x60;        // 8 bit width            parity = 0;            stopBit = 0;            match_attr = "sample_uart_5";        }    }}

2、在HDF框架的设备配置文件（例如vendor\hisilicon\hispark_taurus\config\device_info\device_info.hcs）中添加该驱动的设备节点信息，如下所示：

root {    device_info {        platform :: host {            hostName = "platform_host";            priority = 50;            device_uart :: device {                device5 :: deviceNode {                    policy = 2;                    priority = 10;                    permission = 0660;                    moduleName = "UART_SAMPLE";                      serviceName = "HDF_PLATFORM_UART_5";                    deviceMatchAttr = "sample_uart_5";                }            }        }    }}

注册uart驱动入口

基于HDF框架注册UART驱动的入口HdfDriverEntry，代码如下：

// 绑定UART驱动接口到HDF框架static int32_t SampleUartDriverBind(struct HdfDeviceObject *device){    struct UartHost *uartHost = NULL;    if (device == NULL) {        return HDF_ERR_INVALID_OBJECT;    }    HDF_LOGI("Enter %s:", __func__);    uartHost = UartHostCreate(device);    if (uartHost == NULL) {        HDF_LOGE("%s: UartHostCreate failed", __func__);        return HDF_FAILURE;    }    uartHost->service.Dispatch = SampleDispatch;    return HDF_SUCCESS;} // 从UART驱动的HCS中获取配置信息static uint32_t GetUartDeviceResource(    struct UartDevice *device, const struct DeviceResourceNode *resourceNode){    struct UartResource *resource = &device->resource;    struct DeviceResourceIface *dri = NULL;    dri = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);    if (dri == NULL || dri->GetUint32 == NULL) {        HDF_LOGE("DeviceResourceIface is invalid");        return HDF_FAILURE;    }    if (dri->GetUint32(resourceNode, "num", &resource->num, 0) != HDF_SUCCESS) {        HDF_LOGE("uart config read num fail");        return HDF_FAILURE;    }    if (dri->GetUint32(resourceNode, "base", &resource->base, 0) != HDF_SUCCESS) {        HDF_LOGE("uart config read base fail");        return HDF_FAILURE;    }    resource->physBase = (unsigned long)OsalIoRemap(resource->base, 0x48);    if (resource->physBase == 0) {        HDF_LOGE("uart config fail to remap physBase");        return HDF_FAILURE;    }    if (dri->GetUint32(resourceNode, "irqNum", &resource->irqNum, 0) != HDF_SUCCESS) {        HDF_LOGE("uart config read irqNum fail");        return HDF_FAILURE;    }    if (dri->GetUint32(resourceNode, "baudrate", &resource->baudrate, 0) != HDF_SUCCESS) {        HDF_LOGE("uart config read baudrate fail");        return HDF_FAILURE;    }    if (dri->GetUint32(resourceNode, "wlen", &resource->wlen, 0) != HDF_SUCCESS) {        HDF_LOGE("uart config read wlen fail");        return HDF_FAILURE;    }    if (dri->GetUint32(resourceNode, "parity", &resource->parity, 0) != HDF_SUCCESS) {        HDF_LOGE("uart config read parity fail");        return HDF_FAILURE;    }    if (dri->GetUint32(resourceNode, "stopBit", &resource->stopBit, 0) != HDF_SUCCESS) {        HDF_LOGE("uart config read stopBit fail");        return HDF_FAILURE;    }    if (dri->GetUint32(resourceNode, "uartClk", &resource->uartClk, 0) != HDF_SUCCESS) {        HDF_LOGE("uart config read uartClk fail");        return HDF_FAILURE;    }    return HDF_SUCCESS;} // 将UART驱动的配置和接口附加到HDF驱动框架static int32_t AttachUartDevice(struct UartHost *host, struct HdfDeviceObject *device){    int32_t ret;    struct UartDevice *uartDevice = NULL;    if (device->property == NULL) {        HDF_LOGE("%s: property is NULL", __func__);        return HDF_FAILURE;    }    uartDevice = (struct UartDevice *)OsalMemCalloc(sizeof(struct UartDevice));    if (uartDevice == NULL) {        HDF_LOGE("%s: OsalMemCalloc uartDevice error", __func__);        return HDF_ERR_MALLOC_FAIL;    }    ret = GetUartDeviceResource(uartDevice, device->property);    if (ret != HDF_SUCCESS) {        (void)OsalMemFree(uartDevice);        return HDF_FAILURE;    }    host->num = uartDevice->resource.num;    host->priv = uartDevice;    AddUartDevice(host);    return InitUartDevice(uartDevice);} // 初始化UART驱动static int32_t SampleUartDriverInit(struct HdfDeviceObject *device){    int32_t ret;    struct UartHost *host = NULL;    if (device == NULL) {        HDF_LOGE("%s: device is NULL", __func__);        return HDF_ERR_INVALID_OBJECT;    }    HDF_LOGI("Enter %s:", __func__);    host = UartHostFromDevice(device);    if (host == NULL) {        HDF_LOGE("%s: host is NULL", __func__);        return HDF_FAILURE;    }    ret = AttachUartDevice(host, device);    if (ret != HDF_SUCCESS) {        HDF_LOGE("%s: attach error", __func__);        return HDF_FAILURE;    }    host->method = &g_sampleUartHostMethod;    return ret;} static void DeinitUartDevice(struct UartDevice *device){    struct UartRegisterMap *regMap = (struct UartRegisterMap *)device->resource.physBase;    /* wait for uart enter idle. */    while (UartPl011IsBusy(regMap));    UartPl011ResetRegisters(regMap);    uart_clk_cfg(0, false);    OsalIoUnmap((void *)device->resource.physBase);    device->state = UART_DEVICE_UNINITIALIZED;} // 解绑并释放UART驱动static void DetachUartDevice(struct UartHost *host){    struct UartDevice *uartDevice = NULL;    if (host->priv == NULL) {        HDF_LOGE("%s: invalid parameter", __func__);        return;    }    uartDevice = host->priv;    DeinitUartDevice(uartDevice);    (void)OsalMemFree(uartDevice);    host->priv = NULL;} // 释放UART驱动static void SampleUartDriverRelease(struct HdfDeviceObject *device){    struct UartHost *host = NULL;    HDF_LOGI("Enter %s:", __func__);    if (device == NULL) {        HDF_LOGE("%s: device is NULL", __func__);        return;    }    host = UartHostFromDevice(device);    if (host == NULL) {        HDF_LOGE("%s: host is NULL", __func__);        return;    }    if (host->priv != NULL) {        DetachUartDevice(host);    }    UartHostDestroy(host);} struct HdfDriverEntry g_sampleUartDriverEntry = {    .moduleVersion = 1,    .moduleName = "UART_SAMPLE",    .Bind = SampleUartDriverBind,    .Init = SampleUartDriverInit,    .Release = SampleUartDriverRelease,}; HDF_INIT(g_sampleUartDriverEntry);

注册uart驱动接口

HDF框架提供了UART驱动接口的模板方法UartHostMethod，实现UART驱动接口的代码如下：

static int32_t SampleUartHostInit(struct UartHost *host){    HDF_LOGI("%s: Enter", __func__);    if (host == NULL) {        HDF_LOGE("%s: invalid parameter", __func__);        return HDF_ERR_INVALID_PARAM;    }    return HDF_SUCCESS;}static int32_t SampleUartHostDeinit(struct UartHost *host){    HDF_LOGI("%s: Enter", __func__);    if (host == NULL) {        HDF_LOGE("%s: invalid parameter", __func__);        return HDF_ERR_INVALID_PARAM;    }    return HDF_SUCCESS;}// 向UART中写入数据static int32_t SampleUartHostWrite(struct UartHost *host, uint8_t *data, uint32_t size){    HDF_LOGI("%s: Enter", __func__);    uint32_t idx;    struct UartRegisterMap *regMap = NULL;    struct UartDevice *device = NULL;    if (host == NULL || data == NULL || size == 0) {        HDF_LOGE("%s: invalid parameter", __func__);        return HDF_ERR_INVALID_PARAM;    }    device = (struct UartDevice *)host->priv;    if (device == NULL) {        HDF_LOGE("%s: device is NULL", __func__);        return HDF_ERR_INVALID_PARAM;    }    regMap = (struct UartRegisterMap *)device->resource.physBase;    for (idx = 0; idx < size; idx++) {        UartPl011Write(regMap, data[idx]);    }    return HDF_SUCCESS;} // 设置UART的波特率static int32_t SampleUartHostSetBaud(struct UartHost *host, uint32_t baudRate){    HDF_LOGI("%s: Enter", __func__);    struct UartDevice *device = NULL;    struct UartRegisterMap *regMap = NULL;    UartPl011Error err;    if (host == NULL) {        HDF_LOGE("%s: invalid parameter", __func__);        return HDF_ERR_INVALID_PARAM;    }    device = (struct UartDevice *)host->priv;    if (device == NULL) {        HDF_LOGE("%s: device is NULL", __func__);        return HDF_ERR_INVALID_PARAM;    }    regMap = (struct UartRegisterMap *)device->resource.physBase;    if (device->state != UART_DEVICE_INITIALIZED) {        return UART_PL011_ERR_NOT_INIT;    }    if (baudRate == 0) {        return UART_PL011_ERR_INVALID_BAUD;    }    err = UartPl011SetBaudrate(regMap, device->uartClk, baudRate);    if (err == UART_PL011_ERR_NONE) {        device->baudrate = baudRate;    }    return err;} // 获取UART的波特率static int32_t SampleUartHostGetBaud(struct UartHost *host, uint32_t *baudRate){    HDF_LOGI("%s: Enter", __func__);    struct UartDevice *device = NULL;    if (host == NULL) {        HDF_LOGE("%s: invalid parameter", __func__);        return HDF_ERR_INVALID_PARAM;    }    device = (struct UartDevice *)host->priv;    if (device == NULL) {        HDF_LOGE("%s: device is NULL", __func__);        return HDF_ERR_INVALID_PARAM;    }    *baudRate = device->baudrate;    return HDF_SUCCESS;} // 在HdfUartSampleInit方法中绑定struct UartHostMethod g_sampleUartHostMethod = {    .Init = SampleUartHostInit,    .Deinit = SampleUartHostDeinit,    .Read = NULL,    .Write = SampleUartHostWrite,    .SetBaud = SampleUartHostSetBaud,    .GetBaud = SampleUartHostGetBaud,    .SetAttribute = NULL,    .GetAttribute = NULL,    .SetTransMode = NULL,};

uart驱动Makefile如下:

include $(LITEOSTOPDIR)/config.mkinclude $(LITEOSTOPDIR)/../../drivers/adapter/khdf/liteos/lite.mkMODULE_NAME := hdf_uart_sampleLOCAL_CFLAGS += $(HDF_INCLUDE)LOCAL_SRCS += src/uart_sample.c \              src/uart_pl011_sample.c \              src/buf_fifo.c \              src/uart_dev_sample.c \              src/uart_dispatch_sample.c \LOCAL_INCLUDE := ./includeLOCAL_CFLAGS += -fstack-protector-stronginclude $(HDF_DRIVER)

在device/hisilicon/drivers/lite.mk编译脚本中增加示例UART驱动模块，代码如下：

LITEOS_BASELIB += -lhdf_uart_sampleLIB_SUBDIRS    += $(LITEOS_SOURCE_ROOT)/vendor/huawei/hdf/sample/platform/uart

用户程序和驱动交互代码

UART驱动成功初始化后，会创建/dev/uartdev-5设备节点，通过设备节点与UART驱动交互的代码如下：

#include <stdlib.h>#include <unistd.h>#include <fcntl.h>#include "hdf_log.h"#define HDF_LOG_TAG "hello_uart"#define INFO_SIZE 16int main(void){    int ret;    int fd;    const char info[INFO_SIZE] = {" HELLO UART! "};    fd = open("/dev/uartdev-5", O_RDWR);    if (fd < 0) {        HDF_LOGE("hello_uart uartdev-5 open failed %d", fd);        return -1;    }    ret = write(fd, info, INFO_SIZE);    if (ret != 0) {        HDF_LOGE("hello_uart write uartdev-5 ret is %d", ret);    }    ret = close(fd);    if (ret != 0) {        HDF_LOGE("hello_uart uartdev-5 close failed %d", fd);        return -1;    }    return ret;}

将应用程序编译进hello_uart_sample组件，应用的编译文件：（1）vendor/huawei/hdf/sample/platform/uart/BUILD.gn

import("//build/lite/config/component/lite_component.gni")lite_component("hello_uart_sample") {    features = [        "dev:hello_uart",        "dispatch:hello_uart_dispatch",    ]}

（2）vendor/huawei/hdf/sample/platform/uart/dev/BUILD.gn:

HDF_FRAMEWORKS = "//drivers/framework"executable("hello_uart") {  sources = [ "hello_uart_dev.c" ]  include_dirs = [    "$HDF_FRAMEWORKS/ability/sbuf/include",    "$HDF_FRAMEWORKS/core/shared/include",    "$HDF_FRAMEWORKS/core/host/include",    "$HDF_FRAMEWORKS/core/master/include",    "$HDF_FRAMEWORKS/include/core",    "$HDF_FRAMEWORKS/include/utils",    "$HDF_FRAMEWORKS/utils/include",    "$HDF_FRAMEWORKS/include/osal",    "//drivers/adapter/uhdf/posix/include",    "//third_party/bounds_checking_function/include",    "//base/hiviewdfx/hilog_lite/interfaces/native/innerkits",  ]  deps = [    "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared",    "//drivers/adapter/uhdf/manager:hdf_core",    "//drivers/adapter/uhdf/posix:hdf_posix_osal",  ]  public_deps = [ "//third_party/bounds_checking_function:libsec_shared" ]  defines = [ "__USER__" ]  cflags = [    "-Wall",    "-Wextra",    "-Wno-format",    "-Wno-format-extra-args",  ]}

在build/lite/components/drivers.json驱动配置中hdf_hi3516dv300_liteos_a组件下的targets中增加hello_uart_sample组件，代码如下：

{  "components": [    {      "component": "hdf_hi3516dv300_liteos_a",      "description": "",      "optional": "false",      "dirs": ["vendor/huawei/hdf/sample/platform/uart"],      "targets": [        "//vendor/huawei/hdf/sample/platform/uart:hello_uart_sample"       ],      "rom": "",      "ram": "",      "output": [],      "adapted_board": [],      "adapted_kernel": [ "liteos_a" ],      "features": [],      "deps": {        "third_party": [          "bounds_checking_function"        ],        "components": [          "hilog"        ]      }    }  ]}

修改单板配置文件（vendor/hisilicon/hispark_taurus/config.json），新增hdf_hi3516dv300_liteos_a组件的条目，如下所示代码片段为driver子系统配置

 {        "subsystem": "drivers",        "components": [          { "component": "adapter_uhdf", "features":[] },          { "component": "peripheral_display", "features":[] },          { "component": "hdf_hi3516dv300_liteos_a", "features":[] },          { "component": "peripheral_input", "features":[] },          { "component": "peripheral_sensor", "features":[] },          { "component": "peripheral_wlan", "features":[] }        ]      },

编译

如果Linux编译环境通过Docker方式安装，具体编译过程请参见Docker方式获取编译环境的编译操作。如果Linux编译环境通过软件包方式安装，请进入源码根目录，执行如下命令进行编译：

hb set(设置编译路径).（选择当前路径）选择ipcamera_hispark_taurus并回车hb build -f（执行编译）

运行

烧录成功之后，可执行文件在bin目录下（/bin/hello_uart），运行：