鸿蒙OpenHarmony【外设驱动使用之USB】 子体系

USB

概述

功能简介

USB（Universal Serial Bus）通用串行总线，包含了主机端（Host）和设备端（Device）。主机端负责USB总线中的数据传输及端口管理，设备端则可以毗连各种外设，以是USB驱动开辟又分为主机端驱动开辟和设备端驱动开辟。
OpenHarmony体系USB模块支持USB业务的开辟，提供USB相干的功能，提供用户态第三方功能驱动的USB设备数据读写接口，以及提供创建和删除USB设备，接口的事件获取、打开和关闭等，管道同步异步读写通信，设置USB自界说属性等。
USB DDK（USB DriverDevelop Kit）是HDF驱动框架为开辟者提供的USB驱动程序开辟套件，包括USB Host DDK及USB Device DDK两部门，支持基于用户态开辟USB设备驱动的同时，还提供了丰富的USB驱动开辟本领，让广大开辟者能精准且高效的开辟USB驱动程序。
根本概念

• 管道
  管道（Pipe）是主机端和设备端点之间数据传输的模型。任何USB设备一旦上电就存在一个信息管道，即默认的控制管道，USB主机通过该管道来获取设备的描述、配置、状态，并对设备进行配置；管道和端点关联，两者有相同的属性，如支持的传输范例、最大包长度、传输方向等。
  
• 端点
  端点（Endpoint）是USB设备中的可以进行数据收发的最小单元，支持单向大概双向的数据传输。一个USB设备可以包括若干个端点，不同的端点以端点编号和方向区分。不同端点可以支持不同的传输范例、访问间隔以及最大数据包大小。除端点0外，所有的端点只支持一个方向的数据传输。端点0是一个特殊的端点，它支持双向的控制传输。
  
• 接口
  应用软件通过和设备之间的数据互换来完成设备的控制和数据传输。由于同一管道只支持一种范例的数据传输，因此这个过程中通常需要多个管道来完成数据互换。像这样用在一起来对设备进行控制的若干管道的聚集称为接口。
  
• 描述符
  描述符（Descriptor）是用于描述设备属性（Attributes）的数据结构，第一个字节表示描述符的大小（字节数），第二个字节表示描述符的范例（Type）。
  

运作机制

USB Host DDK

USB Host DDK为开辟者提供了主机端USB驱动开辟本领，按照功能分为三大类，分别是DDK初始化类、interface对象利用类及request对象利用类。
图1 USB Host驱动模型图

• USB Interface Pool负责USB Interface管理。提供USB Interface接口对象的申请和回收，USB Interface接口对象用来记录设备端口信息以及资源。USB Interface Pool按照USB Port对USB Interface进行分类管理。同时，此模块还提供了USB DDK API，方便开辟者进行USB数据读写利用。
  
• USB Protocol Layer提供USB协议封装，根据USB协议对设备IO/控制命令进行翻译息争析”，同时负责设备描述符的管理，根据USB Device上报的罗列信息，匹配对应的描述符；构建对应的USB Interface接口对象，并将其加入到USB Interface Pool中管理。
  
• Device IO Manager负责USB IO哀求管理，提供了同步IO和异步IO管理机制，对于异步IO，IO Manager负责将该哀求记录下来，然后通过Raw API Library提供的接口依次处理待发送的IO哀求；当收到USB控制器应答的处理结果后，IO接收线程负责剖析并上报处理结果给上层调用者。
  
• Raw API Library抽象了底层OS本领，界说了同一的OS本领接口，对外提供了USB RAW API，方便开辟者实现更加复杂的驱动功能。
  
• OS Adapter用于封装与平台（Linux和LiteOS）相干的利用，根据不同平台配置编译对应平台的封装接口。在Linux平台上，访问USB FS的利用，全部都封装在这个模块中；而在LiteOS平台上，基于FreeBSD USB框架的设备访问利用，也都全部封装在这个模块中。
  
• PNP Notify用于动态监测USB状态变化，当有新设备添加/移除时，变化设备信息。同时将所有USB设备信息都通过KHDF上报给UHDF侧的PNP Notify Manager模块来完成加载/卸载第三方功能驱动。
  

USB Device DDK

USB Device DDK向开辟者提供了设备端USB驱动开辟本领。比方，USB端口动态注册和去注册本领，开辟者可以基于本领实现USB端口的动态添加和组合；动态实例化本领，支持根据动态下发设备、配置、接口及端点描述符创建立备实例及传输通道；用户态的数据发送及接收本领，支持用户态下发送及接收数据；复合设备本领，支持一个物理设备上多个逻辑设备，实现多个逻辑设备间隔离，并支持不同逻辑设备同时被不同的应用历程访问。
图2 USB Device驱动模型图

• SDK IF负责将USB设备按照设备、接口、管道进行逻辑划分，对配置管理、设备管理、IO管理进行封装。此模块还向开辟者提供了设备创建、获取接口、接收Event事件、收发数据等设备测驱动开辟的本领接口。
  
• Configuration Manager负责剖析HCS文件描述的USB描述符信息，得到的USB描述符信息用于设备创建，同时模块还提供了自界说属性的读取、创建、删除、修改等利用。
  
• Device Manager负责根据配置模块剖析USB描述符，并根据USB描述符创建立备。同时还负责获取设备、删除设备、获取设备状态，获取设备上面接口信息。
  
• IO Manager负责数据的读写，包括Events事件、数据读写完成后事件的接收，支持同步和异步模式数据读写。
  
• Adapter IF主要是对复合设备配置驱动及通用功能驱动设备节点利用进行封装，为上层提供同一的设备管理接口。
  
• Adapter该模块由复合设备配置驱动及通用功能驱动提供。
  

开辟指导

由于内核态开辟USB驱动较复杂，需要开辟者对USB协议要有较深的了解才华很好的使用，对开辟者的要求相对较高。USB DDK的引入是为了让开辟者能在用户态更方便的开辟USB驱动。
场景介绍

USB Host DDK为开辟者提供了普通模式和专家模式，普通模式下，开辟者可通过USB DDK API直接完成相干USB数据读写利用，不需要过多关注底层的传输细节。专家模式下，开辟者通过USB RAW API直接访问OS平台中USB通道的接口，自界说实现更加复杂的功能。USB Device DDk为开辟者提供了管理USB设备、接口界说及USB数据哀求等功能。下文将介绍相干API。
接口说明

USB主机端驱动程序开辟相干接口（普通模式）如下
表1 USB主机端驱动程序开辟相干接口（普通模式）
接口名称功能描述int32_t UsbInitHostSdk(struct UsbSession **session);
USB主机端驱动开辟工具包初始化struct UsbInterface *UsbClaimInterface(const struct UsbSession *session, uint8_t busNum, uint8_t usbAddr, uint8_t interfaceIndex)获取USB接口对象UsbInterfaceHandle *UsbOpenInterface(const struct UsbInterface *interfaceObj);
打开USB对象接口int32_t UsbGetPipeInfo(const UsbInterfaceHandle *interfaceHandle, uint8_t settingIndex, uint8_t pipeId, struct UsbPipeInfo *pipeInfo);
获取指定可选设置的管道信息struct UsbRequest *UsbAllocRequest(const UsbInterfaceHandle *interfaceHandle, int32_t isoPackets , int32_t length);分配哀求对象int32_t UsbFillRequest(const struct UsbRequest *request, const UsbInterfaceHandle *interfaceHandle, const struct UsbRequestParams *params);
添补哀求int32_t UsbSubmitRequestSync(const struct UsbRequest *request);发送同步哀求 USB主机端驱动程序开辟相干接口（专家模式）如下
表2 USB主机端驱动程序开辟相干接口（专家模式）
接口名称功能描述int32_t UsbRawInit(struct UsbSession **session);
USB驱动开辟工具包专家模式初始化UsbRawHandle *UsbRawOpenDevice(const struct UsbSession *session, uint8_t busNum, uint8_t usbAddr);
打开USB设备对象int32_t UsbRawSendControlRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbControlRequestData *requestData);实行同步控制传输int32_t UsbRawSendBulkRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRequestData *requestData);实行同步批量传输int32_t UsbRawSendInterruptRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRequestData *requestData);实行同步停止传输int32_t UsbRawGetConfigDescriptor(const UsbRawDevice *rawDev, uint8_t configIndex, struct UsbRawConfigDescriptor **config);
获取给定设备指定ID的设备配置描述符int32_t UsbRawFillInterruptRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawFillRequestData *fillData);添补停止传输哀求所需信息int32_t UsbRawFillIsoRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawFillRequestData *fillData);添补同步传输（Isochronous Transfers）哀求所需信息int32_t UsbRawSubmitRequest(const struct UsbRawRequest *request);提交一个传输哀求int32_t UsbRawCancelRequest(const struct UsbRawRequest *request);取消一个传输哀求int32_t UsbRawHandleRequests(const UsbRawHandle *devHandle);传输哀求事件完成处理 USB设备端用于管理USB设备的相干接口如下
表3 USB设备端用于管理USB设备的相干接口
接口名称功能描述const struct UsbFnDevice *UsbFnCreateDevice(const char *udcName, const struct UsbFnDescriptorData *descriptor);创建USB设备int32_t UsbFnRemoveDevice(struct UsbFnDevice *fnDevice);删除USB设备const struct UsbFnDevice *UsbFnGetDevice(const char *udcName);获取USB设备 USB设备端用于USB接口界说的相干接口如下
表4 USB设备端用于USB接口界说的相干接口
接口名称功能描述int32_t UsbFnStartRecvInterfaceEvent(struct UsbFnInterface *interface, uint32_t eventMask, UsbFnEventCallback callback, void *context);开始接受Event事件int32_t UsbFnStopRecvInterfaceEvent(struct UsbFnInterface *interface);停止接受Event事件UsbFnInterfaceHandle UsbFnOpenInterface(struct UsbFnInterface *interface);打开一个接口int32_t UsbFnCloseInterface(UsbFnInterfaceHandle handle);关闭一个接口int32_t UsbFnGetInterfacePipeInfo(struct UsbFnInterface *interface, uint8_t pipeId, struct UsbFnPipeInfo *info);获取管道信息int32_t UsbFnSetInterfaceProp(const struct UsbFnInterface *interface, const char *name, const char *value);设置自界说属性 USB设备端用于管理USB数据哀求的相干接口如下
表5 USB设备端用于管理USB数据哀求的相干接口
接口名称功能描述struct UsbFnRequest *UsbFnAllocCtrlRequest(UsbFnInterfaceHandle handle, uint32_t len);申请一个控制哀求struct UsbFnRequest *UsbFnAllocRequest(UsbFnInterfaceHandle handle, uint8_t pipe, uint32_t len);申请一个数据哀求int32_t UsbFnFreeRequest(struct UsbFnRequest *req);开释一个哀求int32_t UsbFnSubmitRequestAsync(struct UsbFnRequest *req);发送异步哀求int32_t UsbFnSubmitRequestSync(struct UsbFnRequest *req, uint32_t timeout);发送同步哀求int32_t UsbFnCancelRequest(struct UsbFnRequest *req);取消哀求 开辟步骤

