开发Hi3516第一个驱动程序示例

本节指导开发者在单板上运行第一个驱动程序，其中包括驱动程序介绍、编译、烧写、运行等步骤。

获取源码

参考“开发Hi3516第一个应用程序示例”获取源码。

驱动程序介绍

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

  1. 添加配置。

    在HDF框架的驱动配置文件（例如vendor/hisi/hi35xx/hi3516dv300/config/uart/uart_config.hcs）中添加该驱动的配置信息，如下所示：

    1. root {
    2.     platform {
    3.         uart_sample {
    4.             num = 5;            // UART设备编号
    5.             base = 0x120a0000;  // UART 寄存器基地址
    6.             irqNum = 38;
    7.             baudrate = 115200;
    8.             uartClk = 24000000;
    9.             wlen = 0x60;
    10.             parity = 0;
    11.             stopBit = 0;
    12.             match_attr = "sample_uart_5";
    13.         }
    14.     }
    15. }

    在HDF框架的设备配置文件（例如vendor/hisi/hi35xx/hi3516dv300/config/device_info/device_info.hcs）中添加该驱动的设备节点信息，如下所示：

    1. root {
    2.     device_info {
    3.         platform :: host {
    4.             hostName = "platform_host";
    5.             priority = 50;
    6.             device_uart :: device {
    7.                 device5 :: deviceNode {
    8.                     policy = 2;
    9.                     priority = 10;
    10.                     permission = 0660;
    11.                     moduleName = "UART_SAMPLE";
    12.                     serviceName = "HDF_PLATFORM_UART_5";
    13.                     deviceMatchAttr = "sample_uart_5";
    14.                 }
    15.             }
    16.         }
    17.     }
    18. }

    开发Hi3516第一个驱动程序示例 - 图1 说明： 配置文件与UART驱动示例的源码在同一个路径，需要手动添加到Hi3516DV300单板路径下。

  2. 注册UART驱动入口。

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

    1. // 绑定UART驱动接口到HDF框架
    2. static int32_t HdfUartSampleBind(struct HdfDeviceObject *device)
    3. {
    4.     if (device == NULL) {
    5.         return HDF_ERR_INVALID_OBJECT;
    6.     }
    7.     HDF_LOGI("Enter %s:", __func__);
    8.     return (UartHostCreate(device) == NULL) ? HDF_FAILURE : HDF_SUCCESS;
    9. }
    11. // 从UART驱动的HCS中获取配置信息
    12. static uint32_t UartDeviceGetResource(
    13.     struct UartDevice *device, const struct DeviceResourceNode *resourceNode)
    14. {
    15.     struct UartResource *resource = &device->resource;
    16.     struct DeviceResourceIface *dri = NULL;
    17.     dri = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
    18.     if (dri == NULL || dri->GetUint32 == NULL) {
    19.         HDF_LOGE("DeviceResourceIface is invalid");
    20.         return HDF_FAILURE;
    21.     }
    23.     if (dri->GetUint32(resourceNode, "num", &resource->num, 0) != HDF_SUCCESS) {
    24.         HDF_LOGE("uart config read num fail");
    25.         return HDF_FAILURE;
    26.     }
    27.     if (dri->GetUint32(resourceNode, "base", &resource->base, 0) != HDF_SUCCESS) {
    28.         HDF_LOGE("uart config read base fail");
    29.         return HDF_FAILURE;
    30.     }
    31.     resource->physBase = (unsigned long) OsalIoRemap(resource->base, 0x48);
    32.     if (resource->physBase == 0) {
    33.         HDF_LOGE("uart config fail to remap physBase");
    34.         return HDF_FAILURE;
    35.     }
    36.     if (dri->GetUint32(resourceNode, "irqNum", &resource->irqNum, 0) != HDF_SUCCESS) {
    37.         HDF_LOGE("uart config read irqNum fail");
    38.         return HDF_FAILURE;
    39.     }
    40.     if (dri->GetUint32(resourceNode, "baudrate", &resource->baudrate, 0) != HDF_SUCCESS) {
    41.         HDF_LOGE("uart config read baudrate fail");
    42.         return HDF_FAILURE;
    43.     }
    44.     if (dri->GetUint32(resourceNode, "wlen", &resource->wlen, 0) != HDF_SUCCESS) {
    45.         HDF_LOGE("uart config read wlen fail");
    46.         return HDF_FAILURE;
    47.     }
    48.     if (dri->GetUint32(resourceNode, "parity", &resource->parity, 0) != HDF_SUCCESS) {
    49.         HDF_LOGE("uart config read parity fail");
    50.         return HDF_FAILURE;
    51.     }
    52.     if (dri->GetUint32(resourceNode, "stopBit", &resource->stopBit, 0) != HDF_SUCCESS) {
    53.         HDF_LOGE("uart config read stopBit fail");
    54.         return HDF_FAILURE;
    55.     }
    56.     if (dri->GetUint32(resourceNode, "uartClk", &resource->uartClk, 0) != HDF_SUCCESS) {
    57.         HDF_LOGE("uart config read uartClk fail");
    58.         return HDF_FAILURE;
    59.     }
    60.     return HDF_SUCCESS;
    61. }
    63. // 将UART驱动的配置和接口附加到HDF驱动框架
    64. static int32_t SampleAttach(struct UartHost *host, struct HdfDeviceObject *device)
    65. {
    66.     int32_t ret;
    67.     struct UartDevice *uartDevice = NULL;
    68.     if (device->property == NULL) {
    69.         HDF_LOGE("%s: property is NULL", __func__);
    70.         return HDF_FAILURE;
    71.     }
    72.     uartDevice = (struct UartDevice *) OsalMemCalloc(sizeof(struct UartDevice));
    73.     if (uartDevice == NULL) {
    74.         HDF_LOGE("%s: OsalMemCalloc uartDevice error", __func__);
    75.         return HDF_ERR_MALLOC_FAIL;
    76.     }
    77.     ret = UartDeviceGetResource(uartDevice, device->property);
    78.     if (ret != HDF_SUCCESS) {
    79.         (void) OsalMemFree(uartDevice);
    80.         return HDF_FAILURE;
    81.     }
    82.     host->num = uartDevice->resource.num;
    83.     host->priv = uartDevice;
    84.     UartSampleAddDev(host); // 添加用户态UART设备节点，具体实现见源码uart_dev_sample
    85.     return UartDeviceInit(uartDevice); // 初始化UART PL011，具体实现见源码uart_pl011_sample
    86. }
    88. // 初始化UART驱动
    89. static int32_t HdfUartSampleInit(struct HdfDeviceObject *device)
    90. {
    91.     int32_t ret;
    92.     struct UartHost *host = NULL;
    94.     if (device == NULL) {
    95.         HDF_LOGE("%s: device is NULL", __func__);
    96.         return HDF_ERR_INVALID_OBJECT;
    97.     }
    98.     HDF_LOGI("Enter %s:", __func__);
    99.     host = UartHostFromDevice(device);
    100.     if (host == NULL) {
    101.         HDF_LOGE("%s: host is NULL", __func__);
    102.         return HDF_FAILURE;
    103.     }
    104.     ret = SampleAttach(host, device);
    105.     if (ret != HDF_SUCCESS) {
    106.         HDF_LOGE("%s: attach error", __func__);
    107.         return HDF_FAILURE;
    108.     }
    109.     host->method = &g_uartSampleHostMethod;
    110.     return ret;
    111. }
    113. static void UartDeviceDeinit(struct UartDevice *device)
    114. {
    115.     struct UartRegisterMap *regMap = (struct UartRegisterMap *) device->resource.physBase;
    116.     /* wait for uart enter idle. */
    117.     while (UartPl011IsBusy(regMap));
    118.     UartPl011ResetRegisters(regMap);
    119.     uart_clk_cfg(0, false);
    120.     OsalIoUnmap((void *) device->resource.physBase);
    121.     device->state = UART_DEVICE_UNINITIALIZED;
    122. }
    124. // 解绑并释放UART驱动
    125. static void SampleDetach(struct UartHost *host)
    126. {
    127.     struct UartDevice *uartDevice = NULL;
    129.     if (host->priv == NULL) {
    130.         HDF_LOGE("%s: invalid parameter", __func__);
    131.         return;
    132.     }
    133.     uartDevice = host->priv;
    134.     UartDeviceDeinit(uartDevice);
    135.     (void) OsalMemFree(uartDevice);
    136.     host->priv = NULL;
    137. }
    139. // 释放UART驱动
    140. static void HdfUartSampleRelease(struct HdfDeviceObject *device)
    141. {
    142.     struct UartHost *host = NULL;
    143.     HDF_LOGI("Enter %s:", __func__);
    145.     if (device == NULL) {
    146.         HDF_LOGE("%s: device is null", __func__);
    147.         return;
    148.     }
    149.     host = UartHostFromDevice(device);
    150.     if (host == NULL) {
    151.         HDF_LOGE("%s: host is null", __func__);
    152.         return;
    153.     }
    154.     if (host->priv != NULL) {
    155.         SampleDetach(host);
    156.     }
    157.     UartHostDestroy(host);
    158. }
    160. struct HdfDriverEntry g_hdfUartSample = {
    161.     .moduleVersion = 1,
    162.     .moduleName = "UART_SAMPLE",
    163.     .Bind = HdfUartSampleBind,
    164.     .Init = HdfUartSampleInit,
    165.     .Release = HdfUartSampleRelease,
    166. };
    168. HDF_INIT(g_hdfUartSample);

  3. 注册UART驱动接口。

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

    1. static int32_t SampleInit(struct UartHost *host)
    2. {
    3.     HDF_LOGI("%s: Enter", __func__);
    4.     if (host == NULL) {
    5.         HDF_LOGE("%s: invalid parameter", __func__);
    6.         return HDF_ERR_INVALID_PARAM;
    7.     }
    8.     return HDF_SUCCESS;
    9. }
    11. static int32_t SampleDeinit(struct UartHost *host)
    12. {
    13.     HDF_LOGI("%s: Enter", __func__);
    14.     if (host == NULL) {
    15.         HDF_LOGE("%s: invalid parameter", __func__);
    16.         return HDF_ERR_INVALID_PARAM;
    17.     }
    18.     return HDF_SUCCESS;
    19. }
    21. // 向UART中写入数据
    22. static int32_t SampleWrite(struct UartHost *host, uint8_t *data, uint32_t size)
    23. {
    24.     HDF_LOGI("%s: Enter", __func__);
    25.     uint32_t idx;
    26.     struct UartRegisterMap *regMap = NULL;
    27.     struct UartDevice *device = NULL;
    29.     if (host == NULL || data == NULL || size == 0) {
    30.         HDF_LOGE("%s: invalid parameter", __func__);
    31.         return HDF_ERR_INVALID_PARAM;
    32.     }
    33.     device = (struct UartDevice *) host->priv;
    34.     if (device == NULL) {
    35.         HDF_LOGE("%s: device is NULL", __func__);
    36.         return HDF_ERR_INVALID_PARAM;
    37.     }
    38.     regMap = (struct UartRegisterMap *) device->resource.physBase;
    39.     for (idx = 0; idx < size; idx++) {
    40.         while (UartPl011IsBusy(regMap));
    41.         UartPl011Write(regMap, data[idx]);
    42.     }
    43.     return HDF_SUCCESS;
    44. }
    46. // 设置UART的波特率
    47. static int32_t SampleSetBaud(struct UartHost *host, uint32_t baudRate)
    48. {
    49.     HDF_LOGI("%s: Enter", __func__);
    50.     struct UartDevice *device = NULL;
    51.     struct UartRegisterMap *regMap = NULL;
    52.     UartPl011Error err;
    54.     if (host == NULL) {
    55.         HDF_LOGE("%s: invalid parameter", __func__);
    56.         return HDF_ERR_INVALID_PARAM;
    57.     }
    58.     device = (struct UartDevice *) host->priv;
    59.     if (device == NULL) {
    60.         HDF_LOGE("%s: device is NULL", __func__);
    61.         return HDF_ERR_INVALID_PARAM;
    62.     }
    63.     regMap = (struct UartRegisterMap *) device->resource.physBase;
    64.     if (device->state != UART_DEVICE_INITIALIZED) {
    65.         return UART_PL011_ERR_NOT_INIT;
    66.     }
    67.     if (baudRate == 0) {
    68.         return UART_PL011_ERR_INVALID_BAUD;
    69.     }
    70.     err = UartPl011SetBaudrate(regMap, device->uartClk, baudRate);
    71.     if (err == UART_PL011_ERR_NONE) {
    72.         device->baudrate = baudRate;
    73.     }
    74.     return err;
    75. }
    77. // 获取UART的波特率
    78. static int32_t SampleGetBaud(struct UartHost *host, uint32_t *baudRate)
    79. {
    80.     HDF_LOGI("%s: Enter", __func__);
    81.     struct UartDevice *device = NULL;
    83.     if (host == NULL) {
    84.         HDF_LOGE("%s: invalid parameter", __func__);
    85.         return HDF_ERR_INVALID_PARAM;
    86.     }
    87.     device = (struct UartDevice *) host->priv;
    88.     if (device == NULL) {
    89.         HDF_LOGE("%s: device is NULL", __func__);
    90.         return HDF_ERR_INVALID_PARAM;
    91.     }
    92.     *baudRate = device->baudrate;
    93.     return HDF_SUCCESS;
    94. }
    96. // 在HdfUartSampleInit方法中绑定
    97. struct UartHostMethod g_uartSampleHostMethod = {
    98.     .Init = SampleInit,
    99.     .Deinit = SampleDeinit,
    100.     .Read = NULL,
    101.     .Write = SampleWrite,
    102.     .SetBaud = SampleSetBaud,
    103.     .GetBaud = SampleGetBaud,
    104.     .SetAttribute = NULL,
    105.     .GetAttribute = NULL,
    106.     .SetTransMode = NULL,
    107. };

    在vendor/huawei/hdf/hdf_vendor.mk编译脚本中增加示例UART驱动模块，代码如下：

    1. LITEOS_BASELIB += -lhdf_uart_sample
    2. LIB_SUBDIRS    += $(VENDOR_HDF_DRIVERS_ROOT)/sample/platform/uart

  4. 用户程序和驱动交互代码。

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

    1. #include <stdlib.h>
    2. #include <unistd.h>
    3. #include <fcntl.h>
    4. #include "hdf_log.h"
    6. #define HDF_LOG_TAG "hello_uart"
    7. #define INFO_SIZE 16
    9. int main(void)
    10. {
    11.     int ret;
    12.     int fd;
    13.     const char info[INFO_SIZE] = {" HELLO UART! "};
    15.     fd = open("/dev/uartdev-5", O_RDWR);
    16.     if (fd < 0) {
    17.         HDF_LOGE("hello_uart uartdev-5 open failed %d", fd);
    18.         return -1;
    19.     }
    20.     ret = write(fd, info, INFO_SIZE);
    21.     if (ret != 0) {
    22.         HDF_LOGE("hello_uart write uartdev-5 ret is %d", ret);
    23.     }
    24.     ret = close(fd);
    25.     if (ret != 0) {
    26.         HDF_LOGE("hello_uart uartdev-5 close failed %d", fd);
    27.         return -1;
    28.     }
    29.     return ret;
    30. }

    在build/lite/product/ipcamera_hi3516dv300.json产品配置的hdf子系统下增加hello_uart_sample组件，代码如下：

    1. {
    2.   "subsystem": [
    3.     {
    4.       "name": "hdf",
    5.       "component": [
    6.         { "name": "hdf_sample", "dir": "//vendor/huawei/hdf/sample/platform/uart:hello_uart_sample", "features":[] }
    7.       ]
    8.     }
    9.   ]
    10. }

    开发Hi3516第一个驱动程序示例 - 图2 说明： 如上代码均为示例代码，完整代码可以在vendor/huawei/hdf/sample查看。 示例代码默认不参与编译，需要手动添加到编译脚本中。

