返回发烧友论坛
发 帖  

[文章]【HarmonyOS HiSpark AI Camera试用连载 】第七次眷恋-鸿蒙OS驱动服务的订阅机制

瑟寒凌风
2021-01-14 23:08:21
阅读量0
驱动开发
0
1
谁？
我！
是你？
是我！
你终于来了！
我终于来了！
你终究是来了？
我终究是来了！
你来干什么!
我来写服务订阅！

鸿蒙lite-a的驱动开发，我们其实就是为了实现HdfDriverEntry结构体，驱动框架完成大部分驱动加载的动作，用户只需注册自己所需的接口和配置，然后驱动框架就会根据解析，完成驱动加载和初始化动作。
开发者基于HDF驱动框架开发的驱动主要包含三大部分：
1、驱动程序部分 - 完成驱动的功能逻辑
2、驱动配置信息 - 指示驱动的加载信息内容
3、驱动资源配置 - 配置驱动的硬件配置信息。
驱动程序主要是完成驱动功能的开发部分：
对于开发者首先看到的是驱动入口部分，驱动入口部分通过DriverEntry对齐进行描述。
其中主要包含bind, init 和release三个接口。
本文主要说的是驱动订阅服务。

要实现订阅，需要在device_info.hcs文件中修改policy字段，该字段policy是驱动服务发布的策略
  1. typedef enum {
  2. /* 驱动不提供服务 */
  3. SERVICE_POLICY_NONE = 0,
  4. /* 驱动对内核态发布服务 */
  5. SERVICE_POLICY_PUBLIC = 1,
  6. /* 驱动对内核态和用户态都发布服务 */
  7. SERVICE_POLICY_CAPACITY = 2,
  8. /* 驱动服务不对外发布服务，但可以被订阅 */
  9. SERVICE_POLICY_FRIENDLY = 3,
  10. /* 驱动私有服务不对外发布服务，也不能被订阅 */
  11. SERVICE_POLICY_PRIVATE = 4,
  12. /* 错误的服务策略 */
  13. SERVICE_POLICY_INVALID
  14. } ServicePolicy;
复制代码

当对驱动（同一个host）加载的时机不感知时，可以通过HDF框架提供的订阅机制来订阅该驱动，当该驱动加载完成时，HDF框架会将被订阅的驱动服务发布给订阅者，我们先实现一个自定义结构体
  1. struct ILedService {
  2.     struct IDeviceIoService ioService;   // 服务结构的首个成员必须是IDeviceIoService类型的成员
  3.     int32_t (*LedServiceA)(void);               // 驱动的第一个服务接口
  4.     int32_t (*LedServiceB)(uint32_t inputCode); // 驱动的第二个服务接口，有多个可以依次往下累加
  5. };
复制代码

在驱动的绑定程序中，实现服务函数的初始化
  1. static struct ILedService ledDriver = {
  2.         .ioService.object = {0},
  3.         .ioService.Dispatch = led_dispatch,
  4.         .LedServiceA = service_funA,
  5.         .LedServiceB = service_funB,
  6.     };
  7. object->service = &ledDriver.ioService;
复制代码

然后可以来实现service_funA和service_funB函数，我的函数如下
  1. int32_t service_funA()
  2. {
  3.     HDF_LOGE("%s: serviceA ok", __func__);
  4.     int i = 5;
  5.     while(i--)
  6.     {
  7.         GpioWrite(gpio, 1);
  8.         OsalSleep(1);
  9.         GpioWrite(gpio, 0);
  10.         OsalSleep(1);
  11.         
  12.     }
  13.     return 0;
  14. }

  16. int32_t service_funB(uint32_t inputCode)
  17. {
  18.     HDF_LOGE("%s: serviceB ok", __func__);
  19.     HDF_LOGE("inputCode: %d",inputCode);
  20.     return 0;
  21. }
复制代码