USB驱动基于HDF框架、Platform和OSAL基础接口进行开辟，不区分利用体系和芯片平台，为不同USB器件提供同一的驱动模型。此处以串口为例，分别介绍USB Host和USB Device驱动开辟的详细过程。
Host DDK API驱动开辟

• 在设备私有数据HCS中配置，完成主机端驱动总体信息的配置，具体如下：
  
  1. root {
  2.     module = "usb_pnp_device";
  3.     usb_pnp_config {
  4.         match_attr = "usb_pnp_match";
  5.         usb_pnp_device_id = "UsbPnpDeviceId";
  6.         UsbPnpDeviceId {
  7.             idTableList = [
  8.                 "host_acm_table"
  9.             ];
  10.             host_acm_table {
  11.                 // 驱动模块名，该字段的值必须和驱动入口结构的moduleName一致
  12.                 moduleName = "usbhost_acm";
  13.                 // 驱动对外发布服务的名称，必须唯一
  14.                 serviceName = "usbhost_acm_pnp_service";
  15.                 // 驱动私有数据匹配关键字
  16.                 deviceMatchAttr = "usbhost_acm_pnp_matchAttr";
  17.                 // 从该字段开始（包含该字段）之后数据长度，以byte为单位
  18.                 length = 21;
  19.                 // USB驱动匹配规则vendorId+productId+interfaceSubClass+interfaceProtocol+interfaceNumber
  20.                 matchFlag = 0x0303;
  21.                 // 厂商编号
  22.                 vendorId = 0x12D1;
  23.                 // 产品编号
  24.                 productId = 0x5000;
  25.                 // 设备出厂编号，低16位
  26.                 bcdDeviceLow = 0x0000;
  27.                 // 设备出厂编号，高16位
  28.                 bcdDeviceHigh = 0x0000;
  29.                 // USB分配的设备类代码
  30.                 deviceClass = 0;
  31.                 // USB分配的子类代码
  32.                 deviceSubClass = 0;
  33.                 // USB分配的设备协议代码
  34.                 deviceProtocol = 0;
  35.                 // 接口类型，根据实际需要可填写多个
  36.                 interfaceClass = [0];
  37.                 // 接口子类型，根据实际需要可填写多个
  38.                 interfaceSubClass = [2, 0];
  39.                 // 接口所遵循的协议，根据实际需要可填写多个   
  40.                 interfaceProtocol = [1, 2];
  41.                 // 接口的编号，根据实际需要可填写多个
  42.                 interfaceNumber = [2, 3];
  43.             }
  44.         }
  45.     }
  46. }

  复制代码
• USB主机端驱动开辟工具包初始化。
  
  1. int32_t UsbInitHostSdk(struct UsbSession **session);

  复制代码
• 步骤2初始化完后获取UsbInterface对象。
  
  1. const struct UsbInterface *UsbClaimInterface(const struct UsbSession *session, uint8_t busNum, uint8_t usbAddr, uint8_t interfaceIndex);

  复制代码
• 打开步骤3获取到的UsbInterface接口对象，获取相应接口的UsbInterfaceHandle对象。
  
  1. UsbInterfaceHandle *UsbOpenInterface(const struct UsbInterface *interfaceObj);

  复制代码
• 根据步骤4获取到的UsbInterfaceHandle对象，获取指定索引为pipeIndex的pipeInfo信息。
  
  1. int32_t UsbGetPipeInfo(const UsbInterfaceHandle *interfaceHandle, uint8_t settingIndex, uint8_t pipeId, struct UsbPipeInfo *pipeInfo);

  复制代码
• 为步骤4获取到的UsbInterfaceHandle预先分配待发送的IO Request对象。
  
  1. struct UsbRequest *UsbAllocRequest(const UsbInterfaceHandle *interfaceHandle, int32_t isoPackets, int32_t length);

  复制代码
• 根据输入参数params添补步骤6预先分配的IO Request。
  
  1. int32_t UsbFillRequest(const struct UsbRequest *request, const UsbInterfaceHandle *interfaceHandle, const struct UsbRequestParams *params);

  复制代码
• 提交IO Request对象，可以选择同步或异步两种模式。
  
  1. int32_t UsbSubmitRequestSync(const struct UsbRequest *request); //发送同步IO请求
  2. int32_t UsbSubmitRequestAsync(const struct UsbRequest *request); //发送异步IO请求

  复制代码

Host RAW API驱动开辟

• 同Host DDK API的步骤1一样，在设备私有数据HCS中配置。
  
• 初始化Host RAW，并打开USB设备，然后获取描述符，通过描述符获取接口、端点信息。
  
  1. int32_t UsbRawInit(struct UsbSession **session);

  复制代码
• 待步骤2完成后打开USB设备。
  
  1. UsbRawHandle *UsbRawOpenDevice(const struct UsbSession *session, uint8_t busNum, uint8_t usbAddr);

  复制代码
• 待步骤3完成后获取描述符，通过描述符获取接口、端点信息。
  
  1. int32_t UsbRawGetConfigDescriptor(const UsbRawDevice *rawDev, uint8_t configIndex, struct UsbRawConfigDescriptor **config);

  复制代码
• 分配Request，并根据传输范例使用相应接口对Request进行添补。
  
  1. int32_t UsbRawFillBulkRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawFillRequestData *fillData); // 填充用于批量传输的请求
  2. int32_t UsbRawFillControlSetup(const unsigned char *setup, const struct UsbControlRequestData *requestData);
  3. int32_t UsbRawFillControlRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawFillRequestData *fillData); // 填充用于控制传输的请求
  4. int32_t UsbRawFillInterruptRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawFillRequestData *fillData); // 填充用于中断传输的请求
  5. int32_t UsbRawFillIsoRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRawFillRequestData *fillData); // 填充用于同步传输的请求

  复制代码
• 提交IO Request对象，可以选择同步或异步两种模式。
  
  1. int32_t UsbRawSendControlRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbControlRequestData *requestData); //发送同步USB控制传输请求
  2. int32_t UsbRawSendBulkRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRequestData *requestData); //发送同步USB批量传输请求
  3. int32_t UsbRawSendInterruptRequest(const struct UsbRawRequest *request, const UsbRawHandle *devHandle, const struct UsbRequestData *requestData); //发送同步执行USB中断传输请求
  4. int32_t UsbRawSubmitRequest(const struct UsbRawRequest *request); //提交异步IO请求

  复制代码

Device DDK API驱动开辟

• 在设备功能代码中构造描述符。
  
  1. static struct UsbFnFunction g_acmFunction = {
  2.     .funcName = "f_generic.a",                     //功能名称
  3.     .strings = g_acmStrings,                       //字符串
  4.     .fsDescriptors = g_acmFsFunction,              //初始化fs描述符
  5.     .hsDescriptors = g_acmHsFunction,              //初始化hs描述符
  6.     .ssDescriptors = g_acmSsFunction,              //初始化ss描述符
  7.     .sspDescriptors = nullptr,                     //ss描述符置空
  8. };
  9. struct UsbFnFunction *g_functions[] = {
  10. #ifdef CDC_ECM
  11.     &g_ecmFunction,
  12. #endif
  13. #ifdef CDC_ACM
  14.     &g_acmFunction,
  15. #endif
  16.     nullptr};
  17. static struct UsbFnConfiguration g_masterConfig = { // 配置描述符
  18.     .configurationValue = 1,
  19.     .iConfiguration     = USB_FUNC_CONFIG_IDX,
  20.     .attributes         = USB_CFG_BUS_POWERED,
  21.     .maxPower           = POWER,
  22.     .functions          = g_functions,
  23. };
  24. static struct UsbFnConfiguration *g_configs[] = {
  25.     &g_masterConfig,
  26.     nullptr,
  27. };
  28. static struct UsbDeviceDescriptor g_cdcUsbFnDeviceDesc = { // 设备描述符
  29.     .bLength            = sizeof(g_cdcUsbFnDeviceDesc),
  30.     .bDescriptorType    = USB_DDK_DT_DEVICE,
  31.     .bcdUSB             = CpuToLe16(BCD_USB),
  32.     .bDeviceClass       = 0,
  33.     .bDeviceSubClass    = 0,
  34.     .bDeviceProtocol    = 0,
  35.     .bMaxPacketSize0    = USB_MAX_PACKET_SIZE,
  36.     .idVendor           = CpuToLe16(DEVICE_VENDOR_ID),
  37.     .idProduct          = CpuToLe16(DEVICE_PRODUCT_ID),
  38.     .bcdDevice          = CpuToLe16(DEVICE_VERSION),
  39.     .iManufacturer      = USB_FUNC_MANUFACTURER_IDX,
  40.     .iProduct           = USB_FUNC_PRODUCT_IDX,
  41.     .iSerialNumber      = USB_FUNC_SERIAL_IDX,
  42.     .bNumConfigurations = 1,
  43. };
  44. struct UsbFnDeviceDesc g_acmFnDevice = { //描述符入口
  45.     .deviceDesc = &g_cdcUsbFnDeviceDesc,
  46.     .deviceStrings = g_devStrings,
  47.     .configs = g_configs,
  48. };

  复制代码