编译和烧写

参考示例1进行编译和烧写：编译、烧写。

镜像运行

  1. 连接串口。

    图 1 连接串口图 

  1. ![](/projects/openharmony-1.0-zh-cn/quick-start/figures/chuankou1.png)
  3. 1.  单击**Serial port**打开串口。
  4. 2.  输入"com11"串口编号并连续输入回车直到串口显示"hisillicon"。
  5. 3.  单板初次启动或修改启动参数，请进入步骤2，否则进入步骤3。

  1. （单板初次启动必选）修改U-boot的bootcmd及bootargs内容：该步骤为固化操作，若不修改参数只需执行一次。每次复位单板均会自动进入系统。

    开发Hi3516第一个驱动程序示例 - 图3 须知： U-boot引导程序默认会有2秒的等待时间，用户可使用回车打断等待并显示”hisillicon”，通过reset命令可再次启动系统。

    表 1 U-boot启动参数

    执行命令

    setenv bootcmd “sf probe 0;mmc read 0x0 0x80000000 0x800 0x4800; go 0x80000000”;

    setenv bootargs “console=ttyAMA0,115200n8 root=emmc fstype=vfat rootaddr=10M rootsize=15M rw”;

    saveenv

    reset

    命令解释

    setenv bootcmd “mmc read 0x0 0x80000000 0x800 0x4800;go 0x80000000”;

    表示选择FLASH器件0，读取FLASH起始地址为0x800（单位为512B，即1MB），大小为0x4800（单位为512B，即9MB）的内容到0x80000000的内存地址。

    setenv bootargs “console=ttyAMA0,115200n8 root=emmc fstype=vfat rootaddr=10M rootsize=15M rw”;

    表示设置启动参数，输出模式为串口输出，波特率为115200，数据位8，rootfs挂载于emmc器件，文件系统类型为vfat，

    “rootaddr=10M rootsize=15M rw”处对应填入rootfs.img的烧写起始位置与长度，此处与IDE中新增rootfs.img文件时所填大小必须相同。

    saveenv;表示保存当前配置。

    reset;表示复位单板

    [可选]“go 0x80000000”默认配置已将指令固化在启动参数中，单板复位后可自动启动。若想切换为手动启动，可在U-boot启动倒数阶段使用”回车”打断自动启动。

  2. 输入“reset”指令并回车，重启单板，启动成功如下图，输入回车串口显示OHOS字样。

    图 2 系统启动图 

  1. ![](/projects/openharmony-1.0-zh-cn/quick-start/figures/qi1.png)

  1. 根目录下，在命令行输入指令“./bin/hello_uart”执行写入的demo程序，显示成功结果如下图所示。

    1. OHOS # ./bin/hello_uart
    2. OHOS #  HELLO UART!

下一步学习

恭喜，您已完成Hi3516 快速上手！建议您下一步进入带屏摄像头产品开发的学习 。