通过回调函数可以调用这两个服务函数，我的回调函数如下
  1. int32_t TestDriverSubCallBack(struct HdfDeviceObject *deviceObject, const struct HdfObject *service)
  2. {
  3.     (void)*deviceObject;
  4.     const struct ILedService *sampleService =
  5.         (const struct ILedService *)service;
  6.     if (sampleService == NULL) {
  7.         return -1;
  8.     }
  9.     sampleService->LedServiceA();
  10.     sampleService->LedServiceB(5);
  11.     return 0;
  12. }
复制代码

这个函数就是简单的两个服务函数的调用。主要函数就是这样。
图1.jpg

Test.c如下


  3. /*
  4. * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
  5. * Description: ft6236 touch driver implement.
  6. * Author: zhaihaipeng
  7. * Create: 2020-07-25
  8. */

  10. #include <stdlib.h>
  11. #include <asm/io.h>
  12. #include <fs/fs.h>
  13. #include <fs_poll_pri.h>
  14. #include <los_queue.h>
  15. #include <poll.h>
  16. #include <user_copy.h>
  17. #include <securec.h>
  18. #include "gpio_if.h"
  19. #include "hdf_device_desc.h"
  20. #include "hdf_log.h"
  21. #include "osal_irq.h"
  22. #include "osal_mem.h"
  23. #include "osal_time.h"
  24. #include "led_dev.h"

  26. #define LED_WRITE_READ 123

  28. uint16_t gpio = 19; /*待测试的GPIO管脚号 */
  29. #define HDF_LOG_TAG led_driver   // 打印日志所包含的标签，如果不定义则用默认定义的HDF_TAG标签
  30. struct ILedService {
  31.     struct IDeviceIoService ioService;   // 服务结构的首个成员必须是IDeviceIoService类型的成员
  32.     int32_t (*LedServiceA)(void);               // 驱动的第一个服务接口
  33.     int32_t (*LedServiceB)(uint32_t inputCode); // 驱动的第二个服务接口，有多个可以依次往下累加
  34. };


  37. int32_t led_dispatch(struct HdfDeviceIoClient *deviceObject, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply)
  38. {
  39.     HDF_LOGE("%s:Dispatch,cmd:%d", __func__,cmdId);
  40.     if(cmdId == LED_WRITE_READ)
  41.     {
  42.         const char *readData = HdfSbufReadString(data);
  43.         if (readData != NULL) {
  44.             HDF_LOGE("%s: read data is: %s", __func__, readData);
  45.         }
  46.         if (!HdfSbufWriteInt32(reply, INT32_MAX)) {
  47.             HDF_LOGE("%s: reply int32 fail", __func__);
  48.         }
  49.         return HdfDeviceSendEvent(deviceObject->device, cmdId, data);
  50.     }
  51.         
  52.     return HDF_FAILURE;
  53. }

  55. int32_t service_funA()
  56. {
  57.     HDF_LOGE("%s: serviceA ok", __func__);
  58.     int i = 5;
  59.     while(i--)
  60.     {
  61.         GpioWrite(gpio, 1);
  62.         OsalSleep(1);
  63.         GpioWrite(gpio, 0);
  64.         OsalSleep(1);
  65.         
  66.     }
  67.     return 0;
  68. }

  70. int32_t service_funB(uint32_t inputCode)
  71. {
  72.     HDF_LOGE("%s: serviceB ok", __func__);
  73.     HDF_LOGE("inputCode: %d",inputCode);
  74.     return 0;
  75. }

  77. int32_t led_bind(struct HdfDeviceObject *object)
  78. {
  79.     HDF_LOGI("%s: led_bind", __func__);
  80.     if (object == NULL) {
  81.         HDF_LOGE("%s: param is null", __func__);
  82.         return HDF_ERR_INVALID_PARAM;
  83.     }
  84.     static struct ILedService ledDriver = {
  85.         .ioService.object = {0},
  86.         .ioService.Dispatch = led_dispatch,
  87.         .LedServiceA = service_funA,
  88.         .LedServiceB = service_funB,
  89.     };
  90.     object->service = &ledDriver.ioService;
  91.     return HDF_SUCCESS;
  92. }

  94. // 订阅回调函数的编写，当被订阅的驱动加载完成后，HDF框架会将被订阅驱动的服务发布给订阅者，通过这个回调函数给订阅者使用
  95. // object为订阅者的私有数据，service为被订阅的服务对象
  96. int32_t TestDriverSubCallBack(struct HdfDeviceObject *deviceObject, const struct HdfObject *service)
  97. {
  98.     (void)*deviceObject;
  99.     const struct ILedService *sampleService =
  100.         (const struct ILedService *)service;
  101.     if (sampleService == NULL) {
  102.         return -1;
  103.     }
  104.     sampleService->LedServiceA();
  105.     sampleService->LedServiceB(5);
  106.     return 0;
  107. }

  109. int led_init(struct HdfDeviceObject *deviceObject)
  110. {
  111.     HDF_LOGI("%s: led_init", __func__);
  112.     GpioSetDir(gpio, GPIO_DIR_OUT);//设置GPIO管脚方向,输出
  113.     if (deviceObject == NULL) {
  114.         HDF_LOGE("Test driver init failed, deviceObject is null!");
  115.         return -1;
  116.     }
  117.     struct SubscriberCallback callBack;
  118.     callBack.deviceObject = deviceObject;
  119.     callBack.OnServiceConnected = TestDriverSubCallBack;
  120.     int32_t ret = HdfDeviceSubscribeService(deviceObject, "HDF_PLATFORM_LED", callBack);
  121.     if (ret != 0) {
  122.         HDF_LOGE("Test driver subscribe led driver failed!");
  123.     }
  124.     return ret;
  125. }

  127. void led_release(struct HdfDeviceObject *deviceObject)
  128. {
  129.     HDF_LOGD("led driver release success");
  130.     return;
  131. }

  133. struct HdfDriverEntry g_ledDevEntry = {
  134.     .moduleVersion = 1,
  135.     .moduleName = "HDF_PLATFORM_LED",
  136.     .Bind = led_bind,
  137.     .Init = led_init,
  138.     .Release = led_release,
  139. };

  141. HDF_INIT(g_ledDevEntry);