• 创建立备。描述符构造完成后，使用UsbFnDeviceCreate函数创建一个USB设备，并传入UDC控制器和UsbFnDescriptorData结构体。
  
  1. if (useHcs == 0) { // 使用代码编写的描述符
  2.     descData.type = USBFN_DESC_DATA_TYPE_DESC;
  3.     descData.descriptor = &g_acmFnDevice;
  4. } else {             // 使用hcs编写的描述符
  5.     devMgr->descData.type = USBFN_DESC_DATA_TYPE_PROP;
  6.     devMgr->descData.property = device->property;
  7. }
  8. // 创建设备
  9. fnDev = (struct UsbFnDevice *)UsbFnCreateDevice(devMgr->udcName, &devMgr->descData);

  复制代码
• 设备创建后，使用UsbFnGetInterface函数获取UsbInterface接口对象，并通过UsbFnGetInterfacePipeInfo函数获取USB管道信息。
  
  1. // 获取接口
  2. fnIface = (struct UsbFnInterface *)UsbFnGetInterface(fnDev, i);
  3. // 获取Pipe信息
  4. UsbFnGetInterfacePipeInfo(fnIface, i, &pipeInfo);
  5. // 获取Handle
  6. handle = UsbFnOpenInterface(fnIface);
  7. // 获取控制（EP0）Request
  8. req = UsbFnAllocCtrlRequest(acmDevice->ctrlIface.handle, sizeof(struct UsbCdcLineCoding) + sizeof(struct UsbCdcLineCoding));
  9. // 获取Request
  10. req = UsbFnAllocCtrlRequest(acmDevice->ctrlIface.handle, sizeof(struct UsbCdcLineCoding) + sizeof(struct UsbCdcLineCoding));

  复制代码
• 通过UsbFnStartRecvInterfaceEvent函数接收Event事件，并通过UsbFnEventCallback回调函数对Event事件做出响应。
  
  1. // 开始接收Event事件
  2. ret = UsbFnStartRecvInterfaceEvent(acmDevice->ctrlIface.fn, 0xff, AcmEventCallback, acmDevice);
  3. // Event处理回调函数
  4. static void UsbAcmEventCallback(struct UsbFnEvent *event)
  5. {
  6.     struct UsbAcmDevice *acm = NULL;
  7.     if (event == NULL || event->context == NULL) {
  8.         HDF_LOGE("%{public}s: event is null", __func__);
  9.         return;
  10.     }
  11.     acm = (struct UsbAcmDevice *)event->context;
  12.     switch (event->type) {
  13.         case USBFN_STATE_BIND:
  14.             HDF_LOGI("%{public}s: receive bind event", __func__);
  15.             break;
  16.         case USBFN_STATE_UNBIND:
  17.             HDF_LOGI("%{public}s: receive unbind event", __func__);
  18.             break;
  19.         case USBFN_STATE_ENABLE:
  20.             HDF_LOGI("%{public}s: receive enable event", __func__);
  21.             AcmEnable(acm);
  22.             break;
  23.         case USBFN_STATE_DISABLE:
  24.             HDF_LOGI("%{public}s: receive disable event", __func__);
  25.             AcmDisable(acm);
  26.             acm->enableEvtCnt = 0;
  27.             break;
  28.         case USBFN_STATE_SETUP:
  29.             HDF_LOGI("%{public}s: receive setup event", __func__);
  30.             if (event->setup != NULL) {
  31.                 AcmSetup(acm, event->setup);
  32.             }
  33.             break;
  34.         case USBFN_STATE_SUSPEND:
  35.             HDF_LOGI("%{public}s: receive suspend event", __func__);
  36.             AcmSuspend(acm);
  37.             break;
  38.         case USBFN_STATE_RESUME:
  39.             HDF_LOGI("%{public}s: receive resume event", __func__);
  40.             AcmResume(acm);
  41.             break;
  42.         default:
  43.             break;
  44.     }
  45. }

  复制代码
• 收发数据，可以选择同步异步发送模式。
  
  1. notify = (struct UsbCdcNotification *)req->buf;
  2. ...
  3. ret = memcpy_s((void *)(notify + 1), length, data, length);
  4. if (ret != EOK) {
  5.     HDF_LOGE("%s: memcpy_s failed", __func__);
  6.     return HDF_FAILURE;
  7. }
  8. ret = UsbFnSubmitRequestAsync(req); // 异步发送
  9. if (ret != HDF_SUCCESS) {
  10.     HDF_LOGE("%s: send notify request failed", __func__);
  11.     acm->notifyReq = req;
  12. }

  复制代码

开辟实例

本实例提供USB串口驱动开辟示例，并简要对具体关键点进行开辟说明。
Host DDK API驱动开辟

1. #include "usb_serial.h"
2. #include "hdf_base.h"
3. #include "hdf_log.h"
4. #include "hdf_usb_pnp_manage.h"
5. #include "osal_mem.h"
6. #include "osal_time.h"
7. #include "securec.h"
8. #include "usb_ddk_interface.h"
10. #define HDF_LOG_TAG USB_HOST_ACM
11. #define STR_LEN     512
13. static struct UsbRequest *g_syncRequest = NULL;  // 定义一个USB请求
14. static struct UsbRequest *g_ctrlCmdRequest = NULL;
15. static bool g_acmReleaseFlag = false;
16. static uint8_t *g_acmReadBuffer = NULL;
17. ...
18. static int32_t SerialCtrlMsg(struct AcmDevice *acm, uint8_t request, uint16_t value, void *buf, uint16_t len)
19. {
20.     int32_t ret;
21.     if (acm == NULL || buf == NULL || acm->intPipe == NULL) {
22.         HDF_LOGE("%s:invalid param", __func__);
23.         return HDF_ERR_IO;
24.     }
25.     uint16_t index = acm->intPipe->interfaceId;
26.     struct UsbControlParams controlParams = {};
27.     struct UsbRequestParams parmas = {}; // 定义一个USB请求参数对象
28.     if (acm->ctrlReq == NULL) {
29.         // 为获取到的UsbInterfaceHandle预先分配待发送的IO Request对象
30.         acm->ctrlReq = UsbAllocRequest(acm->ctrDevHandle, 0, len);
31.         if (acm->ctrlReq == NULL) {
32.             HDF_LOGE("%s: UsbAllocRequest failed", __func__);
33.             return HDF_ERR_IO;
34.         }
35.     }
37.     controlParams.request = request;
38.     controlParams.target = USB_REQUEST_TARGET_INTERFACE; // 接口对象
39.     controlParams.reqType = USB_REQUEST_TYPE_CLASS; // 请求类型
40.     controlParams.directon = USB_REQUEST_DIR_TO_DEVICE; // 从主机到设备的数据传输
41.     controlParams.value = value;
42.     controlParams.index = index;
43.     controlParams.data = buf;
44.     controlParams.size = len;
46.     parmas.interfaceId = USB_CTRL_INTERFACE_ID; // 定义USB控制接口的默认ID
47.     if (acm->ctrPipe != NULL) {
48.         parmas.pipeAddress = acm->ctrPipe->pipeAddress;
49.         parmas.pipeId = acm->ctrPipe->pipeId;
50.     }
51.     parmas.requestType = USB_REQUEST_PARAMS_CTRL_TYPE; // 控制类型
52.     parmas.timeout = USB_CTRL_SET_TIMEOUT; // 设置超时时间
53.     parmas.ctrlReq = UsbControlSetUp(&controlParams);
54.     parmas.callback = NULL;
55.     // 根据params填充预先分配的IO Request
56.     ret = UsbFillRequest(acm->ctrlReq, acm->ctrDevHandle, &parmas);
57.     if (ret != HDF_SUCCESS) {
58.         HDF_LOGE("%s: UsbFillRequest failed, ret = %d ", __func__, ret);
59.         return ret;
60.     }
61.     // 发送同步IO Request
62.     ret = UsbSubmitRequestSync(acm->ctrlReq);
63.     if (ret != HDF_SUCCESS) {
64.         HDF_LOGE("UsbSubmitRequestSync failed, ret = %d ", ret);
65.         return ret;
66.     }
67.     if (!acm->ctrlReq->compInfo.status) {
68.         HDF_LOGE("%s  status=%d ", __func__, acm->ctrlReq->compInfo.status);
69.     }
70.     return HDF_SUCCESS;
71. }
72. ...
73. static struct UsbInterface *GetUsbInterfaceById(const struct AcmDevice *acm, uint8_t interfaceIndex)
74. {
75.     // 获取UsbInterface接口对象
76.     return UsbClaimInterface(acm->session, acm->busNum, acm->devAddr, interfaceIndex);
77. }
78. ...
79. static struct UsbPipeInfo *EnumePipe(
80.     const struct AcmDevice *acm, uint8_t interfaceIndex, UsbPipeType pipeType, UsbPipeDirection pipeDirection)
81. {
82.     struct UsbInterfaceInfo *info = NULL; // 定义一个USB接口信息对象
83.     UsbInterfaceHandle *interfaceHandle = NULL; // 定义一个USB接口操作句柄，就是void *类型
84.     if (pipeType == USB_PIPE_TYPE_CONTROL) {
85.         info = &acm->ctrIface->info;
86.         interfaceHandle = acm->ctrDevHandle;
87.     } else {
88.         // 根据interfaceIndex获取设备句柄
89.         info = &acm->iface[interfaceIndex]->info;
90.         interfaceHandle = InterfaceIdToHandle(acm, info->interfaceIndex);
91.     }
93.     for (uint8_t i = 0; i <= info->pipeNum; i++) {
94.         struct UsbPipeInfo p;
95.         // 获取指定索引为i的pipeInfo信息
96.         int32_t ret = UsbGetPipeInfo(interfaceHandle, info->curAltSetting, i, &p);
97.         if (ret < 0) {
98.             continue;
99.         }
100.         if ((p.pipeDirection == pipeDirection) && (p.pipeType == pipeType)) {
101.             struct UsbPipeInfo *pi = OsalMemCalloc(sizeof(*pi)); // 开辟内存并初始化
102.             if (pi == NULL) {
103.                 HDF_LOGE("%s: Alloc pipe failed", __func__);
104.                 return NULL;
105.             }
106.             p.interfaceId = info->interfaceIndex;
107.             *pi = p;
108.             return pi;
109.         }
110.     }
111.     return NULL;
112. }
114. static struct UsbPipeInfo *GetPipe(const struct AcmDevice *acm, UsbPipeType pipeType, UsbPipeDirection pipeDirection)
115. {
116.     uint8_t i;
117.     if (acm == NULL) {
118.         HDF_LOGE("%s: invalid param", __func__);
119.         return NULL;
120.     }
121.     for (i = 0; i < acm->interfaceCnt; i++) {
122.         struct UsbPipeInfo *p = NULL;
123.         if (!acm->iface[i]) {
124.             continue;
125.         }
126.         // 获取控制pipe的pipeInfo信息
127.         p = EnumePipe(acm, i, pipeType, pipeDirection);
128.         if (p == NULL) {
129.             continue;
130.         }
131.         return p;
132.     }
133.     return NULL;
134. }
136. /* HdfDriverEntry implementations */
137. static int32_t UsbSerialDriverBind(struct HdfDeviceObject *device)
138. {
139.     struct UsbPnpNotifyServiceInfo *info = NULL;
140.     errno_t err;
141.     struct AcmDevice *acm = NULL;
142.     if (device == NULL) {
143.         HDF_LOGE("%s: device is null", __func__);
144.         return HDF_ERR_INVALID_OBJECT;
145.     }
146.     //开辟内存空间
147.     acm = (struct AcmDevice *)OsalMemCalloc(sizeof(*acm));
148.     if (acm == NULL) {
149.         HDF_LOGE("%s: Alloc usb serial device failed", __func__);
150.         return HDF_FAILURE;
151.     }
152.     // 初始化互斥锁，&acm->lock表示指向互斥量的指针
153.     if (OsalMutexInit(&acm->lock) != HDF_SUCCESS) {
154.         HDF_LOGE("%s:%d OsalMutexInit failed", __func__, __LINE__);
155.         goto ERROR;
156.     }
157.     info = (struct UsbPnpNotifyServiceInfo *)device->priv;
158.     if (info != NULL) {
159.         HDF_LOGD("%s:%d busNum=%d,devAddr=%d,interfaceLength=%d", __func__, __LINE__, info->busNum, info->devNum,
160.             info->interfaceLength);
161.         acm->busNum = (uint8_t)info->busNum;
162.         acm->devAddr = (uint8_t)info->devNum;
163.         acm->interfaceCnt = info->interfaceLength;
164.         err = memcpy_s((void *)(acm->interfaceIndex), USB_MAX_INTERFACES, (const void *)info->interfaceNumber,
165.             info->interfaceLength);
166.         if (err != EOK) {
167.             HDF_LOGE("%s:%d memcpy_s failed err = %d", __func__, __LINE__, err);
168.             goto LOCK_ERROR;
169.         }
170.     } else {
171.         HDF_LOGE("%s:%d info is null!", __func__, __LINE__);
172.         goto LOCK_ERROR;
173.     }
174.     acm->device = device;
175.     device->service = &(acm->service);
176.     acm->device->service->Dispatch = UsbSerialDeviceDispatch;
177.     HDF_LOGD("UsbSerialDriverBind=========================OK");
178.     return HDF_SUCCESS;
180. LOCK_ERROR:
181.     if (OsalMutexDestroy(&acm->lock)) {
182.         HDF_LOGE("%s:%d OsalMutexDestroy failed", __func__, __LINE__);
183.     }
184. ERROR:
185.     OsalMemFree(acm);
186.     acm = NULL;
187.     return HDF_FAILURE;
188. }
189. ...
190. static int32_t AcmAllocReadRequests(struct AcmDevice *acm)
191. {
192.     int32_t ret;
193.     struct UsbRequestParams readParmas = {};
194.     for (int32_t i = 0; i < ACM_NR; i++) {
195.         // 分配待发送的readReq IO Request对象
196.         acm->readReq[i] = UsbAllocRequest(InterfaceIdToHandle(acm, acm->dataInPipe->interfaceId), 0, acm->readSize);
197.         if (!acm->readReq[i]) {
198.             HDF_LOGE("readReq request failed\n");
199.             goto ERROR;
200.         }
201.         readParmas.userData = (void *)acm;
202.         readParmas.pipeAddress = acm->dataInPipe->pipeAddress;
203.         readParmas.pipeId = acm->dataInPipe->pipeId;
204.         readParmas.interfaceId = acm->dataInPipe->interfaceId;
205.         readParmas.callback = AcmReadBulk;
206.         readParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; /* Data type */
207.         readParmas.timeout = USB_CTRL_SET_TIMEOUT;
208.         readParmas.dataReq.numIsoPackets = 0;
209.         readParmas.dataReq.directon = (((uint8_t)acm->dataInPipe->pipeDirection) >> USB_PIPE_DIR_OFFSET) & 0x1;
210.         readParmas.dataReq.length = (int)acm->readSize;
211.         // 根据readParams填充预先分配待发送的readReq IO Request对象
212.         ret = UsbFillRequest(acm->readReq[i], InterfaceIdToHandle(acm, acm->dataInPipe->interfaceId), &readParmas);
213.         if (ret != HDF_SUCCESS) {
214.             HDF_LOGE("%s: UsbFillRequest failed, ret=%d \n", __func__, ret);
215.             goto ERROR;
216.         }
217.     }
218.     return HDF_SUCCESS;
220. ERROR:
221.     AcmFreeReadRequests(acm);
222.     return HDF_ERR_MALLOC_FAIL;
223. }
225. static int32_t AcmAllocNotifyRequest(struct AcmDevice *acm)
226. {
227.     int32_t ret;
228.     struct UsbRequestParams intParmas = {};
229.     // 分配待发送的中断IO Request对象
230.     acm->notifyReq = UsbAllocRequest(InterfaceIdToHandle(acm, acm->intPipe->interfaceId), 0, acm->intSize);
231.     if (!acm->notifyReq) {
232.         HDF_LOGE("notifyReq request failed.\n");
233.         return HDF_ERR_MALLOC_FAIL;
234.     }
235.     intParmas.userData = (void *)acm;
236.     intParmas.pipeAddress = acm->intPipe->pipeAddress;
237.     intParmas.pipeId = acm->intPipe->pipeId;
238.     intParmas.interfaceId = acm->intPipe->interfaceId;
239.     intParmas.callback = AcmCtrlIrq;
240.     intParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE;
241.     intParmas.timeout = USB_CTRL_SET_TIMEOUT;
242.     intParmas.dataReq.numIsoPackets = 0;
243.     intParmas.dataReq.directon = (((uint8_t)acm->intPipe->pipeDirection) >> USB_PIPE_DIR_OFFSET) & DIRECTION_MASK;
244.     intParmas.dataReq.length = (int)acm->intSize;
245.     // 填充预先分配的中断IO Request
246.     ret = UsbFillRequest(acm->notifyReq, InterfaceIdToHandle(acm, acm->intPipe->interfaceId), &intParmas);
247.     if (ret != HDF_SUCCESS) {
248.         HDF_LOGE("%s: UsbFillRequest failed, ret = %d", __func__, ret);
249.         goto ERROR;
250.     }
251.     return HDF_SUCCESS;
253. ERROR:
254.     AcmFreeNotifyReqeust(acm);
255.     return ret;
256. }
258. static void AcmReleaseInterfaces(struct AcmDevice *acm)
259. {
260.     for (uint8_t i = 0; i < acm->interfaceCnt; i++) {
261.         if (acm->iface[i]) {
262.             // 释放一个USB接口对象
263.             UsbReleaseInterface(acm->iface[i]);
264.             acm->iface[i] = NULL;
265.         }
266.     }
267.     if (acm->ctrIface) {
268.         UsbReleaseInterface(acm->ctrIface);
269.         acm->ctrIface = NULL;
270.     }
271. }
273. static int32_t AcmClaimInterfaces(struct AcmDevice *acm)
274. {
275.     for (uint8_t i = 0; i < acm->interfaceCnt; i++) {
276.         // 获取UsbInterface接口对象
277.         acm->iface[i] = GetUsbInterfaceById((const struct AcmDevice *)acm, acm->interfaceIndex[i]);
278.         if (acm->iface[i] == NULL) {
279.             HDF_LOGE("%s: interface%d is null", __func__, acm->interfaceIndex[i]);
280.             goto ERROR;
281.         }
282.     }
283.         // 获取控制接口对应的UsbInterface接口对象
284.     acm->ctrIface = GetUsbInterfaceById((const struct AcmDevice *)acm, USB_CTRL_INTERFACE_ID);
285.     if (acm->ctrIface == NULL) {
286.         HDF_LOGE("%s: GetUsbInterfaceById null", __func__);
287.         goto ERROR;
288.     }
290.     return HDF_SUCCESS;
292. ERROR:
293.     // 根据acm->interfaceCnt循环释放接口对象
294.     AcmReleaseInterfaces(acm);
295.     return HDF_FAILURE;
296. }
298. static void AcmCloseInterfaces(struct AcmDevice *acm)
299. {
300.     for (uint8_t i = 0; i < acm->interfaceCnt; i++) {
301.         if (acm->devHandle[i]) {
302.             // 关闭一个USB设备对象
303.             UsbCloseInterface(acm->devHandle[i]);
304.             acm->devHandle[i] = NULL;
305.         }
306.     }
307.     if (acm->ctrDevHandle) {
308.         UsbCloseInterface(acm->ctrDevHandle);
309.         acm->ctrDevHandle = NULL;
310.     }
311. }
313. static int32_t AcmOpenInterfaces(struct AcmDevice *acm)
314. {
315.     for (uint8_t i = 0; i < acm->interfaceCnt; i++) {
316.         if (acm->iface[i]) {
317.             // 打开获取到的UsbInterface接口对象
318.             acm->devHandle[i] = UsbOpenInterface(acm->iface[i]);
319.             if (acm->devHandle[i] == NULL) {
320.                 HDF_LOGE("%s: UsbOpenInterface null", __func__);
321.                 goto ERROR;
322.             }
323.         }
324.     }
325.     acm->ctrDevHandle = UsbOpenInterface(acm->ctrIface);
326.     if (acm->ctrDevHandle == NULL) {
327.         HDF_LOGE("%s: ctrDevHandle UsbOpenInterface null", __func__);
328.         goto ERROR;
329.     }
331.     return HDF_SUCCESS;
333. ERROR:
334.     // 关闭所有UsbInterface接口对象
335.     AcmCloseInterfaces(acm);
336.     return HDF_FAILURE;
337. }
339. static int32_t AcmGetPipes(struct AcmDevice *acm)
340. {
341.     // 获取dataInPipe的pipeInfo信息
342.     acm->dataInPipe = GetPipe(acm, USB_PIPE_TYPE_BULK, USB_PIPE_DIRECTION_IN);
343.     if (acm->dataInPipe == NULL) {
344.         HDF_LOGE("dataInPipe is null");
345.         goto ERROR;
346.     }
347.         // 获取dataOutPipe的pipeInfo信息
348.     acm->dataOutPipe = GetPipe(acm, USB_PIPE_TYPE_BULK, USB_PIPE_DIRECTION_OUT);
349.     if (acm->dataOutPipe == NULL) {
350.         HDF_LOGE("dataOutPipe is null");
351.         goto ERROR;
352.     }
353.         // 获取控制pipe的pipeInfo信息
354.     acm->ctrPipe = EnumePipe(acm, acm->ctrIface->info.interfaceIndex, USB_PIPE_TYPE_CONTROL, USB_PIPE_DIRECTION_OUT);
355.     if (acm->ctrPipe == NULL) {
356.         HDF_LOGE("ctrPipe is null");
357.         goto ERROR;
358.     }
359.     // 获取中断pipe的pipeInfo信息
360.     acm->intPipe = GetPipe(acm, USB_PIPE_TYPE_INTERRUPT, USB_PIPE_DIRECTION_IN);
361.     if (acm->intPipe == NULL) {
362.         HDF_LOGE("intPipe is null");
363.         goto ERROR;
364.     }
366.     acm->readSize = acm->dataInPipe->maxPacketSize;
367.     acm->writeSize = acm->dataOutPipe->maxPacketSize;
368.     acm->ctrlSize = acm->ctrPipe->maxPacketSize;
369.     acm->intSize = acm->intPipe->maxPacketSize;
371.     return HDF_SUCCESS;
373. ERROR:
374.     // 释放设备中所有的管道信息
375.     AcmFreePipes(acm);
376.     return HDF_FAILURE;
377. }
379. static void AcmFreeRequests(struct AcmDevice *acm)
380. {
381.     if (g_syncRequest != NULL) {
382.         UsbFreeRequest(g_syncRequest);
383.         g_syncRequest = NULL;
384.     }
385.     AcmFreeReadRequests(acm);
386.     AcmFreeNotifyReqeust(acm);
387.     AcmFreeWriteRequests(acm);
388.     AcmWriteBufFree(acm);
389. }
391. static int32_t AcmAllocRequests(const struct AcmDevice *acm)
392. {
393.     int32_t ret;
395.     if (AcmWriteBufAlloc(acm) < 0) {
396.         HDF_LOGE("%s: AcmWriteBufAlloc failed", __func__);
397.         return HDF_ERR_MALLOC_FAIL;
398.     }
400.     for (int32_t i = 0; i < ACM_NW; i++) {
401.         struct AcmWb *snd = (struct AcmWb *)&(acm->wb[i]);
402.         // 分配待发送的IO Request对象
403.         snd->request = UsbAllocRequest(
404.             InterfaceIdToHandle((struct AcmDevice *)acm, acm->dataOutPipe->interfaceId), 0, acm->writeSize);
405.         snd->instance = (struct AcmDevice *)acm;
406.         if (snd->request == NULL) {
407.             HDF_LOGE("%s:%d snd request fail", __func__, __LINE__);
408.             goto ERROR_ALLOC_WRITE_REQ;
409.         }
410.     }
412.     ret = AcmAllocNotifyRequest((struct AcmDevice *)acm); // 分配并填充中断IO Request对象
413.     if (ret != HDF_SUCCESS) {
414.         HDF_LOGE("%s:%d AcmAllocNotifyRequest fail", __func__, __LINE__);
415.         goto ERROR_ALLOC_INT_REQ;
416.     }
418.     ret = AcmAllocReadRequests((struct AcmDevice *)acm); // 分配并填充readReq IO Request对象
419.     if (ret) {
420.         HDF_LOGE("%s:%d AcmAllocReadRequests fail", __func__, __LINE__);
421.         goto ERROR_ALLOC_READ_REQ;
422.     }
424.     return HDF_SUCCESS;
426. ERROR_ALLOC_READ_REQ:
427.     AcmFreeNotifyReqeust((struct AcmDevice *)acm);
428. ERROR_ALLOC_INT_REQ:
429.     AcmFreeWriteRequests((struct AcmDevice *)acm);
430. ERROR_ALLOC_WRITE_REQ:
431.     AcmWriteBufFree((struct AcmDevice *)acm);
432.     return HDF_FAILURE;
433. }
435. static int32_t AcmInit(struct AcmDevice *acm)
436. {
437.     int32_t ret;
439.     if (acm->initFlag) {
440.         HDF_LOGE("%{public}s: initFlag is true", __func__);
441.         return HDF_SUCCESS;
442.     }
443.         // 初始化Host DDK
444.     ret = UsbInitHostSdk(NULL);
445.     if (ret != HDF_SUCCESS) {
446.         HDF_LOGE("%{public}s: UsbInitHostSdk failed", __func__);
447.         return HDF_ERR_IO;
448.     }
449.     acm->session = NULL;
450.         // 根据acm->interfaceIndex[i]分别获取UsbInterface接口对象
451.     ret = AcmClaimInterfaces(acm);
452.     if (ret != HDF_SUCCESS) {
453.         HDF_LOGE("%{public}s: AcmClaimInterfaces failed", __func__);
454.         goto ERROR_CLAIM_INTERFACES;
455.     }
456.     // 根据acm->iface[i]分别打开UsbInterface接口对象
457.     ret = AcmOpenInterfaces(acm);
458.     if (ret != HDF_SUCCESS) {
459.         HDF_LOGE("%{public}s: AcmOpenInterfaces failed", __func__);
460.         goto ERROR_OPEN_INTERFACES;
461.     }
462.     // 获取管道信息的指针
463.     ret = AcmGetPipes(acm);
464.     if (ret != HDF_SUCCESS) {
465.         HDF_LOGE("%{public}s: AcmGetPipes failed", __func__);
466.         goto ERROR_GET_PIPES;
467.     }
469.     ret = AcmAllocRequests(acm);
470.     if (ret != HDF_SUCCESS) {
471.         HDF_LOGE("%{public}s: AcmAllocRequests failed", __func__);
472.         goto ERROR_ALLOC_REQS;
473.     }
475.     acm->lineCoding.dwDTERate = CPU_TO_LE32(DATARATE);
476.     acm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
477.     acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
478.     acm->lineCoding.bDataBits = DATA_BITS_LENGTH;
479.     acm->initFlag = true;
481.     return HDF_SUCCESS;
483. ERROR_ALLOC_REQS:
484.     AcmFreePipes(acm);
485. ERROR_GET_PIPES:
486.     // 关闭所有UsbInterface接口对象
487.     AcmCloseInterfaces(acm);
488. ERROR_OPEN_INTERFACES:
489.     // 释放所有UsbInterface接口对象
490.     AcmReleaseInterfaces(acm);
491. ERROR_CLAIM_INTERFACES:
492.     // 在主机端退出USB DDK，acm->session代表指向会话上下文的指针
493.     UsbExitHostSdk(acm->session);
494.     acm->session = NULL;
495.     return ret;
496. }
498. static void AcmRelease(struct AcmDevice *acm)
499. {
500.     if (!(acm->initFlag)) {
501.         HDF_LOGE("%s:%d: initFlag is false", __func__, __LINE__);
502.         return;
503.     }
505.     AcmCloseInterfaces(acm);
506.     AcmReleaseInterfaces(acm);
507.     AcmFreeRequests(acm);
508.     AcmFreePipes(acm);
509.     // 在主机端退出USB DDK
510.     UsbExitHostSdk(acm->session);
511.     acm->session = NULL;
513.     acm->initFlag = false;
514. }
516. static int32_t UsbSerialDriverInit(struct HdfDeviceObject *device)
517. {
518.     int32_t ret;
519.     struct AcmDevice *acm = NULL;
521.     if (device == NULL) {
522.         HDF_LOGE("%s: device is null", __func__);
523.         return HDF_ERR_INVALID_OBJECT;
524.     }
525.     acm = (struct AcmDevice *)device->service;
526.     // 初始化互斥锁，&acm->readLock表示指向互斥量的指针
527.     if (acm == NULL) {
528.         return HDF_ERR_INVALID_OBJECT;
529.     }
530.     OsalMutexInit(&acm->readLock);
531.     OsalMutexInit(&acm->writeLock);
532.     HDF_LOGD("%s:%d busNum = %d,devAddr = %d", __func__, __LINE__, acm->busNum, acm->devAddr);
533.     // 给USB串口设备信息开辟空间并赋值
534.     ret = UsbSerialDeviceAlloc(acm);
535.     if (ret != HDF_SUCCESS) {
536.         HDF_LOGE("%s: Serial Device alloc failed", __func__);
537.     }
539.     acm->initFlag = false;
540.     g_acmReleaseFlag = false;
542.     HDF_LOGD("%s:%d init ok!", __func__, __LINE__);
544.     return ret;
545. }
547. static void UsbSerialDriverRelease(struct HdfDeviceObject *device)
548. {
549.     struct AcmDevice *acm = NULL;
551.     if (device == NULL) {
552.         HDF_LOGE("%s: device is null", __func__);
553.         return;
554.     }
555.     acm = (struct AcmDevice *)device->service;
556.     if (acm == NULL) {
557.         HDF_LOGE("%s: acm is null", __func__);
558.         return;
559.     }
561.     g_acmReleaseFlag = true;
563.     if (acm->initFlag) {
564.         HDF_LOGE("%s:%d AcmRelease", __func__, __LINE__);
565.         AcmRelease(acm);
566.     }
567.     // 释放usb串口设备信息
568.     UsbSeriaDevicelFree(acm);
569.     // 释放互斥锁
570.     OsalMutexDestroy(&acm->writeLock);
571.     OsalMutexDestroy(&acm->readLock);
572.     OsalMutexDestroy(&acm->lock);
573.     OsalMemFree(acm);
574.     acm = NULL;
575.     HDF_LOGD("%s:%d exit", __func__, __LINE__);
576. }
577. // 驱动的Bind、Init、及Release操作
578. struct HdfDriverEntry g_usbSerialDriverEntry = {
579.     .moduleVersion = 1,
580.     .moduleName = "usbhost_acm", // 驱动模块名称，必须与hcs文件中配置的名称一致
581.     .Bind = UsbSerialDriverBind,
582.     .Init = UsbSerialDriverInit,
583.     .Release = UsbSerialDriverRelease,
584. };
585. HDF_INIT(g_usbSerialDriverEntry); // 驱动入口