复制代码

main.c如下
  1. #include "hdf_log.h"
  2. #include "osal_mem.h"
  3. #include "hdf_io_service_if.h"
  4. #include <sys/types.h>
  5. #include <sys/stat.h>
  6. #include <fcntl.h>
  7. #include <string.h>
  8. #include <unistd.h>
  9. #include "osal_time.h"
  10. // #include "hdf_device_desc.h"
  11. //#include "hdf_device_section.h"

  13. #include <stdlib.h>
  14. // #include <asm/io.h>
  15. // #include <fs/fs.h>
  16. // #include <fs_poll_pri.h>
  17. // #include <los_queue.h>
  18. #include <poll.h>
  19. // #include <user_copy.h>
  20. // #include <securec.h>
  21. // #include "gpio_if.h"
  22. #include "hdf_device_desc.h"
  23. // #include "hdf_log.h"
  24. #include "osal_irq.h"
  25. // #include "osal_mem.h"
  26. // #include "osal_time.h"
  27. #include <sys/ioctl.h>
  28. #include "hdf_***uf.h"
  29. #include "led_dev.h"



  33. #define SAMPLE_WRITE_READ 123    // 读写操作码1
  34. int g_replyFlag = 0;

  36. struct ILedService {
  37.     struct IDeviceIoService ioService;   // 服务结构的首个成员必须是IDeviceIoService类型的成员
  38.     int32_t (*LedServiceA)(void);               // 驱动的第一个服务接口
  39.     int32_t (*LedServiceB)(uint32_t inputCode); // 驱动的第二个服务接口，有多个可以依次往下累加
  40. };

  42. static int SendEvent(struct HdfIoService *serv, char *eventData)
  43. {
  44.     int ret = 0;
  45.     struct HdfSBuf *data = HdfSBufObtainDefaultSize();
  46.     if (data == NULL) {
  47.         HDF_LOGE("fail to obtain ***uf data");
  48.         return 1;
  49.     }

  51.     struct HdfSBuf *reply = HdfSBufObtainDefaultSize();
  52.     if (reply == NULL) {
  53.         HDF_LOGE("fail to obtain ***uf reply");
  54.         ret = HDF_DEV_ERR_NO_MEMORY;
  55.         goto out;
  56.     }

  58.     if (!HdfSbufWriteString(data, eventData)) {
  59.         HDF_LOGE("fail to write ***uf");
  60.         ret = HDF_FAILURE;
  61.         goto out;
  62.     }

  64.     ret = serv->dispatcher->Dispatch(&serv->object, SAMPLE_WRITE_READ, data, reply);
  65.     if (ret != HDF_SUCCESS) {
  66.         HDF_LOGE("fail to send service call");
  67.         goto out;
  68.     }

  70.     int replyData = 0;
  71.     if (!HdfSbufReadInt32(reply, &replyData)) {
  72.         HDF_LOGE("fail to get service call reply");
  73.         ret = HDF_ERR_INVALID_OBJECT;
  74.         goto out;
  75.     }
  76.     HDF_LOGE("Get reply is: %d", replyData);
  77. out:
  78.     HdfSBufRecycle(data);
  79.     HdfSBufRecycle(reply);
  80.     return ret;
  81. }

  83. static int OnDevEventReceived(void *priv,  uint32_t id, struct HdfSBuf *data)
  84. {
  85.         HDF_LOGE("%s: OnDevEventReceived", __func__);
  86.     const char *string = HdfSbufReadString(data);
  87.     if (string == NULL) {
  88.         HDF_LOGE("fail to read string in event data");
  89.         g_replyFlag = 1;
  90.         return HDF_FAILURE;
  91.     }
  92.     HDF_LOGE("%s: dev event received: %u %s",  (char *)priv, id, string);
  93.     g_replyFlag = 1;
  94.     return HDF_SUCCESS;
  95. }

  97. int main()
  98. {
  99.         char *sendData = "default event info";
  100.     struct HdfIoService *serv = HdfIoServiceBind("HDF_PLATFORM_LED", 0);
  101.     if (serv == NULL) {
  102.         HDF_LOGE("fail to get service %s", "HDF_PLATFORM_LED");
  103.         return HDF_FAILURE;
  104.     }

  106.     static struct HdfDevEventlistener listener = {
  107.         .callBack = OnDevEventReceived,
  108.         .priv ="Service0"
  109.     };

  111.     if (HdfDeviceRegisterEventListener(serv, &listener) != HDF_SUCCESS) {
  112.         HDF_LOGE("fail to register event listener");
  113.         return HDF_FAILURE;
  114.     }
  115.     if (SendEvent(serv, sendData)) {
  116.         HDF_LOGE("fail to send event");
  117.         return HDF_FAILURE;
  118.     }

  120.     /* wait for event receive event finishing */
  121.     while (g_replyFlag == 0) {
  122.         sleep(1);
  123.     }
  124.     if (HdfDeviceUnregisterEventListener(serv, &listener)) {
  125.         HDF_LOGE("fail to  unregister listener");
  126.         return HDF_FAILURE;
  127.     }
  128.     HdfIoServiceRecycle(serv);
  129.     return HDF_SUCCESS;
  130. }

复制代码


service.zip
(35.7 KB, 下载次数: 6)
举报

回帖

声明：本文内容及配图由入驻作者撰写或者入驻合作网站授权转载。文章观点仅代表作者本人，不代表电子发烧友网立场。文章及其配图仅供工程师学习之用，如有内容图片侵权或者其他问题，请联系本站作侵删。 侵权投诉
链接复制成功，分享给好友