复制代码

Host RAW API驱动开辟

1. root {
2.     module = "usb_pnp_device";
3.     usb_pnp_config {
4.         match_attr = "usb_pnp_match";
5.         usb_pnp_device_id = "UsbPnpDeviceId";
6.         UsbPnpDeviceId {
7.             idTableList = [
8.                 "host_acm_rawapi_table"
9.             ];
10.             host_acm_rawapi_table {    // 驱动配置匹配表信息
11.                 // 驱动模块名，该字段的值必须和驱动入口结构的moduleName一致
12.                 moduleName = "usbhost_acm_rawapi";
13.                 // 驱动对外发布服务的名称，必须唯一
14.                 serviceName = "usbhost_acm_rawapi_service";
15.                 // 驱动私有数据匹配关键字
16.                 deviceMatchAttr = "usbhost_acm_rawapi_matchAttr";
17.                 // 从该字段开始（包含该字段）之后数据长度，以byte为单位
18.                 length = 21;
19.                 // USB驱动匹配规则vendorId+productId+interfaceSubClass+interfaceProtocol+interfaceNumber
20.                 matchFlag = 0x0303;
21.                 // 厂商编号
22.                 vendorId = 0x12D1;
23.                 // 产品编号
24.                 productId = 0x5000;
25.                 // 设备出厂编号，低16位
26.                 bcdDeviceLow = 0x0000;
27.                 // 设备出厂编号，高16位
28.                 bcdDeviceHigh = 0x0000;
29.                 // USB分配的设备类代码
30.                 deviceClass = 0;
31.                 // USB分配的子类代码
32.                 deviceSubClass = 0;
33.                 // USB分配的设备协议代码
34.                 deviceProtocol = 0;
35.                 // 接口类型，根据实际需要可填写多个
36.                 interfaceClass = [0];
37.                 // 接口子类型，根据实际需要可填写多个
38.                 interfaceSubClass = [2, 0];
39.                 // 接口所遵循的协议，根据实际需要可填写多个
40.                 interfaceProtocol = [1, 2];
41.                 // 接口的编号，根据实际需要可填写多个
42.                 interfaceNumber = [2, 3];
43.             }
44.         }
45.     }
46. }

复制代码

1. #include <unistd.h>
3. #include "hdf_base.h"
4. #include "hdf_log.h"
5. #include "hdf_usb_pnp_manage.h"
6. #include "osal_mem.h"
7. #include "osal_time.h"
8. #include "securec.h"
9. #include "usb_serial_rawapi.h"
11. #define HDF_LOG_TAG                   USB_HOST_ACM_RAW_API
12. #define USB_CTRL_REQ_SIZE             64
13. #define USB_IO_THREAD_STACK_SIZE      8192
14. #define USB_RAW_IO_SLEEP_MS_TIME      100
15. #define USB_RAW_IO_STOP_WAIT_MAX_TIME 3
17. static struct UsbRawRequest *g_syncRequest = NULL;
18. static UsbRawIoProcessStatusType g_stopIoStatus = USB_RAW_IO_PROCESS_RUNNING;
19. struct OsalMutex g_stopIoLock;
20. static bool g_rawAcmReleaseFlag = false;
21. ...
22. static int32_t UsbGetConfigDescriptor(UsbRawHandle *devHandle, struct UsbRawConfigDescriptor **config)
23. {
24.     UsbRawDevice *dev = NULL;
25.     int32_t activeConfig;
26.     int32_t ret;
28.     if (devHandle == NULL) {
29.         HDF_LOGE("%s:%d devHandle is null", __func__, __LINE__);
30.         return HDF_ERR_INVALID_PARAM;
31.     }
32.     // 获取主用设备配置
33.     ret = UsbRawGetConfiguration(devHandle, &activeConfig);
34.     if (ret) {
35.         HDF_LOGE("%s:%d UsbRawGetConfiguration failed, ret = %d", __func__, __LINE__, ret);
36.         return HDF_FAILURE;
37.     }
38.     HDF_LOGE("%s:%d activeConfig = %d", __func__, __LINE__, activeConfig);
39.     // 根据指定的设备句柄获取设备指针
40.     dev = UsbRawGetDevice(devHandle);
41.     if (dev == NULL) {
42.         HDF_LOGE("%s:%d UsbRawGetDevice failed", __func__, __LINE__);
43.         return HDF_FAILURE;
44.     }
45.     // 根据指定的设备ID获取设备配置描述符
46.     ret = UsbRawGetConfigDescriptor(dev, activeConfig, config);
47.     if (ret) {
48.         HDF_LOGE("UsbRawGetConfigDescriptor failed, ret = %d\n", ret);
49.         return HDF_FAILURE;
50.     }
52.     return HDF_SUCCESS;
53. }
54. ...
55.     static int32_t UsbAllocWriteRequests(struct AcmDevice *acm)
56. {
57.     int32_t i;
59.     for (i = 0; i < ACM_NW; i++) {
60.         struct AcmWb *snd = &acm->wb[i];
61.         // 分配一个具有指定数目的同步传输分组描述符的传输请求
62.         snd->request = UsbRawAllocRequest(acm->devHandle, 0, acm->dataOutEp->maxPacketSize);
63.         snd->instance = acm;
64.         if (snd->request == NULL) {
65.             HDF_LOGE("%s: UsbRawAllocRequest failed", __func__);
66.             return HDF_ERR_MALLOC_FAIL;
67.         }
68.     }
70.     return HDF_SUCCESS;
71. }
72. ...
73. /* HdfDriverEntry implementations */
74. static int32_t UsbSerialDriverBind(struct HdfDeviceObject *device)
75. {
76.     struct AcmDevice *acm = NULL;
77.     struct UsbPnpNotifyServiceInfo *info = NULL;
78.     errno_t err;
80.     if (device == NULL) {
81.         HDF_LOGE("%s: device is null", __func__);
82.         return HDF_ERR_INVALID_OBJECT;
83.     }
85.     acm = (struct AcmDevice *)OsalMemCalloc(sizeof(*acm));
86.     if (acm == NULL) {
87.         HDF_LOGE("%s: Alloc usb serial device failed", __func__);
88.         return HDF_FAILURE;
89.     }
90.     if (OsalMutexInit(&acm->lock) != HDF_SUCCESS) {
91.         HDF_LOGE("%s:%d OsalMutexInit fail", __func__, __LINE__);
92.         goto ERROR;
93.     }
95.     info = (struct UsbPnpNotifyServiceInfo *)device->priv;
96.     if (info != NULL) {
97.         acm->busNum = (uint8_t)info->busNum;
98.         acm->devAddr = (uint8_t)info->devNum;
99.         acm->interfaceCnt = info->interfaceLength;
100.         err = memcpy_s((void *)(acm->interfaceIndex), USB_MAX_INTERFACES, (const void *)info->interfaceNumber,
101.             info->interfaceLength);
102.         if (err != EOK) {
103.             HDF_LOGE("%s:%d memcpy_s failed err=%d", __func__, __LINE__, err);
104.             goto LOCK_ERROR;
105.         }
106.     } else {
107.         HDF_LOGE("%s:%d info is NULL!", __func__, __LINE__);
108.         goto LOCK_ERROR;
109.     }
111.     device->service = &(acm->service);
112.     device->service->Dispatch = UsbSerialDeviceDispatch;
113.     acm->device = device;
114.     HDF_LOGD("UsbSerialDriverBind=========================OK");
115.     return HDF_SUCCESS;
117. LOCK_ERROR:
118.     if (OsalMutexDestroy(&acm->lock)) {
119.         HDF_LOGE("%s:%d OsalMutexDestroy fail", __func__, __LINE__);
120.     }
121. ERROR:
122.     OsalMemFree(acm);
123.     acm = NULL;
124.     return HDF_FAILURE;
125. }
126. ...
127. static int32_t UsbAllocReadRequests(struct AcmDevice *acm)
128. {
129.     struct UsbRawFillRequestData reqData;
130.     uint32_t size = acm->dataInEp->maxPacketSize;
132.     for (int32_t i = 0; i < ACM_NR; i++) {
133.         // 分配一个具有指定数目的同步传输分组描述符的传输请求
134.         acm->readReq[i] = UsbRawAllocRequest(acm->devHandle, 0, size);
135.         if (!acm->readReq[i]) {
136.             HDF_LOGE("readReq request failed\n");
137.             return HDF_ERR_MALLOC_FAIL;
138.         }
140.         reqData.endPoint = acm->dataInEp->addr;
141.         reqData.numIsoPackets = 0;
142.         reqData.callback = AcmReadBulkCallback;
143.         reqData.userData = (void *)acm;
144.         reqData.timeout = USB_CTRL_SET_TIMEOUT;
145.         reqData.length = size;
146.         // 在批量传输请求中填写所需信息
147.         int32_t ret = UsbRawFillBulkRequest(acm->readReq[i], acm->devHandle, &reqData);
148.         if (ret != HDF_SUCCESS) {
149.             HDF_LOGE("%s: FillBulkRequest failed, ret=%d\n", __func__, ret);
150.             return HDF_FAILURE;
151.         }
152.     }
154.     return HDF_SUCCESS;
155. }
156. ...
157. static int32_t UsbAllocNotifyRequest(struct AcmDevice *acm)
158. {
159.     struct UsbRawFillRequestData fillRequestData;
160.     uint32_t size = acm->notifyEp->maxPacketSize;
161.     int32_t ret;
162.     // 分配一个具有指定数目的同步传输分组描述符的传输请求
163.     acm->notifyReq = UsbRawAllocRequest(acm->devHandle, 0, size);
164.     if (!acm->notifyReq) {
165.         HDF_LOGE("notifyReq request fail\n");
166.         return HDF_ERR_MALLOC_FAIL;
167.     }
169.     fillRequestData.endPoint = acm->notifyEp->addr;
170.     fillRequestData.length = size;
171.     fillRequestData.numIsoPackets = 0;
172.     fillRequestData.callback = AcmNotifyReqCallback;
173.     fillRequestData.userData = (void *)acm;
174.     fillRequestData.timeout = USB_CTRL_SET_TIMEOUT;
175.     // 在中断传输请求中填充所需的信息
176.     ret = UsbRawFillInterruptRequest(acm->notifyReq, acm->devHandle, &fillRequestData);
177.     if (ret) {
178.         HDF_LOGE("%s: FillInterruptRequest failed, ret=%d", __func__, ret);
179.         return HDF_FAILURE;
180.     }
182.     return HDF_SUCCESS;
183. }
184. ...
185. static int32_t UsbSerialInit(struct AcmDevice *acm)
186. {
187.     struct UsbSession *session = NULL;
188.     UsbRawHandle *devHandle = NULL;
189.     int32_t ret;
191.     if (acm->initFlag) {
192.         HDF_LOGE("%s:%d: initFlag is true", __func__, __LINE__);
193.         return HDF_SUCCESS;
194.     }
195.     // 以专家模式初始化USB DDK
196.     ret = UsbRawInit(NULL);
197.     if (ret) {
198.         HDF_LOGE("%s:%d UsbRawInit failed", __func__, __LINE__);
199.         return HDF_ERR_IO;
200.     }
201.     acm->session = session;
202.     // 打开一个USB设备对象
203.     devHandle = UsbRawOpenDevice(session, acm->busNum, acm->devAddr);
204.     if (devHandle == NULL) {
205.         HDF_LOGE("%s:%d UsbRawOpenDevice failed", __func__, __LINE__);
206.         ret = HDF_FAILURE;
207.         goto ERR_OPEN_DEVICE;
208.     }
209.     acm->devHandle = devHandle;
210.     // 获取主用设备配置、设备指针及配置描述符
211.     ret = UsbGetConfigDescriptor(devHandle, &acm->config);
212.     if (ret) {
213.         HDF_LOGE("%s:%d UsbGetConfigDescriptor failed", __func__, __LINE__);
214.         ret = HDF_FAILURE;
215.         goto ERR_GET_DESC;
216.     }
217.     ret = UsbParseConfigDescriptor(acm, acm->config);
218.     if (ret != HDF_SUCCESS) {
219.         HDF_LOGE("%s:%d UsbParseConfigDescriptor failed", __func__, __LINE__);
220.         ret = HDF_FAILURE;
221.         goto ERR_PARSE_DESC;
222.     }
224.     ret = AcmWriteBufAlloc(acm);
225.     if (ret < 0) {
226.         HDF_LOGE("%s:%d AcmWriteBufAlloc failed", __func__, __LINE__);
227.         ret = HDF_FAILURE;
228.         goto ERR_ALLOC_WRITE_BUF;
229.     }
230.     ret = UsbAllocWriteRequests(acm);
231.     if (ret < 0) {
232.         HDF_LOGE("%s:%d UsbAllocWriteRequests failed", __func__, __LINE__);
233.         ret = HDF_FAILURE;
234.         goto ERR_ALLOC_WRITE_REQS;
235.     }
236.     ret = UsbAllocNotifyRequest(acm);
237.     if (ret) {
238.         HDF_LOGE("%s:%d UsbAllocNotifyRequests failed", __func__, __LINE__);
239.         goto ERR_ALLOC_NOTIFY_REQ;
240.     }
241.     ret = UsbAllocReadRequests(acm);
242.     if (ret) {
243.         HDF_LOGE("%s:%d UsbAllocReadRequests failed", __func__, __LINE__);
244.         goto ERR_ALLOC_READ_REQS;
245.     }
246.     ret = UsbStartIo(acm);
247.     if (ret) {
248.         HDF_LOGE("%s:%d UsbAllocReadRequests failed", __func__, __LINE__);
249.         goto ERR_START_IO;
250.     }
252.     acm->lineCoding.dwDTERate = CPU_TO_LE32(DATARATE);
253.     acm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS;
254.     acm->lineCoding.bParityType = USB_CDC_NO_PARITY;
255.     acm->lineCoding.bDataBits = DATA_BITS_LENGTH;
257.     ret = UsbRawSubmitRequest(acm->notifyReq);
258.     if (ret) {
259.         HDF_LOGE("%s:%d UsbRawSubmitRequest failed", __func__, __LINE__);
260.         goto ERR_SUBMIT_REQ;
261.     }
263.     acm->initFlag = true;
265.     HDF_LOGD("%s:%d=========================OK", __func__, __LINE__);
267.     return HDF_SUCCESS;
269. ERR_SUBMIT_REQ:
270.     UsbStopIo(acm); // 停止IO线程并释放所有资源
271. ERR_START_IO:
272.     UsbFreeReadRequests(acm);
273. ERR_ALLOC_READ_REQS:
274.     UsbFreeNotifyReqeust(acm);
275. ERR_ALLOC_NOTIFY_REQ:
276.     UsbFreeWriteRequests(acm);
277. ERR_ALLOC_WRITE_REQS:
278.     AcmWriteBufFree(acm);
279. ERR_ALLOC_WRITE_BUF:
280.     UsbReleaseInterfaces(acm);
281. ERR_PARSE_DESC:
282.     UsbRawFreeConfigDescriptor(acm->config);
283.     acm->config = NULL;
284. ERR_GET_DESC:
285.     (void)UsbRawCloseDevice(devHandle); // 关闭USB设备对象
286. ERR_OPEN_DEVICE:
287.     UsbRawExit(acm->session); // 退出USB DDK的专家模式
289.     return ret;
290. }
291. ...
292. static void UsbSerialRelease(struct AcmDevice *acm)
293. {
294.     if (!(acm->initFlag)) {
295.         HDF_LOGE("%s:%d: initFlag is false", __func__, __LINE__);
296.         return;
297.     }
299.     /* stop io thread and release all resources */
300.     UsbStopIo(acm);
301.     if (g_syncRequest != NULL) {
302.         UsbRawFreeRequest(g_syncRequest);
303.         g_syncRequest = NULL;
304.     }
305.     UsbFreeReadRequests(acm);
306.     UsbFreeNotifyReqeust(acm);
307.     UsbFreeWriteRequests(acm);
308.     AcmWriteBufFree(acm);
309.     UsbReleaseInterfaces(acm);
310.     (void)UsbRawCloseDevice(acm->devHandle);
311.     UsbRawFreeConfigDescriptor(acm->config);
312.     acm->config = NULL;
313.     // 退出USB DDK的专家模式
314.     UsbRawExit(acm->session);
316.     acm->initFlag = false;
317. }
319. static int32_t UsbSerialDriverInit(struct HdfDeviceObject *device)
320. {
321.     struct AcmDevice *acm = NULL;
322.     int32_t ret;
324.     if (device == NULL) {
325.         HDF_LOGE("%s:%d device is null", __func__, __LINE__);
326.         return HDF_ERR_INVALID_OBJECT;
327.     }
328.     acm = (struct AcmDevice *)device->service;
329.     if (acm == NULL) {
330.         return HDF_ERR_INVALID_OBJECT;
331.     }
332.     OsalMutexInit(&acm->readLock);
333.     OsalMutexInit(&acm->writeLock);
334.         // 设备申请连续的内存
335.     ret = UsbSerialDeviceAlloc(acm);
336.     if (ret != HDF_SUCCESS) {
337.         HDF_LOGE("%s:%d UsbSerialDeviceAlloc failed", __func__, __LINE__);
338.     }
340.     acm->initFlag = false;
341.     g_rawAcmReleaseFlag = false;
342.     HDF_LOGD("%s:%d init ok!", __func__, __LINE__);
343.     return ret;
344. }
346. static void UsbSerialDriverRelease(struct HdfDeviceObject *device)
347. {
348.     struct AcmDevice *acm = NULL;
349.     if (device == NULL) {
350.         HDF_LOGE("%s: device is null", __func__);
351.         return;
352.     }
354.     acm = (struct AcmDevice *)device->service;
355.     if (acm == NULL) {
356.         HDF_LOGE("%s: acm is null", __func__);
357.         return;
358.     }
360.     g_rawAcmReleaseFlag = true;
362.     if (acm->initFlag) {
363.         HDF_LOGE("%s:%d UsbSerialRelease", __func__, __LINE__);
364.         UsbSerialRelease(acm);
365.     }
366.     UsbSeriaDevicelFree(acm);
367.     OsalMutexDestroy(&acm->writeLock);
368.     OsalMutexDestroy(&acm->readLock);
369.     OsalMutexDestroy(&acm->lock);
370.     OsalMemFree(acm);
371.     acm = NULL;
372.     HDF_LOGD("%s:%d exit", __func__, __LINE__);
373. }
375. struct HdfDriverEntry g_usbSerialRawDriverEntry = {
376.     .moduleVersion = 1,
377.     .moduleName = "usbhost_acm_rawapi", // 驱动模块名称，必须与hcs文件中配置的名称一致
378.     .Bind = UsbSerialDriverBind,
379.     .Init = UsbSerialDriverInit,
380.     .Release = UsbSerialDriverRelease,
381. };
382. HDF_INIT(g_usbSerialRawDriverEntry);

复制代码

Device DDK API驱动开辟

USB ACM设备焦点代码路径为drivers\peripheral\usb\gadget\function\acm\cdcacm.c。其使用示比方下所示，起首根据描述符创建立备，然后获取接口，打开接口，获取Pipe信息，接收Event事件，接着进行USB通信（读写等），设备卸载时候，关闭接口，停止Event接收，删除设备。

• 创建立备。
  
  1. static int32_t AcmCreateFuncDevice(struct UsbAcmDevice *acm, struct DeviceResourceIface *iface)
  2. {
  3.     int32_t ret;
  4.     struct UsbFnDevice *fnDev = NULL;
  5. // 读取hcs文件中的udc_name节点的字符串值
  6.     if (iface->GetString(acm->device->property, "udc_name", (const char **)&acm->udcName, UDC_NAME) != HDF_SUCCESS) {
  7.         HDF_LOGE("%s: read udc_name failed, use default", __func__);
  8.         return HDF_FAILURE;
  9.     }
  11.     fnDev = (struct UsbFnDevice *)UsbFnGetDevice(acm->udcName);
  12.     if (fnDev == NULL) {
  13.         HDF_LOGE("%s: create usb function device failed", __func__);
  14.         return HDF_FAILURE;
  15.     }
  16. // 解析acm每一个Iface
  17.     ret = AcmParseEachIface(acm, fnDev);
  18.     if (ret != HDF_SUCCESS) {
  19.         HDF_LOGE("%s: get pipes failed", __func__);
  20.         return HDF_FAILURE;
  21.     }
  23.     acm->fnDev = fnDev;
  24.     return HDF_SUCCESS;
  25. }

  复制代码
• 获取接口，打开接口，获取Pipe信息
  
  1. static int32_t AcmParseEachPipe(struct UsbAcmDevice *acm, struct UsbAcmInterface *iface)
  2. {
  3.     struct UsbFnInterface *fnIface = iface->fn;
  4.     for (uint32_t i = 0; i < fnIface->info.numPipes; i++) {
  5.         struct UsbFnPipeInfo pipeInfo;
  6.         // pipeInfo清除缓存区内容
  7.         (void)memset_s(&pipeInfo, sizeof(pipeInfo), 0, sizeof(pipeInfo));
  8.         /* 获取pipe信息 */
  9.         int32_t ret = UsbFnGetInterfacePipeInfo(fnIface, i, &pipeInfo);
  10.         if (ret != HDF_SUCCESS) {
  11.             HDF_LOGE("%s: get pipe info error", __func__);
  12.             return ret;
  13.         }
  14.         // PIPE的中断和管脚
  15.         switch (pipeInfo.type) {
  16.             case USB_PIPE_TYPE_INTERRUPT:
  17.                 acm->notifyPipe.id = pipeInfo.id;
  18.                 acm->notifyPipe.maxPacketSize = pipeInfo.maxPacketSize;
  19.                 acm->ctrlIface = *iface;
  20.                 break;
  21.             case USB_PIPE_TYPE_BULK:
  22.                 if (pipeInfo.dir == USB_PIPE_DIRECTION_IN) {
  23.                     acm->dataInPipe.id = pipeInfo.id;
  24.                     acm->dataInPipe.maxPacketSize = pipeInfo.maxPacketSize;
  25.                     acm->dataIface = *iface;
  26.                 } else {
  27.                     acm->dataOutPipe.id = pipeInfo.id;
  28.                     acm->dataOutPipe.maxPacketSize = pipeInfo.maxPacketSize;
  29.                 }
  30.                 break;
  31.             default:
  32.                 HDF_LOGE("%s: pipe type %d don't support", __func__, pipeInfo.type);
  33.                 break;
  34.         }
  35.     }
  37.     return HDF_SUCCESS;
  38. }
  39. /* 获取接口，打开接口获取handle */
  40. static int32_t AcmParseEachIface(struct UsbAcmDevice *acm, struct UsbFnDevice *fnDev)
  41. {
  42.     struct UsbFnInterface *fnIface = NULL;
  43.     uint32_t i;
  44.     if (fnDev == NULL) {
  45.         return HDF_FAILURE;
  46.     }
  47.     for (i = 0; i < fnDev->numInterfaces; i++) {
  48.         fnIface = (struct UsbFnInterface *)UsbFnGetInterface(fnDev, i);
  49.         if (fnIface == NULL) {
  50.             HDF_LOGE("%s: get interface failed", __func__);
  51.             return HDF_FAILURE;
  52.         }
  54.         if (fnIface->info.subclass == USB_DDK_CDC_SUBCLASS_ACM) {
  55.             (void)AcmParseAcmIface(acm, fnIface);
  56.             fnIface = (struct UsbFnInterface *)UsbFnGetInterface(fnDev, i + 1);
  57.             if (fnIface == NULL) {
  58.                 HDF_LOGE("%s: get interface failed", __func__);
  59.                 return HDF_FAILURE;
  60.             }
  61.             (void)AcmParseAcmIface(acm, fnIface);
  62.             return HDF_SUCCESS;
  63.         }
  64.     }
  65.     return HDF_FAILURE;
  66. }

  复制代码
• 接收Event事件（EP0控制传输）
  
  1. static int32_t AcmAllocCtrlRequests(struct UsbAcmDevice *acm, int32_t num)
  2. {
  3.     struct DListHead *head = &acm->ctrlPool;
  4.     struct UsbFnRequest *req = NULL;
  5.     struct CtrlInfo *ctrlInfo = NULL;
  6.     int32_t i;
  8.     DListHeadInit(&acm->ctrlPool);
  9.     acm->ctrlReqNum = 0;
  11.     for (i = 0; i < num; i++) {
  12.         // 申请内存
  13.         ctrlInfo = (struct CtrlInfo *)OsalMemCalloc(sizeof(*ctrlInfo));
  14.         if (ctrlInfo == NULL) {
  15.             HDF_LOGE("%s: Allocate ctrlInfo failed", __func__);
  16.             goto OUT;
  17.         }
  18.         ctrlInfo->acm = acm;
  19.         req = UsbFnAllocCtrlRequest(
  20.             acm->ctrlIface.handle, sizeof(struct UsbCdcLineCoding) + sizeof(struct UsbCdcLineCoding));
  21.         if (req == NULL) {
  22.             goto OUT;
  23.         }
  24.         req->complete = AcmCtrlComplete;
  25.         req->context = ctrlInfo;
  26.         DListInsertTail(&req->list, head);
  27.         acm->ctrlReqNum++;
  28.     }
  29.     return HDF_SUCCESS;
  31. OUT:
  32.     return DListIsEmpty(head) ? HDF_FAILURE : HDF_SUCCESS;
  33. }

  复制代码
• 进行USB通信（读写等）
  
  1. static int32_t AcmSendNotifyRequest(
  2.     struct UsbAcmDevice *acm, uint8_t type, uint16_t value, const void *data, uint32_t length)
  3. {
  4.     struct UsbFnRequest *req = acm->notifyReq;
  5.     struct UsbCdcNotification *notify = NULL;
  6.     int32_t ret;
  8.     if (req == NULL || req->buf == NULL) {
  9.         HDF_LOGE("%s: req is null", __func__);
  10.         return HDF_FAILURE;
  11.     }
  13.     acm->notifyReq = NULL;
  14.     acm->pending = false;
  15.     req->length = sizeof(*notify) + length;
  17.     notify = (struct UsbCdcNotification *)req->buf;
  18.     notify->bmRequestType = USB_DDK_DIR_IN | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE;
  19.     notify->bNotificationType = type;
  20.     notify->wValue = CPU_TO_LE16(value);
  21.     notify->wIndex = CPU_TO_LE16(acm->ctrlIface.fn->info.index);
  22.     notify->wLength = CPU_TO_LE16(length);
  23.     ret = memcpy_s((void *)(notify + 1), length, data, length);
  24.     if (ret != EOK) {
  25.         HDF_LOGE("%s: memcpy_s failed", __func__);
  26.         return HDF_FAILURE;
  27.     }
  29.     ret = UsbFnSubmitRequestAsync(req);
  30.     if (ret != HDF_SUCCESS) {
  31.         HDF_LOGE("%s: send notify request failed", __func__);
  32.         acm->notifyReq = req;
  33.     }
  35.     return ret;
  36. }

  复制代码
• 关闭接口，停止Event接收，删除设备
  
  1. static int32_t AcmReleaseFuncDevice(struct UsbAcmDevice *acm)
  2. {
  3.     int32_t ret;
  4.     /* 关闭接口 */
  5.     (void)UsbFnInterfaceClose(acm->ctrlIface.handle);
  6.     (void)UsbFnInterfaceClose(acm->dataIface.handle);
  7.     /* 停止接收Event EP0控制传输 */
  8.     (void)UsbFnInterfaceStopRecvEvent(acm->ctrlIface.fn);
  9.     /* 删除设备 */
  10.     ret = UsbFnDeviceRemove(acm->fnDev);
  11.     if (ret != HDF_SUCCESS) {
  12.         HDF_LOGE("%s: remove usb function device failed", __func__);
  13.     }
  14.     return ret;
  15. }
  16. static int32_t AcmReleaseFuncDevice(struct UsbAcmDevice *acm)
  17. {
  18.     int32_t ret = HDF_SUCCESS;
  19.     if (acm->fnDev == NULL) {
  20.         HDF_LOGE("%s: fnDev is null", __func__);
  21.         return HDF_FAILURE;
  22.     }
  23.     //释放通知请求
  24.     AcmFreeCtrlRequests(acm);
  25.     AcmFreeNotifyRequest(acm);
  26.      /* 停止接收Event EP0控制传输 */
  27.     (void)UsbFnCloseInterface(acm->ctrlIface.handle);
  28.     (void)UsbFnCloseInterface(acm->dataIface.handle);
  29.     (void)UsbFnStopRecvInterfaceEvent(acm->ctrlIface.fn);
  30.     return ret;
  31. }

  复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。