From e48d3150f207a896ad1fe7f5c686825221b1a81e Mon Sep 17 00:00:00 2001 From: zianed Date: Thu, 5 Aug 2021 09:16:26 +0800 Subject: [PATCH] add usb liteos Signed-off-by: zianed --- core/shared/include/hdf_device_info.h | 1 + model/usb/include/usb_ddk_pnp_loader.h | 84 + model/usb/src/usb_ddk_pnp_loader.c | 1023 +++++++++ test/unittest/common/hdf_main_test.c | 11 +- test/unittest/common/hdf_main_test.h | 2 + test/unittest/include/hdf_uhdf_test.h | 2 + .../include/hdf_usb_device_test.h | 21 +- .../include/usb_device_lite_cdcacm_test.h | 33 +- .../{ => device}/src/hdf_usb_device_test.c | 18 +- .../src/usb_device_lite_cdcacm_test.c | 67 +- .../src/usb_device_lite_sdk_if_test.c | 1379 ++++-------- .../device/src/usb_device_lite_sdk_io_test.c | 634 ++++++ .../usb/host/include/hdf_usb_entry_test.h | 15 + .../model/usb/host/include/usb_raw_test.h | 510 +++++ .../model/usb/host/include/usb_test.h | 236 ++ .../model/usb/host/src/hdf_usb_entry_test.c | 29 + test/unittest/model/usb/host/src/usb_raw_io.c | 1091 +++++++++ .../model/usb/host/src/usb_raw_test.c | 1752 +++++++++++++++ test/unittest/model/usb/host/src/usb_test.c | 1986 +++++++++++++++++ 19 files changed, 7971 insertions(+), 923 deletions(-) create mode 100644 model/usb/include/usb_ddk_pnp_loader.h create mode 100644 model/usb/src/usb_ddk_pnp_loader.c rename test/unittest/model/usb/{ => device}/include/hdf_usb_device_test.h (91%) rename test/unittest/model/usb/{ => device}/include/usb_device_lite_cdcacm_test.h (91%) rename test/unittest/model/usb/{ => device}/src/hdf_usb_device_test.c (92%) rename test/unittest/model/usb/{ => device}/src/usb_device_lite_cdcacm_test.c (91%) rename test/unittest/model/usb/{ => device}/src/usb_device_lite_sdk_if_test.c (73%) create mode 100644 test/unittest/model/usb/device/src/usb_device_lite_sdk_io_test.c create mode 100644 test/unittest/model/usb/host/include/hdf_usb_entry_test.h create mode 100644 test/unittest/model/usb/host/include/usb_raw_test.h create mode 100644 test/unittest/model/usb/host/include/usb_test.h create mode 100644 test/unittest/model/usb/host/src/hdf_usb_entry_test.c create mode 100644 test/unittest/model/usb/host/src/usb_raw_io.c create mode 100644 test/unittest/model/usb/host/src/usb_raw_test.c create mode 100644 test/unittest/model/usb/host/src/usb_test.c diff --git a/core/shared/include/hdf_device_info.h b/core/shared/include/hdf_device_info.h index aedf9c00b..8852e8306 100755 --- a/core/shared/include/hdf_device_info.h +++ b/core/shared/include/hdf_device_info.h @@ -43,6 +43,7 @@ struct HdfPrivateInfo { uint32_t length; const void *data; }; + struct HdfDeviceInfo *HdfDeviceInfoNewInstance(void); void HdfDeviceInfoConstruct(struct HdfDeviceInfo *deviceInfo); void HdfDeviceInfoFreeInstance(struct HdfDeviceInfo *deviceInfo); diff --git a/model/usb/include/usb_ddk_pnp_loader.h b/model/usb/include/usb_ddk_pnp_loader.h new file mode 100644 index 000000000..f7d3b49cf --- /dev/null +++ b/model/usb/include/usb_ddk_pnp_loader.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#ifndef USB_DDK_PNP_LOADER_H +#define USB_DDK_PNP_LOADER_H + +#include "devmgr_service_if.h" +#include "hdf_usb_pnp_manage.h" + +#define USB_PNP_NOTIFY_SERVICE_NAME "hdf_usb_pnp_notify_service" + +typedef enum { + USB_PNP_NORMAL_STATUS, + USB_PNP_ADD_STATUS, + USB_PNP_REMOVE_STATUS +} UsbPnpDriverStatus; + +struct UsbPnpMatchIdTable { + const char *moduleName; + const char *serviceName; + const char *deviceMatchAttr; + + int32_t interfaceClassLength; + int32_t interfaceClassMask; + int32_t interfaceSubClassLength; + int32_t interfaceSubClassMask; + int32_t interfaceProtocolLength; + int32_t interfaceProtocolMask; + int32_t interfaceLength; + int32_t interfaceMask; + + uint8_t pnpMatchFlag; + + uint8_t length; + + uint16_t matchFlag; + + uint16_t vendorId; + uint16_t productId; + + uint16_t bcdDeviceLow; + uint16_t bcdDeviceHigh; + + uint8_t deviceClass; + uint8_t deviceSubClass; + uint8_t deviceProtocol; + + uint8_t interfaceClass[USB_PNP_INFO_MAX_INTERFACES]; + uint8_t interfaceSubClass[USB_PNP_INFO_MAX_INTERFACES]; + uint8_t interfaceProtocol[USB_PNP_INFO_MAX_INTERFACES]; + + uint8_t interfaceNumber[USB_PNP_INFO_MAX_INTERFACES]; +}; + +struct UsbPnpDeviceListTable { + struct DListHead list; + const char *moduleName; + const char *serviceName; + const char *deviceMatchAttr; + UsbPnpDriverStatus status; + uint32_t usbDevAddr; + int32_t devNum; + int32_t busNum; + int32_t interfaceLength; + uint8_t interfaceNumber[USB_PNP_INFO_MAX_INTERFACES]; +}; + +struct UsbPnpRemoveInfo { + uint8_t removeType; + uint32_t usbDevAddr; + int32_t devNum; + int32_t busNum; + uint8_t interfaceNum; +}; + +int UsbDdkPnpLoaderEventReceived(void *priv, uint32_t id, struct HdfSBuf *data); +int UsbDdkPnpLoaderEventHandle(void); + +#endif /* USB_DDK_PNP_LOADER_H */ diff --git a/model/usb/src/usb_ddk_pnp_loader.c b/model/usb/src/usb_ddk_pnp_loader.c new file mode 100644 index 000000000..5582662fd --- /dev/null +++ b/model/usb/src/usb_ddk_pnp_loader.c @@ -0,0 +1,1023 @@ +/* + * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#include "usb_ddk_pnp_loader.h" +#include "devhost_service_clnt.h" +#include "device_resource_if.h" +#include "hcs_tree_if.h" +#include "hdf_attribute_manager.h" +#include "hdf_base.h" +#include "hdf_log.h" +#include "hdf_sbuf.h" +#include "osal_mem.h" +#include "osal_time.h" +#include "securec.h" +#include "usb_pnp_manager.h" + +#define HDF_LOG_TAG USB_DDK_PNP_LOADER + +#define USB_DDK_PNP_CLASS_VENDOR_SPEC 0xFF + +static struct DListHead g_usbPnpDeviceTableListHead; +static struct UsbPnpMatchIdTable **g_usbPnpMatchIdTable = NULL; + +static struct HdfSBuf *UsbDdkPnpLoaderBufCreate(const char *moduleName, + const char *serviceName, const char *deviceMatchAttr, struct UsbPnpNotifyServiceInfo serviceInfo) +{ + struct HdfSBuf *pnpData = NULL; + + pnpData = HdfSBufObtainDefaultSize(); + if (pnpData == NULL) { + HDF_LOGE("%{public}s: HdfSBufTypedObtain pnpData fail", __func__); + return NULL; + } + + if (!UsbPnpManagerWriteModuleName(pnpData, moduleName)) { + HDF_LOGE("%{public}s: write moduleName failed!", __func__); + goto out; + } + + if (!HdfSbufWriteString(pnpData, serviceName)) { + HDF_LOGE("%{public}s: write service name failed!", __func__); + goto out; + } + + if (!HdfSbufWriteString(pnpData, deviceMatchAttr)) { + HDF_LOGE("%{public}s: write deviceMatchAttr failed!", __func__); + goto out; + } + + if (!HdfSbufWriteBuffer(pnpData, (const void *)(&serviceInfo), serviceInfo.length)) { + HDF_LOGE("%{public}s: write privateData failed!", __func__); + goto out; + } + + return pnpData; + +out: + HdfSBufRecycle(pnpData); + + return NULL; +} + +static bool UsbDdkPnpLoaderMatchDevice(struct UsbPnpNotifyMatchInfoTable *dev, + const struct UsbPnpMatchIdTable *id) +{ + if ((id->matchFlag & USB_PNP_NOTIFY_MATCH_VENDOR) && + (id->vendorId != dev->deviceInfo.vendorId)) { + return false; + } + + if ((id->matchFlag & USB_PNP_NOTIFY_MATCH_PRODUCT) && + (id->productId != dev->deviceInfo.productId)) { + return false; + } + + if ((id->matchFlag & USB_PNP_NOTIFY_MATCH_DEV_LOW) && + (id->bcdDeviceLow > dev->deviceInfo.bcdDeviceLow)) { + return false; + } + + if ((id->matchFlag & USB_PNP_NOTIFY_MATCH_DEV_HIGH) && + (id->bcdDeviceHigh < dev->deviceInfo.bcdDeviceHigh)) { + return false; + } + + if ((id->matchFlag & USB_PNP_NOTIFY_MATCH_DEV_CLASS) && + (id->deviceClass != dev->deviceInfo.deviceClass)) { + return false; + } + + if ((id->matchFlag & USB_PNP_NOTIFY_MATCH_DEV_SUBCLASS) && + (id->deviceSubClass != dev->deviceInfo.deviceSubClass)) { + return false; + } + + if ((id->matchFlag & USB_PNP_NOTIFY_MATCH_DEV_PROTOCOL) && + (id->deviceProtocol != dev->deviceInfo.deviceProtocol)) { + return false; + } + + return true; +} + +static void UsbDdkPnpLoaderMatchHandle(struct UsbPnpNotifyMatchInfoTable *dev, + int8_t index, struct UsbPnpMatchIdTable *id, bool flag) +{ + if ((id->pnpMatchFlag == false) && (flag == true)) { + if (!(id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_CLASS)) { + id->interfaceClass[id->interfaceClassLength++] = dev->interfaceInfo[index].interfaceClass; + } + if (!(id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_SUBCLASS)) { + id->interfaceSubClass[id->interfaceSubClassLength++] = dev->interfaceInfo[index].interfaceSubClass; + } + if (!(id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_PROTOCOL)) { + id->interfaceProtocol[id->interfaceProtocolLength++] = dev->interfaceInfo[index].interfaceProtocol; + } + if (!(id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_NUMBER)) { + id->interfaceNumber[id->interfaceLength++] = dev->interfaceInfo[index].interfaceNumber; + } + } +} + +static bool UsbDdkPnpLoaderMatchFlag(struct UsbPnpNotifyMatchInfoTable *dev, + int8_t index, struct UsbPnpMatchIdTable *id, bool flag) +{ + int32_t i; + bool ret = true; + + if (id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_CLASS) { + for (i = 0; i < id->interfaceClassLength; i++) { + if (!((id->interfaceClassMask >> i) & 0x01)) { + break; + } + } + if (i < id->interfaceClassLength) { + ret = false; + goto out; + } + } + + if (id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_SUBCLASS) { + for (i = 0; i < id->interfaceSubClassLength; i++) { + if (!((id->interfaceSubClassMask >> i) & 0x01)) { + break; + } + } + if (i < id->interfaceSubClassLength) { + ret = false; + goto out; + } + } + + if (id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_PROTOCOL) { + for (i = 0; i < id->interfaceProtocolLength; i++) { + if (!((id->interfaceProtocolMask >> i) & 0x01)) { + break; + } + } + if (i < id->interfaceProtocolLength) { + ret = false; + goto out; + } + } + + if (id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_NUMBER) { + for (i = 0; i < id->interfaceLength; i++) { + if (!((id->interfaceMask >> i) & 0x01)) { + break; + } + } + if (i < id->interfaceLength) { + ret = false; + goto out; + } + } + + ret = true; + +out: + UsbDdkPnpLoaderMatchHandle(dev, index, id, flag); + + return ret; +} + +static bool UsbDdkPnpLoaderMatchInterface(struct UsbPnpNotifyMatchInfoTable *dev, + int8_t index, struct UsbPnpMatchIdTable *id) +{ + int32_t i; + bool maskFlag = true; + + if (id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_CLASS) { + for (i = 0; i < id->interfaceClassLength; i++) { + if (id->interfaceClass[i] == dev->interfaceInfo[index].interfaceClass) { + id->interfaceClassMask |= (1 << i); + break; + } + } + + if (i >= id->interfaceClassLength) { + maskFlag = false; + } + } + + if (id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_SUBCLASS) { + for (i = 0; i < id->interfaceSubClassLength; i++) { + if (id->interfaceSubClass[i] == dev->interfaceInfo[index].interfaceSubClass) { + id->interfaceSubClassMask |= (1 << i); + break; + } + } + + if (i >= id->interfaceSubClassLength) { + maskFlag = false; + } + } + + if (id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_PROTOCOL) { + for (i = 0; i < id->interfaceProtocolLength; i++) { + if (id->interfaceProtocol[i] == dev->interfaceInfo[index].interfaceProtocol) { + id->interfaceProtocolMask |= (1 << i); + break; + } + } + + if (i >= id->interfaceProtocolLength) { + maskFlag = false; + } + } + + if (id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_NUMBER) { + for (i = 0; i < id->interfaceLength; i++) { + if (id->interfaceNumber[i] == dev->interfaceInfo[index].interfaceNumber) { + id->interfaceMask |= (1 << i); + break; + } + } + + if (i >= id->interfaceLength) { + maskFlag = false; + } + } + + return maskFlag; +} + +static bool UsbDdkPnpLoaderMatchOneIdIntf(struct UsbPnpNotifyMatchInfoTable *dev, + int8_t index, struct UsbPnpMatchIdTable *id) +{ + bool maskFlag = true; + + if (dev->deviceInfo.deviceClass == USB_DDK_PNP_CLASS_VENDOR_SPEC && + !(id->matchFlag & USB_PNP_NOTIFY_MATCH_VENDOR) && + (id->matchFlag & (USB_PNP_NOTIFY_MATCH_INT_CLASS | USB_PNP_NOTIFY_MATCH_INT_SUBCLASS | + USB_PNP_NOTIFY_MATCH_INT_PROTOCOL | USB_PNP_NOTIFY_MATCH_INT_NUMBER))) { + return false; + } + + maskFlag = UsbDdkPnpLoaderMatchInterface(dev, index, id); + if (UsbDdkPnpLoaderMatchFlag(dev, index, id, maskFlag) != true) { + return false; + } + + if (id->pnpMatchFlag == false) { + id->pnpMatchFlag = true; + } else { + return false; + } + + return true; +} + +static int32_t UsbDdkPnpLoaderParseIdInfClass(const struct DeviceResourceNode *node, + struct DeviceResourceIface *devResIface, struct UsbPnpMatchIdTable *table) +{ + table->interfaceClassMask = 0; + table->interfaceClassLength = devResIface->GetElemNum(node, "interfaceClass"); + if (table->interfaceClassLength <= 0) { + HDF_LOGE("%{public}s: read interfaceClass length=%{public}d fail!", __func__, table->interfaceClassLength); + return HDF_FAILURE; + } + if (devResIface->GetUint8Array(node, "interfaceClass", table->interfaceClass, \ + table->interfaceClassLength, 0) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read interfaceClass fail!", __func__); + return HDF_FAILURE; + } + if (!(table->matchFlag & USB_PNP_NOTIFY_MATCH_INT_CLASS)) { + table->interfaceClassLength = 0; + } + + table->interfaceSubClassMask = 0; + table->interfaceSubClassLength = devResIface->GetElemNum(node, "interfaceSubClass"); + if (table->interfaceSubClassLength <= 0) { + HDF_LOGE("%{public}s: read interfaceSubClass length=%{public}d fail!", + __func__, table->interfaceSubClassLength); + return HDF_FAILURE; + } + if (devResIface->GetUint8Array(node, "interfaceSubClass", table->interfaceSubClass, \ + table->interfaceSubClassLength, 0) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read interfaceSubClass fail!", __func__); + return HDF_FAILURE; + } + if (!(table->matchFlag & USB_PNP_NOTIFY_MATCH_INT_SUBCLASS)) { + table->interfaceSubClassLength = 0; + } + + return HDF_SUCCESS; +} + + +static int32_t UsbDdkPnpLoaderParseIdInferface(const struct DeviceResourceNode *node, + struct DeviceResourceIface *devResIface, struct UsbPnpMatchIdTable *table) +{ + if (UsbDdkPnpLoaderParseIdInfClass(node, devResIface, table) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + table->interfaceProtocolMask = 0; + table->interfaceProtocolLength = devResIface->GetElemNum(node, "interfaceProtocol"); + if (table->interfaceProtocolLength <= 0) { + HDF_LOGE("%{public}s: read interfaceProtocol length=%{public}d fail!", + __func__, table->interfaceProtocolLength); + return HDF_FAILURE; + } + if (devResIface->GetUint8Array(node, "interfaceProtocol", table->interfaceProtocol, \ + table->interfaceProtocolLength, 0) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read interfaceProtocol fail!", __func__); + return HDF_FAILURE; + } + if (!(table->matchFlag & USB_PNP_NOTIFY_MATCH_INT_PROTOCOL)) { + table->interfaceProtocolLength = 0; + } + + table->interfaceMask = 0; + table->interfaceLength = devResIface->GetElemNum(node, "interfaceNumber"); + if (table->interfaceLength <= 0) { + HDF_LOGE("%{public}s: read interfaceNumber length=%{public}d fail!", __func__, table->interfaceLength); + return HDF_FAILURE; + } + if (devResIface->GetUint8Array(node, "interfaceNumber", table->interfaceNumber, \ + table->interfaceLength, 0) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read interfaceNumber fail!", __func__); + return HDF_FAILURE; + } + if (!(table->matchFlag & USB_PNP_NOTIFY_MATCH_INT_NUMBER)) { + table->interfaceLength = 0; + } + + return HDF_SUCCESS; +} + +static int32_t UsbDdkPnpLoaderParseIdDevice(const struct DeviceResourceNode *node, + struct DeviceResourceIface *devResIface, struct UsbPnpMatchIdTable *table) +{ + if (devResIface->GetUint16(node, "vendorId", &table->vendorId, 0) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read vendorId fail!", __func__); + return HDF_FAILURE; + } + + if (devResIface->GetUint16(node, "productId", &table->productId, 0) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read productId fail!", __func__); + return HDF_FAILURE; + } + + if (devResIface->GetUint16(node, "bcdDeviceLow", &table->bcdDeviceLow, 0) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read bcdDeviceLow fail!", __func__); + return HDF_FAILURE; + } + + if (devResIface->GetUint16(node, "bcdDeviceHigh", &table->bcdDeviceHigh, 0) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read bcdDeviceHigh fail!", __func__); + return HDF_FAILURE; + } + + if (devResIface->GetUint8(node, "deviceClass", &table->deviceClass, 0) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read deviceClass fail!", __func__); + return HDF_FAILURE; + } + + if (devResIface->GetUint8(node, "deviceSubClass", &table->deviceSubClass, 0) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read deviceSubClass fail!", __func__); + return HDF_FAILURE; + } + + if (devResIface->GetUint8(node, "deviceProtocol", &table->deviceProtocol, 0) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read deviceProtocol fail!", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t UsbDdkPnpLoaderParseIdTable(const struct DeviceResourceNode *node, + struct DeviceResourceIface *devResIface, struct UsbPnpMatchIdTable *table) +{ + if (node == NULL || table == NULL || devResIface == NULL) { + HDF_LOGE("%{public}s: node or table or devResIface is NULL!", __func__); + return HDF_FAILURE; + } + + if (devResIface->GetString(node, "moduleName", &table->moduleName, "") != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read moduleName fail!", __func__); + return HDF_FAILURE; + } + + if (devResIface->GetString(node, "serviceName", &table->serviceName, "") != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read serviceName fail!", __func__); + return HDF_FAILURE; + } + + if (devResIface->GetString(node, "deviceMatchAttr", &table->deviceMatchAttr, "") != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read deviceMatchAttr fail!", __func__); + return HDF_FAILURE; + } + + if (devResIface->GetUint8(node, "length", &table->length, 0) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read length fail!", __func__); + return HDF_FAILURE; + } + + if (devResIface->GetUint16(node, "matchFlag", &table->matchFlag, 0) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: read matchFlag fail!", __func__); + return HDF_FAILURE; + } + + if (UsbDdkPnpLoaderParseIdDevice(node, devResIface, table) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + return UsbDdkPnpLoaderParseIdInferface(node, devResIface, table); +} + +static struct UsbPnpMatchIdTable **UsbDdkPnpLoaderParseTableList( + const struct DeviceResourceNode *node, int32_t idTabCount, struct DeviceResourceIface *devResIface) +{ + int32_t ret; + int32_t count; + const char *idTableName = NULL; + struct UsbPnpMatchIdTable **idTable = NULL; + const struct DeviceResourceNode *tableNode = NULL; + + idTable = (struct UsbPnpMatchIdTable **)OsalMemCalloc((idTabCount + 1) * sizeof(struct UsbPnpMatchIdTable *)); + if (idTable == NULL) { + HDF_LOGE("%{public}s: OsalMemCalloc failure!", __func__); + return NULL; + } + idTable[idTabCount] = NULL; + for (count = 0; count < idTabCount; count++) { + idTable[count] = (struct UsbPnpMatchIdTable *)OsalMemCalloc(sizeof(struct UsbPnpMatchIdTable)); + if (idTable[count] == NULL) { + HDF_LOGE("%{public}s: OsalMemCalloc failure!", __func__); + goto out; + } + ret = devResIface->GetStringArrayElem(node, "idTableList", count, &idTableName, NULL); + if (ret != HDF_SUCCESS) { + goto out; + } + tableNode = devResIface->GetChildNode(node, idTableName); + if (tableNode == NULL) { + HDF_LOGE("%{public}s: tableNode is NULL!", __func__); + goto out; + } + if (UsbDdkPnpLoaderParseIdTable(tableNode, devResIface, idTable[count]) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: UsbDdkPnpLoaderParseIdTable failure!", __func__); + goto out; + } + } + + return idTable; + +out: + while ((--count) >= 0) { + OsalMemFree(idTable[count]); + } + OsalMemFree(idTable); + + return NULL; +} + +static struct UsbPnpMatchIdTable **UsbDdkPnpLoaderParseTable(const struct DeviceResourceNode *node) +{ + struct DeviceResourceIface *devResIface = NULL; + int32_t idTabCount; + + if (node == NULL) { + HDF_LOGE("%{public}s: node is NULL!", __func__); + return NULL; + } + + devResIface = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (devResIface == NULL) { + HDF_LOGE("%{public}s: devResIface is NULL!", __func__); + return NULL; + } + idTabCount = devResIface->GetElemNum(node, "idTableList"); + if (idTabCount <= 0) { + HDF_LOGE("%{public}s: idTableList not found!", __func__); + return NULL; + } + + return UsbDdkPnpLoaderParseTableList(node, idTabCount, devResIface); +} + +static struct UsbPnpMatchIdTable **UsbDdkPnpLoaderParseDeviceId(const struct DeviceResourceNode *node) +{ + const char *deviceIdName = NULL; + struct DeviceResourceIface *devResIface = NULL; + const struct DeviceResourceNode *deviceIdNode = NULL; + + if (node == NULL) { + HDF_LOGE("%{public}s: node is NULL!", __func__); + return NULL; + } + + devResIface = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (devResIface == NULL) { + HDF_LOGE("%{public}s: devResIface is NULL!", __func__); + return NULL; + } + + if (devResIface->GetString(node, "usb_pnp_device_id", &deviceIdName, NULL) != HDF_SUCCESS) { + HDF_LOGE("%{public}s: get usb_pnp_device_id name failure!", __func__); + return NULL; + } + + deviceIdNode = devResIface->GetChildNode(node, deviceIdName); + if (deviceIdNode == NULL) { + HDF_LOGE("%{public}s: deviceIdNode is NULL!", __func__); + return NULL; + } + + return UsbDdkPnpLoaderParseTable(deviceIdNode); +} + +static struct UsbPnpMatchIdTable **UsbDdkPnpLoaderPnpMatch(void) +{ + struct DeviceResourceIface *devResInstance = NULL; + const struct DeviceResourceNode *rootNode = NULL; + const struct DeviceResourceNode *usbPnpNode = NULL; + + devResInstance = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (devResInstance == NULL) { + HDF_LOGE("%{public}s: devResInstance is NULL!", __func__); + return NULL; + } + + rootNode = devResInstance->GetRootNode(); + if (rootNode == NULL) { + HDF_LOGE("%{public}s: devResNode is NULL!", __func__); + return NULL; + } + + usbPnpNode = devResInstance->GetNodeByMatchAttr(rootNode, "usb_pnp_match"); + if (usbPnpNode == NULL) { + HDF_LOGE("%{public}s: usbPnpNode is NULL!", __func__); + return NULL; + } + + return UsbDdkPnpLoaderParseDeviceId(usbPnpNode); +} + +static int32_t UsbDdkPnpLoaderDispatchPnpDevice( + struct IDevmgrService *devmgrSvc, struct HdfSBuf *data, bool isReg) +{ + uint32_t infoSize = 0; + struct UsbPnpNotifyServiceInfo *privateData = NULL; + struct UsbPnpManagerDeviceInfo managerInfo; + + const char *moduleName = HdfSbufReadString(data); + if (moduleName == NULL) { + return HDF_ERR_INVALID_PARAM; + } + const char *serviceName = HdfSbufReadString(data); + if (serviceName == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + const char *deviceMatchAttr = HdfSbufReadString(data); + if (deviceMatchAttr == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (!HdfSbufReadBuffer(data, (const void **)(&privateData), &infoSize)) { + HDF_LOGW("%{public}s: HdfSbufReadBuffer privateData error!", __func__); + privateData = NULL; + } + + managerInfo.devmgrSvc = devmgrSvc; + managerInfo.moduleName = moduleName; + managerInfo.serviceName = serviceName; + managerInfo.deviceMatchAttr = deviceMatchAttr; + managerInfo.privateData = privateData; + managerInfo.isReg = isReg; + + return UsbPnpManagerRegisterOrUnregisterDevice(managerInfo); +} + +static int UsbDdkPnpLoaderDeviceListAdd(struct UsbPnpNotifyMatchInfoTable *info, + const struct UsbPnpMatchIdTable *idTable) +{ + int ret; + unsigned char *ptr = NULL; + struct UsbPnpDeviceListTable *deviceTableListTemp = NULL; + + ptr = OsalMemAlloc(sizeof(struct UsbPnpDeviceListTable)); + if (ptr == NULL) { + ret = HDF_ERR_MALLOC_FAIL; + HDF_LOGE("%{public}s:%{public}d OsalMemAlloc faile, ret=%{public}d ", __func__, __LINE__, ret); + } else { + deviceTableListTemp = (struct UsbPnpDeviceListTable *)ptr; + + DListHeadInit(&deviceTableListTemp->list); + deviceTableListTemp->moduleName = idTable->moduleName; + deviceTableListTemp->serviceName = idTable->serviceName; + deviceTableListTemp->deviceMatchAttr = idTable->deviceMatchAttr; + deviceTableListTemp->status = USB_PNP_ADD_STATUS; + deviceTableListTemp->usbDevAddr = info->usbDevAddr; + deviceTableListTemp->devNum = info->devNum; + deviceTableListTemp->busNum = info->busNum; + deviceTableListTemp->interfaceLength = idTable->interfaceLength; + memcpy_s(deviceTableListTemp->interfaceNumber, USB_PNP_INFO_MAX_INTERFACES, \ + idTable->interfaceNumber, USB_PNP_INFO_MAX_INTERFACES); + + DListInsertTail(&deviceTableListTemp->list, &g_usbPnpDeviceTableListHead); + + ret = HDF_SUCCESS; + } + + return ret; +} + +static struct UsbPnpDeviceListTable *UsbDdkPnpLoaderAddInterface( + struct UsbPnpNotifyMatchInfoTable *info, const struct UsbPnpMatchIdTable *idTable) +{ + struct UsbPnpDeviceListTable *deviceListTablePos = NULL; + struct UsbPnpDeviceListTable *deviceListTableTemp = NULL; + + if (DListIsEmpty(&g_usbPnpDeviceTableListHead)) { + HDF_LOGE("%{public}s:%{public}d g_usbPnpDeviceTableListHead is empty. ", __func__, __LINE__); + return NULL; + } + + DLIST_FOR_EACH_ENTRY_SAFE(deviceListTablePos, deviceListTableTemp, &g_usbPnpDeviceTableListHead, + struct UsbPnpDeviceListTable, list) { + if ((strcmp(deviceListTablePos->moduleName, idTable->moduleName) == 0) && \ + (strcmp(deviceListTablePos->serviceName, idTable->serviceName) == 0) && \ + (strcmp(deviceListTablePos->deviceMatchAttr, idTable->deviceMatchAttr) == 0) && \ + (deviceListTablePos->usbDevAddr == info->usbDevAddr) && \ + (deviceListTablePos->devNum = info->devNum) && \ + (deviceListTablePos->busNum = info->busNum)) { + return deviceListTablePos; + } + } + + HDF_LOGE("%{public}s:%{public}d usbDevAddr=0x%{public}x, interface=%{public}d-%{public}d-%{public}d to \ + be add but not exist. ", + __func__, __LINE__, info->usbDevAddr, info->devNum, info->busNum, info->numInfos); + + return NULL; +} + +static int UsbDdkPnpLoaderrAddPnpDevice(struct IDevmgrService *devmgrSvc, + struct UsbPnpNotifyMatchInfoTable *infoTable, struct UsbPnpMatchIdTable *idTable, uint32_t cmdId) +{ + int ret; + struct HdfSBuf *pnpData = NULL; + struct UsbPnpNotifyServiceInfo serviceInfo; + struct UsbPnpDeviceListTable *deviceListTable = NULL; + + deviceListTable = UsbDdkPnpLoaderAddInterface(infoTable, idTable); + if ((deviceListTable != NULL) && (deviceListTable->status != USB_PNP_REMOVE_STATUS)) { + HDF_LOGI("%{public}s:%{public}d %{public}s-%{public}s is already exist!", + __func__, __LINE__, idTable->moduleName, idTable->serviceName); + return HDF_SUCCESS; + } + + serviceInfo.length = sizeof(struct UsbPnpNotifyServiceInfo) - (USB_PNP_INFO_MAX_INTERFACES + - idTable->interfaceLength); + serviceInfo.devNum = infoTable->devNum; + serviceInfo.busNum = infoTable->busNum; + serviceInfo.interfaceLength = idTable->interfaceLength; + memcpy_s(serviceInfo.interfaceNumber, USB_PNP_INFO_MAX_INTERFACES, \ + idTable->interfaceNumber, USB_PNP_INFO_MAX_INTERFACES); + pnpData = UsbDdkPnpLoaderBufCreate(idTable->moduleName, idTable->serviceName, + idTable->deviceMatchAttr, serviceInfo); + if (pnpData == NULL) { + ret = HDF_FAILURE; + HDF_LOGE("%{public}s: UsbDdkPnpLoaderBufCreate faile", __func__); + goto error; + } + + ret = UsbDdkPnpLoaderDispatchPnpDevice(devmgrSvc, pnpData, true); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s:%{public}d handle failed, %{public}s-%{public}s cmdId is %{public}d, ret=%{public}d", + __func__, __LINE__, idTable->moduleName, idTable->serviceName, cmdId, ret); + } else { + if (cmdId == USB_PNP_NOTIFY_ADD_INTERFACE) { + if (deviceListTable == NULL) { + ret = HDF_ERR_INVALID_OBJECT; + HDF_LOGE("%{public}s:%{public}d UsbDdkPnpLoaderAddInterface faile", __func__, __LINE__); + goto error; + } + deviceListTable->status = USB_PNP_ADD_STATUS; + } else { + ret = UsbDdkPnpLoaderDeviceListAdd(infoTable, idTable); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s:%{public}d UsbDdkPnpLoaderDeviceListAdd faile", __func__, __LINE__); + goto error; + } + } + } +error: + HdfSBufRecycle(pnpData); + return ret; +} + +static void UsbDdkPnpLoaderAddDevice(uint32_t cmdId, uint8_t index, struct IDevmgrService *devmgrSvc, + struct UsbPnpNotifyMatchInfoTable *infoTable, struct UsbPnpMatchIdTable **matchIdTable) +{ + int ret; + struct UsbPnpMatchIdTable *idTable = NULL; + int32_t tableCount; + + for (tableCount = 0, idTable = matchIdTable[0]; idTable != NULL; idTable = matchIdTable[++tableCount]) { + if (!UsbDdkPnpLoaderMatchDevice(infoTable, idTable)) { + continue; + } + + if (!UsbDdkPnpLoaderMatchOneIdIntf(infoTable, index, idTable)) { + continue; + } + + HDF_LOGD("%{public}s:%{public}d matchDevice end, index=%{public}d tableCount=%{public}d is match \ + idTable=%{public}p, moduleName=%{public}s, serviceName=%{public}s", + __func__, __LINE__, index, tableCount, idTable, idTable->moduleName, idTable->serviceName); + + ret = UsbDdkPnpLoaderrAddPnpDevice(devmgrSvc, infoTable, idTable, cmdId); + if (ret != HDF_SUCCESS) { + continue; + } + } + + HDF_LOGD("%{public}s:%{public}d AddDevice end, index=%{public}d, ret=%{public}d", __func__, __LINE__, index, ret); +} + +static int UsbDdkPnpLoaderRemoveHandle(struct IDevmgrService *devmgrSvc, + struct UsbPnpDeviceListTable *deviceListTablePos) +{ + struct UsbPnpNotifyServiceInfo serviceInfo; + struct HdfSBuf *pnpData = NULL; + int ret = HDF_SUCCESS; + + serviceInfo.length = sizeof(struct UsbPnpNotifyServiceInfo) - (USB_PNP_INFO_MAX_INTERFACES \ + - deviceListTablePos->interfaceLength); + serviceInfo.devNum = deviceListTablePos->devNum; + serviceInfo.busNum = deviceListTablePos->busNum; + serviceInfo.interfaceLength = deviceListTablePos->interfaceLength; + memcpy_s(serviceInfo.interfaceNumber, USB_PNP_INFO_MAX_INTERFACES, \ + deviceListTablePos->interfaceNumber, USB_PNP_INFO_MAX_INTERFACES); + pnpData = UsbDdkPnpLoaderBufCreate(deviceListTablePos->moduleName, deviceListTablePos->serviceName, \ + deviceListTablePos->deviceMatchAttr, serviceInfo); + if (pnpData == NULL) { + HDF_LOGE("%{public}s: UsbDdkPnpLoaderBufCreate faile", __func__); + return HDF_FAILURE; + } + + if (deviceListTablePos->status != USB_PNP_REMOVE_STATUS) { + ret = UsbDdkPnpLoaderDispatchPnpDevice(devmgrSvc, pnpData, false); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s:%{public}d UsbDdkPnpLoaderDispatchPnpDevice faile ret=%{public}d", + __func__, __LINE__, ret); + goto error; + } + deviceListTablePos->status = USB_PNP_REMOVE_STATUS; + } + +error: + HdfSBufRecycle(pnpData); + return ret; +} + +static int UsbDdkPnpLoaderRemoveDevice(struct IDevmgrService *devmgrSvc, + struct UsbPnpRemoveInfo removeInfo, uint32_t cmdId) +{ + int ret = HDF_SUCCESS; + struct UsbPnpDeviceListTable *deviceListTablePos = NULL; + struct UsbPnpDeviceListTable *deviceListTableTemp = NULL; + bool findFlag = false; + int32_t i; + + if (DListIsEmpty(&g_usbPnpDeviceTableListHead)) { + HDF_LOGE("%{public}s:%{public}d g_usbPnpDeviceTableListHead is empty. ", __func__, __LINE__); + return HDF_SUCCESS; + } + + DLIST_FOR_EACH_ENTRY_SAFE(deviceListTablePos, deviceListTableTemp, &g_usbPnpDeviceTableListHead, + struct UsbPnpDeviceListTable, list) { + if (deviceListTablePos->usbDevAddr == removeInfo.usbDevAddr) { + if (removeInfo.removeType == USB_PNP_NOTIFY_REMOVE_INTERFACE_NUM) { + for (i = 0; i < deviceListTablePos->interfaceLength; i++) { + if (deviceListTablePos->interfaceNumber[i] == removeInfo.interfaceNum) { + break; + } + } + + if (i >= deviceListTablePos->interfaceLength) { + continue; + } + } + findFlag = true; + + ret = UsbDdkPnpLoaderRemoveHandle(devmgrSvc, deviceListTablePos); + if (ret != HDF_SUCCESS) { + break; + } + + if (cmdId != USB_PNP_NOTIFY_REMOVE_INTERFACE) { + DListRemove(&deviceListTablePos->list); + OsalMemFree(deviceListTablePos); + deviceListTablePos = NULL; + } + } + } + + if (findFlag == false) { + HDF_LOGE("%{public}s:%{public}d removeType=%{public}d, usbDevAddr=0x%{public}x, to be remove but not exist.", + __func__, __LINE__, removeInfo.removeType, removeInfo.usbDevAddr); + ret = HDF_FAILURE; + } + + return ret; +} + +static int UsbDdkPnpLoaderDevice(struct UsbPnpNotifyMatchInfoTable *infoTable, + struct IDevmgrService *super, uint32_t id) +{ + int8_t i; + int32_t tableCount; + struct UsbPnpMatchIdTable *idTable = NULL; + + if ((infoTable == NULL) || (g_usbPnpMatchIdTable == NULL) || (g_usbPnpMatchIdTable[0] == NULL)) { + HDF_LOGE("%{public}s:%{public}d infoTable or super or g_usbPnpMatchIdTable is NULL!", __func__, __LINE__); + return HDF_ERR_INVALID_PARAM; + } + + for (i = 0; i < infoTable->numInfos; i++) { + UsbDdkPnpLoaderAddDevice(id, i, super, infoTable, g_usbPnpMatchIdTable); + } + + for (tableCount = 0, idTable = g_usbPnpMatchIdTable[0]; idTable != NULL; + idTable = g_usbPnpMatchIdTable[++tableCount]) { + idTable->interfaceClassMask = 0; + if (!(idTable->matchFlag & USB_PNP_NOTIFY_MATCH_INT_CLASS)) { + idTable->interfaceClassLength = 0; + } + idTable->interfaceSubClassMask = 0; + if (!(idTable->matchFlag & USB_PNP_NOTIFY_MATCH_INT_SUBCLASS)) { + idTable->interfaceSubClassLength = 0; + } + idTable->interfaceProtocolMask = 0; + if (!(idTable->matchFlag & USB_PNP_NOTIFY_MATCH_INT_PROTOCOL)) { + idTable->interfaceProtocolLength = 0; + } + idTable->interfaceMask = 0; + if (!(idTable->matchFlag & USB_PNP_NOTIFY_MATCH_INT_NUMBER)) { + idTable->interfaceLength = 0; + } + idTable->pnpMatchFlag = false; + } + + return HDF_SUCCESS; +} + +static int UsbDdkPnpLoaderEventSend(struct HdfIoService *serv, char *eventData) +{ + int ret; + int replyData = 0; + struct HdfSBuf *data = NULL; + + data = HdfSBufObtainDefaultSize(); + if (data == NULL) { + ret = HDF_DEV_ERR_NO_MEMORY; + HDF_LOGE("%{public}s: fail to obtain sbuf data", __func__); + return ret; + } + + struct HdfSBuf *reply = HdfSBufObtainDefaultSize(); + if (reply == NULL) { + ret = HDF_DEV_ERR_NO_MEMORY; + HDF_LOGE("%{public}s: fail to obtain sbuf reply", __func__); + goto out; + } + + if (!HdfSbufWriteString(data, eventData)) { + ret = HDF_FAILURE; + HDF_LOGE("%{public}s: fail to write sbuf", __func__); + goto out; + } + + ret = serv->dispatcher->Dispatch(&serv->object, USB_PNP_NOTIFY_REPORT_INTERFACE, data, reply); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s: fail to send serivice call, ret=%{public}d", __func__, ret); + goto out; + } + + if (!HdfSbufReadInt32(reply, &replyData)) { + ret = HDF_ERR_INVALID_OBJECT; + HDF_LOGE("%{public}s: fail to get service call reply", __func__); + goto out; + } + + HDF_LOGI("%{public}s:%{public}d get reply is 0x%{public}x", __func__, __LINE__, replyData); + +out: + HdfSBufRecycle(data); + HdfSBufRecycle(reply); + + return ret; +} + +int UsbDdkPnpLoaderEventReceived(void *priv, uint32_t id, struct HdfSBuf *data) +{ + int ret; + bool flag = false; + uint32_t infoSize; + struct UsbPnpNotifyMatchInfoTable *infoTable = NULL; + struct IDevmgrService *super = (struct IDevmgrService *)priv; + struct UsbPnpRemoveInfo removeInfo; + + flag = HdfSbufReadBuffer(data, (const void **)(&infoTable), &infoSize); + if ((flag == false) || (infoTable == NULL)) { + ret = HDF_ERR_INVALID_PARAM; + HDF_LOGE("%{public}s: fail to read infoTable in event data, flag=%{public}d, infoTable=%{public}p", \ + __func__, flag, infoTable); + return ret; + } + + HDF_LOGI("%{public}s:%{public}d id=%{public}d infoSize=%{public}d, usbDevAddr=0x%{public}x, devNum=%{public}d, \ + busNum=%{public}d, infoTable=0x%{public}x-0x%{public}x success", + __func__, __LINE__, id, infoSize, infoTable->usbDevAddr, infoTable->devNum, + infoTable->busNum, infoTable->deviceInfo.vendorId, infoTable->deviceInfo.productId); + + switch (id) { + case USB_PNP_NOTIFY_ADD_INTERFACE: + case USB_PNP_NOTIFY_ADD_DEVICE: + case USB_PNP_NOTIFY_REPORT_INTERFACE: +#if USB_PNP_NOTIFY_TEST_MODE == true + case USB_PNP_NOTIFY_ADD_TEST: +#endif + ret = UsbDdkPnpLoaderDevice(infoTable, super, id); + break; + case USB_PNP_NOTIFY_REMOVE_INTERFACE: + case USB_PNP_NOTIFY_REMOVE_DEVICE: +#if USB_PNP_NOTIFY_TEST_MODE == true + case USB_PNP_NOTIFY_REMOVE_TEST: +#endif + removeInfo.removeType = infoTable->removeType; + removeInfo.usbDevAddr = infoTable->usbDevAddr; + removeInfo.devNum = infoTable->devNum; + removeInfo.busNum = infoTable->busNum; + removeInfo.interfaceNum = infoTable->interfaceInfo[0].interfaceNumber; + ret = UsbDdkPnpLoaderRemoveDevice(super, removeInfo, id); + break; + default: + ret = HDF_ERR_INVALID_PARAM; + break; + } + + HDF_LOGI("%{public}s:%{public}d ret=%{public}d DONE", __func__, __LINE__, ret); + + return ret; +} + +int UsbDdkPnpLoaderEventHandle(void) +{ + int status; + int32_t tableCount = 0; + static bool firstInitFlag = true; + const struct UsbPnpMatchIdTable *idTable = NULL; + struct HdfIoService *usbPnpServ = HdfIoServiceBind(USB_PNP_NOTIFY_SERVICE_NAME); + + if (usbPnpServ == NULL) { + HDF_LOGE("%{public}s: HdfIoServiceBind faile.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (firstInitFlag == true) { + firstInitFlag = false; + + DListHeadInit(&g_usbPnpDeviceTableListHead); + } + + g_usbPnpMatchIdTable = UsbDdkPnpLoaderPnpMatch(); + if ((g_usbPnpMatchIdTable == NULL) || (g_usbPnpMatchIdTable[0] == NULL)) { + status = HDF_ERR_INVALID_PARAM; + HDF_LOGE("%{public}s: g_usbPnpMatchIdTable or g_usbPnpMatchIdTable[0] is NULL!", __func__); + return status; + } + + status = UsbDdkPnpLoaderEventSend(usbPnpServ, "USB PNP Handle Info"); + if (status != HDF_SUCCESS) { + HDF_LOGE("UsbDdkPnpLoaderEventSend faile status=%{public}d", status); + goto error; + } + return status; +error: + for (idTable = g_usbPnpMatchIdTable[0]; idTable != NULL; ) { + tableCount++; + idTable = g_usbPnpMatchIdTable[tableCount]; + } + while ((--tableCount) >= 0) { + OsalMemFree(g_usbPnpMatchIdTable[tableCount]); + g_usbPnpMatchIdTable[tableCount] = NULL; + } + OsalMemFree(g_usbPnpMatchIdTable); + g_usbPnpMatchIdTable = NULL; + + return status; +} diff --git a/test/unittest/common/hdf_main_test.c b/test/unittest/common/hdf_main_test.c index 7c5be8c78..09e56f697 100644 --- a/test/unittest/common/hdf_main_test.c +++ b/test/unittest/common/hdf_main_test.c @@ -58,7 +58,9 @@ #if defined(LOSCFG_DRIVERS_HDF_USB_DDK_DEVICE) || defined(CONFIG_DRIVERS_HDF_USB_DDK_DEVICE) #include "hdf_usb_device_test.h" #endif - +#if defined(LOSCFG_DRIVERS_HDF_USB_DDK_HOST) || defined(CONFIG_DRIVERS_HDF_USB_DDK_HOST) +#include "hdf_usb_entry_test.h" +#endif #define HDF_LOG_TAG hdf_test @@ -111,7 +113,12 @@ HdfTestFuncList g_hdfTestFuncList[] = { #if defined(LOSCFG_DRIVERS_HDF_USB_DDK_DEVICE) || defined(CONFIG_DRIVERS_HDF_USB_DDK_DEVICE) {TEST_USB_DEVICE_TYPE, HdfUsbDeviceEntry}, #endif - +#if defined(LOSCFG_DRIVERS_HDF_USB_DDK_HOST) || defined(CONFIG_DRIVERS_HDF_USB_DDK_HOST) +#if defined(LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY) || defined(CONFIG_DRIVERS_HDF_USB_PNP_NOTIFY) + {TEST_USB_HOST_TYPE, HdfUsbUnitTestEntry}, + {TEST_USB_HOST_RAW_TYPE, HdfUsbUnitTestEntry}, +#endif +#endif }; static int32_t HdfTestCaseProcess(struct HdfDeviceIoClient *client, diff --git a/test/unittest/common/hdf_main_test.h b/test/unittest/common/hdf_main_test.h index 460783447..c54969825 100644 --- a/test/unittest/common/hdf_main_test.h +++ b/test/unittest/common/hdf_main_test.h @@ -70,6 +70,8 @@ typedef enum { TEST_AUDIO_TYPE = 701, TEST_HDF_FRAME_END = 800, TEST_USB_DEVICE_TYPE = 900, + TEST_USB_HOST_TYPE = 1000, + TEST_USB_HOST_RAW_TYPE = 1100, } HdfTestSubModuleCmd; struct HdfDeviceObject *GetDeviceObject(void); diff --git a/test/unittest/include/hdf_uhdf_test.h b/test/unittest/include/hdf_uhdf_test.h index e5586f6a1..0c22f0cb9 100644 --- a/test/unittest/include/hdf_uhdf_test.h +++ b/test/unittest/include/hdf_uhdf_test.h @@ -65,6 +65,8 @@ enum HdfTestSubModuleCmd { TEST_CONFIG_TYPE = 601, TEST_HDF_FRAME_END = 800, TEST_USB_DEVICE_TYPE = 900, + TEST_USB_HOST_TYPE = 1000, + TEST_USB_HOST_RAW_TYPE = 1100, }; void HdfTestOpenService(void); diff --git a/test/unittest/model/usb/include/hdf_usb_device_test.h b/test/unittest/model/usb/device/include/hdf_usb_device_test.h similarity index 91% rename from test/unittest/model/usb/include/hdf_usb_device_test.h rename to test/unittest/model/usb/device/include/hdf_usb_device_test.h index 7d5af872e..76f6a99b4 100644 --- a/test/unittest/model/usb/include/hdf_usb_device_test.h +++ b/test/unittest/model/usb/device/include/hdf_usb_device_test.h @@ -24,7 +24,6 @@ typedef enum { USB_DEVICE_DEVICE_STATUS003, USB_DEVICE_DEVICE_STATUS004, USB_DEVICE_DEVICE_STATUS005, - USB_DEVICE_DEVICE_STATUS006, USB_DEVICE_GET_DEVICE, USB_DEVICE_GET_DEVICE002, USB_DEVICE_GET_DEVICE003, @@ -55,36 +54,46 @@ typedef enum { USB_DEVICE_REQUEST_SYNC004, USB_DEVICE_REQUEST_SYNC005, USB_DEVICE_REQUEST_SYNC006, + USB_DEVICE_REQUEST_SYNC007, USB_DEVICE_REGIST_PROP, USB_DEVICE_REGIST_PROP002, USB_DEVICE_REGIST_PROP003, USB_DEVICE_REGIST_PROP004, USB_DEVICE_REGIST_PROP005, USB_DEVICE_REGIST_PROP006, + USB_DEVICE_REGIST_PROP007, USB_DEVICE_GET_PROP, USB_DEVICE_GET_PROP002, USB_DEVICE_GET_PROP003, USB_DEVICE_GET_PROP004, USB_DEVICE_GET_PROP005, USB_DEVICE_GET_PROP006, + USB_DEVICE_GET_PROP007, + USB_DEVICE_GET_PROP008, USB_DEVICE_SET_PROP, USB_DEVICE_SET_PROP002, USB_DEVICE_SET_PROP003, USB_DEVICE_SET_PROP004, USB_DEVICE_SET_PROP005, USB_DEVICE_SET_PROP006, + USB_DEVICE_SET_PROP007, USB_DEVICE_ALLOC_CTRLREQUEST, USB_DEVICE_ALLOC_CTRLREQUEST002, USB_DEVICE_ALLOC_CTRLREQUEST003, USB_DEVICE_ALLOC_CTRLREQUEST004, USB_DEVICE_ALLOC_CTRLREQUEST005, USB_DEVICE_ALLOC_CTRLREQUEST006, + USB_DEVICE_ALLOC_CTRLREQUEST007, + USB_DEVICE_ALLOC_CTRLREQUEST008, USB_DEVICE_ALLOC_REQUEST, USB_DEVICE_ALLOC_REQUEST002, USB_DEVICE_ALLOC_REQUEST003, USB_DEVICE_ALLOC_REQUEST004, USB_DEVICE_ALLOC_REQUEST005, USB_DEVICE_ALLOC_REQUEST006, + USB_DEVICE_ALLOC_REQUEST007, + USB_DEVICE_ALLOC_REQUEST008, + USB_DEVICE_ALLOC_REQUEST009, USB_DEVICE_FREE_REQUEST, USB_DEVICE_FREE_REQUEST002, USB_DEVICE_FREE_REQUEST003, @@ -107,32 +116,24 @@ typedef enum { USB_DEVICE_STOP_EVENT002, USB_DEVICE_STOP_EVENT003, USB_DEVICE_STOP_EVENT004, - USB_DEVICE_STOP_EVENT005, - USB_DEVICE_STOP_EVENT006, USB_DEVICE_START_EVENT, USB_DEVICE_START_EVENT002, USB_DEVICE_START_EVENT003, USB_DEVICE_START_EVENT004, USB_DEVICE_START_EVENT005, USB_DEVICE_START_EVENT006, + USB_DEVICE_START_EVENT007, USB_DEVICE_CLOSE_INTERFACE, USB_DEVICE_CLOSE_INTERFACE002, USB_DEVICE_CLOSE_INTERFACE003, USB_DEVICE_CLOSE_INTERFACE004, - USB_DEVICE_CLOSE_INTERFACE005, - USB_DEVICE_CLOSE_INTERFACE006, USB_DEVICE_OPEN_INTERFACE, USB_DEVICE_OPEN_INTERFACE002, USB_DEVICE_OPEN_INTERFACE003, USB_DEVICE_OPEN_INTERFACE004, USB_DEVICE_OPEN_INTERFACE005, - USB_DEVICE_OPEN_INTERFACE006, USB_DEVICE_DELETE_DEVICE, USB_DEVICE_DELETE_DEVICE002, - USB_DEVICE_DELETE_DEVICE003, - USB_DEVICE_DELETE_DEVICE004, - USB_DEVICE_DELETE_DEVICE005, - USB_DEVICE_DELETE_DEVICE006, USB_DEVICE_MESSAGE_END = 300, } HdfUsbDeviceTestCaseCmd; diff --git a/test/unittest/model/usb/include/usb_device_lite_cdcacm_test.h b/test/unittest/model/usb/device/include/usb_device_lite_cdcacm_test.h similarity index 91% rename from test/unittest/model/usb/include/usb_device_lite_cdcacm_test.h rename to test/unittest/model/usb/device/include/usb_device_lite_cdcacm_test.h index bf204e17d..e28d2ad98 100644 --- a/test/unittest/model/usb/include/usb_device_lite_cdcacm_test.h +++ b/test/unittest/model/usb/device/include/usb_device_lite_cdcacm_test.h @@ -26,7 +26,10 @@ #include "osal_time.h" #define TEST_TIMES 10 - +#define WAIT_TIMES 60 +#define BUFFER_LEN 64 +#define WAIT_100MS 100 +#define SYNC_5000MS 5000 #define CDC_ACM #define QUEUE_SIZE 8 #define PORT_RATE 9600 @@ -62,7 +65,6 @@ struct Serial { int32_t writeStarted; int32_t writeAllocated; bool writeBusy; - bool suspended; bool startDelayed; int refCount; @@ -98,12 +100,12 @@ struct AcmDevice { struct OsalMutex lock; bool pending; bool connect; - bool haved_submit; + bool havedSubmit; uint32_t enableEvtCnt; char *udcName; - char submit; - char submit_exit; - struct Serial *port; + char submit; + char submitExit; + struct Serial *port; struct UsbCdcLineCoding lineCoding; uint16_t serialState; #define SERIAL_STATE_DCD (1 << 0) @@ -129,6 +131,7 @@ struct AcmDevice *SetUpAcmDevice(void); void ReleaseAcmDevice(struct AcmDevice *acm); void AcmEventCallback(struct UsbFnEvent *event); void AcmDeviceRelease(struct AcmDevice *acmDevice); +int remove_usb_device(void); int32_t UsbFnDviceTestCreate(void); int32_t UsbFnDviceTestCreate002(void); @@ -141,7 +144,6 @@ int32_t UsbFnDviceTestStatus002(void); int32_t UsbFnDviceTestStatus003(void); int32_t UsbFnDviceTestStatus004(void); int32_t UsbFnDviceTestStatus005(void); -int32_t UsbFnDviceTestStatus006(void); int32_t UsbFnDviceTestGetDevice(void); int32_t UsbFnDviceTestGetDevice002(void); int32_t UsbFnDviceTestGetDevice003(void); @@ -172,36 +174,46 @@ int32_t UsbFnDviceTestRequestSync003(void); int32_t UsbFnDviceTestRequestSync004(void); int32_t UsbFnDviceTestRequestSync005(void); int32_t UsbFnDviceTestRequestSync006(void); +int32_t UsbFnDviceTestRequestSync007(void); int32_t UsbFnDviceTestRegistProp(void); int32_t UsbFnDviceTestRegistProp002(void); int32_t UsbFnDviceTestRegistProp003(void); int32_t UsbFnDviceTestRegistProp004(void); int32_t UsbFnDviceTestRegistProp005(void); int32_t UsbFnDviceTestRegistProp006(void); +int32_t UsbFnDviceTestRegistProp007(void); int32_t UsbFnDviceTestGetProp(void); int32_t UsbFnDviceTestGetProp002(void); int32_t UsbFnDviceTestGetProp003(void); int32_t UsbFnDviceTestGetProp004(void); int32_t UsbFnDviceTestGetProp005(void); int32_t UsbFnDviceTestGetProp006(void); +int32_t UsbFnDviceTestGetProp007(void); +int32_t UsbFnDviceTestGetProp008(void); int32_t UsbFnDviceTestSetProp(void); int32_t UsbFnDviceTestSetProp002(void); int32_t UsbFnDviceTestSetProp003(void); int32_t UsbFnDviceTestSetProp004(void); int32_t UsbFnDviceTestSetProp005(void); int32_t UsbFnDviceTestSetProp006(void); +int32_t UsbFnDviceTestSetProp007(void); int32_t UsbFnDviceTestAllocCtrlRequest(void); int32_t UsbFnDviceTestAllocCtrlRequest002(void); int32_t UsbFnDviceTestAllocCtrlRequest003(void); int32_t UsbFnDviceTestAllocCtrlRequest004(void); int32_t UsbFnDviceTestAllocCtrlRequest005(void); int32_t UsbFnDviceTestAllocCtrlRequest006(void); +int32_t UsbFnDviceTestAllocCtrlRequest007(void); +int32_t UsbFnDviceTestAllocCtrlRequest008(void); int32_t UsbFnDviceTestAllocRequest(void); int32_t UsbFnDviceTestAllocRequest002(void); int32_t UsbFnDviceTestAllocRequest003(void); int32_t UsbFnDviceTestAllocRequest004(void); int32_t UsbFnDviceTestAllocRequest005(void); int32_t UsbFnDviceTestAllocRequest006(void); +int32_t UsbFnDviceTestAllocRequest007(void); +int32_t UsbFnDviceTestAllocRequest008(void); +int32_t UsbFnDviceTestAllocRequest009(void); int32_t UsbFnDviceTestFreeRequest(void); int32_t UsbFnDviceTestFreeRequest002(void); int32_t UsbFnDviceTestFreeRequest003(void); @@ -224,28 +236,23 @@ int32_t UsbFnDviceTestStopReceEvent(void); int32_t UsbFnDviceTestStopReceEvent002(void); int32_t UsbFnDviceTestStopReceEvent003(void); int32_t UsbFnDviceTestStopReceEvent004(void); -int32_t UsbFnDviceTestStopReceEvent005(void); -int32_t UsbFnDviceTestStopReceEvent006(void); int32_t UsbFnDviceTestStartReceEvent(void); int32_t UsbFnDviceTestStartReceEvent002(void); int32_t UsbFnDviceTestStartReceEvent003(void); int32_t UsbFnDviceTestStartReceEvent004(void); int32_t UsbFnDviceTestStartReceEvent005(void); int32_t UsbFnDviceTestStartReceEvent006(void); +int32_t UsbFnDviceTestStartReceEvent007(void); int32_t UsbFnDviceTestCloseInterface(void); int32_t UsbFnDviceTestCloseInterface002(void); int32_t UsbFnDviceTestCloseInterface003(void); int32_t UsbFnDviceTestCloseInterface004(void); -int32_t UsbFnDviceTestCloseInterface005(void); -int32_t UsbFnDviceTestCloseInterface006(void); int32_t UsbFnDviceTestOpenInterface(void); int32_t UsbFnDviceTestOpenInterface002(void); int32_t UsbFnDviceTestOpenInterface003(void); int32_t UsbFnDviceTestOpenInterface004(void); int32_t UsbFnDviceTestOpenInterface005(void); -int32_t UsbFnDviceTestOpenInterface006(void); int32_t UsbFnDviceTestRemove(void); int32_t UsbFnDviceTestRemove002(void); -int32_t UsbFnDviceTestRemove003(void); #endif diff --git a/test/unittest/model/usb/src/hdf_usb_device_test.c b/test/unittest/model/usb/device/src/hdf_usb_device_test.c similarity index 92% rename from test/unittest/model/usb/src/hdf_usb_device_test.c rename to test/unittest/model/usb/device/src/hdf_usb_device_test.c index cf5848216..329e2f956 100644 --- a/test/unittest/model/usb/src/hdf_usb_device_test.c +++ b/test/unittest/model/usb/device/src/hdf_usb_device_test.c @@ -25,7 +25,6 @@ static HdfTestCaseList g_hdfUsbDeviceTestCaseList[] = { {USB_DEVICE_DEVICE_STATUS003, UsbFnDviceTestStatus003}, {USB_DEVICE_DEVICE_STATUS004, UsbFnDviceTestStatus004}, {USB_DEVICE_DEVICE_STATUS005, UsbFnDviceTestStatus005}, - {USB_DEVICE_DEVICE_STATUS006, UsbFnDviceTestStatus006}, {USB_DEVICE_GET_DEVICE, UsbFnDviceTestGetDevice}, {USB_DEVICE_GET_DEVICE002, UsbFnDviceTestGetDevice002}, {USB_DEVICE_GET_DEVICE003, UsbFnDviceTestGetDevice003}, @@ -56,36 +55,46 @@ static HdfTestCaseList g_hdfUsbDeviceTestCaseList[] = { {USB_DEVICE_REQUEST_SYNC004, UsbFnDviceTestRequestSync004}, {USB_DEVICE_REQUEST_SYNC005, UsbFnDviceTestRequestSync005}, {USB_DEVICE_REQUEST_SYNC006, UsbFnDviceTestRequestSync006}, + {USB_DEVICE_REQUEST_SYNC007, UsbFnDviceTestRequestSync007}, {USB_DEVICE_REGIST_PROP, UsbFnDviceTestRegistProp}, {USB_DEVICE_REGIST_PROP002, UsbFnDviceTestRegistProp002}, {USB_DEVICE_REGIST_PROP003, UsbFnDviceTestRegistProp003}, {USB_DEVICE_REGIST_PROP004, UsbFnDviceTestRegistProp004}, {USB_DEVICE_REGIST_PROP005, UsbFnDviceTestRegistProp005}, {USB_DEVICE_REGIST_PROP006, UsbFnDviceTestRegistProp006}, + {USB_DEVICE_REGIST_PROP007, UsbFnDviceTestRegistProp007}, {USB_DEVICE_GET_PROP, UsbFnDviceTestGetProp}, {USB_DEVICE_GET_PROP002, UsbFnDviceTestGetProp002}, {USB_DEVICE_GET_PROP003, UsbFnDviceTestGetProp003}, {USB_DEVICE_GET_PROP004, UsbFnDviceTestGetProp004}, {USB_DEVICE_GET_PROP005, UsbFnDviceTestGetProp005}, {USB_DEVICE_GET_PROP006, UsbFnDviceTestGetProp006}, + {USB_DEVICE_GET_PROP007, UsbFnDviceTestGetProp007}, + {USB_DEVICE_GET_PROP008, UsbFnDviceTestGetProp008}, {USB_DEVICE_SET_PROP, UsbFnDviceTestSetProp}, {USB_DEVICE_SET_PROP002, UsbFnDviceTestSetProp002}, {USB_DEVICE_SET_PROP003, UsbFnDviceTestSetProp003}, {USB_DEVICE_SET_PROP004, UsbFnDviceTestSetProp004}, {USB_DEVICE_SET_PROP005, UsbFnDviceTestSetProp005}, {USB_DEVICE_SET_PROP006, UsbFnDviceTestSetProp006}, + {USB_DEVICE_SET_PROP007, UsbFnDviceTestSetProp007}, {USB_DEVICE_ALLOC_CTRLREQUEST, UsbFnDviceTestAllocCtrlRequest}, {USB_DEVICE_ALLOC_CTRLREQUEST002, UsbFnDviceTestAllocCtrlRequest002}, {USB_DEVICE_ALLOC_CTRLREQUEST003, UsbFnDviceTestAllocCtrlRequest003}, {USB_DEVICE_ALLOC_CTRLREQUEST004, UsbFnDviceTestAllocCtrlRequest004}, {USB_DEVICE_ALLOC_CTRLREQUEST005, UsbFnDviceTestAllocCtrlRequest005}, {USB_DEVICE_ALLOC_CTRLREQUEST006, UsbFnDviceTestAllocCtrlRequest006}, + {USB_DEVICE_ALLOC_CTRLREQUEST007, UsbFnDviceTestAllocCtrlRequest007}, + {USB_DEVICE_ALLOC_CTRLREQUEST008, UsbFnDviceTestAllocCtrlRequest008}, {USB_DEVICE_ALLOC_REQUEST, UsbFnDviceTestAllocRequest}, {USB_DEVICE_ALLOC_REQUEST002, UsbFnDviceTestAllocRequest002}, {USB_DEVICE_ALLOC_REQUEST003, UsbFnDviceTestAllocRequest003}, {USB_DEVICE_ALLOC_REQUEST004, UsbFnDviceTestAllocRequest004}, {USB_DEVICE_ALLOC_REQUEST005, UsbFnDviceTestAllocRequest005}, {USB_DEVICE_ALLOC_REQUEST006, UsbFnDviceTestAllocRequest006}, + {USB_DEVICE_ALLOC_REQUEST007, UsbFnDviceTestAllocRequest007}, + {USB_DEVICE_ALLOC_REQUEST008, UsbFnDviceTestAllocRequest008}, + {USB_DEVICE_ALLOC_REQUEST009, UsbFnDviceTestAllocRequest009}, {USB_DEVICE_FREE_REQUEST, UsbFnDviceTestFreeRequest}, {USB_DEVICE_FREE_REQUEST002, UsbFnDviceTestFreeRequest002}, {USB_DEVICE_FREE_REQUEST003, UsbFnDviceTestFreeRequest003}, @@ -108,29 +117,24 @@ static HdfTestCaseList g_hdfUsbDeviceTestCaseList[] = { {USB_DEVICE_STOP_EVENT002, UsbFnDviceTestStopReceEvent002}, {USB_DEVICE_STOP_EVENT003, UsbFnDviceTestStopReceEvent003}, {USB_DEVICE_STOP_EVENT004, UsbFnDviceTestStopReceEvent004}, - {USB_DEVICE_STOP_EVENT005, UsbFnDviceTestStopReceEvent005}, - {USB_DEVICE_STOP_EVENT006, UsbFnDviceTestStopReceEvent006}, {USB_DEVICE_START_EVENT, UsbFnDviceTestStartReceEvent}, {USB_DEVICE_START_EVENT002, UsbFnDviceTestStartReceEvent002}, {USB_DEVICE_START_EVENT003, UsbFnDviceTestStartReceEvent003}, {USB_DEVICE_START_EVENT004, UsbFnDviceTestStartReceEvent004}, {USB_DEVICE_START_EVENT005, UsbFnDviceTestStartReceEvent005}, {USB_DEVICE_START_EVENT006, UsbFnDviceTestStartReceEvent006}, + {USB_DEVICE_START_EVENT007, UsbFnDviceTestStartReceEvent007}, {USB_DEVICE_CLOSE_INTERFACE, UsbFnDviceTestCloseInterface}, {USB_DEVICE_CLOSE_INTERFACE002, UsbFnDviceTestCloseInterface002}, {USB_DEVICE_CLOSE_INTERFACE003, UsbFnDviceTestCloseInterface003}, {USB_DEVICE_CLOSE_INTERFACE004, UsbFnDviceTestCloseInterface004}, - {USB_DEVICE_CLOSE_INTERFACE005, UsbFnDviceTestCloseInterface005}, - {USB_DEVICE_CLOSE_INTERFACE006, UsbFnDviceTestCloseInterface006}, {USB_DEVICE_OPEN_INTERFACE, UsbFnDviceTestOpenInterface}, {USB_DEVICE_OPEN_INTERFACE002, UsbFnDviceTestOpenInterface002}, {USB_DEVICE_OPEN_INTERFACE003, UsbFnDviceTestOpenInterface003}, {USB_DEVICE_OPEN_INTERFACE004, UsbFnDviceTestOpenInterface004}, {USB_DEVICE_OPEN_INTERFACE005, UsbFnDviceTestOpenInterface005}, - {USB_DEVICE_OPEN_INTERFACE006, UsbFnDviceTestOpenInterface006}, {USB_DEVICE_DELETE_DEVICE, UsbFnDviceTestRemove}, {USB_DEVICE_DELETE_DEVICE002, UsbFnDviceTestRemove002}, - {USB_DEVICE_DELETE_DEVICE003, UsbFnDviceTestRemove003}, }; int32_t HdfUsbDeviceEntry(HdfTestMsg *msg) diff --git a/test/unittest/model/usb/src/usb_device_lite_cdcacm_test.c b/test/unittest/model/usb/device/src/usb_device_lite_cdcacm_test.c similarity index 91% rename from test/unittest/model/usb/src/usb_device_lite_cdcacm_test.c rename to test/unittest/model/usb/device/src/usb_device_lite_cdcacm_test.c index fa94ee7b4..cea77f8a7 100644 --- a/test/unittest/model/usb/src/usb_device_lite_cdcacm_test.c +++ b/test/unittest/model/usb/device/src/usb_device_lite_cdcacm_test.c @@ -13,6 +13,9 @@ * limitations under the License. */ #include "usb_device_lite_cdcacm_test.h" +#include "usbfn_dev_mgr.h" +#include "usbfn_cfg_mgr.h" +#include "adapter_if.h" static struct UsbInterfaceAssocDescriptor g_acmIadDescriptor = { .bLength = sizeof(g_acmIadDescriptor), @@ -57,7 +60,7 @@ static struct UsbInterfaceDescriptor g_acmDataInterfaceDesc = { .bNumEndpoints = DATA_EP_NUM, .bInterfaceClass = USB_DDK_CLASS_CDC_DATA, .bInterfaceSubClass = 0, - .bInterfaceProtocol = 2, + .bInterfaceProtocol = 0x2, .iInterface = ACM_DATA_IDX, }; @@ -760,11 +763,67 @@ void ReleaseAcmDevice(struct AcmDevice *acm) HDF_LOGE("%{public}s: acm is NULL", __func__); return; } - FreeNotifyRequest(acm); - FreeCtrlRequests(acm); + (void)FreeNotifyRequest(acm); + (void)FreeCtrlRequests(acm); (void)UsbFnCloseInterface(acm->ctrlIface.handle); (void)UsbFnCloseInterface(acm->dataIface.handle); - UsbFnStopRecvInterfaceEvent(acm->ctrlIface.fn); + (void)UsbFnStopRecvInterfaceEvent(acm->ctrlIface.fn); OsalMemFree(acm->port); } +int remove_usb_device(void) +{ + struct UsbFnDevice *device = NULL; + struct UsbFnDeviceMgr *devMgr = NULL; + struct UsbFnFuncMgr *funcMgr = NULL; + struct UsbFnInterfaceMgr *intfMgr = NULL; + const char *udcName = "100e0000.hidwc3_0"; + int i = 0; + int ret; + + device = (struct UsbFnDevice *)UsbFnGetDevice(udcName); + if (device == NULL) { + HDF_LOGE("%s: get device fail", __func__); + return HDF_FAILURE; + } + devMgr = (struct UsbFnDeviceMgr *)device; + devMgr->running = false; + while (devMgr->running != true) { + i++; + OsalMSleep(WAIT_100MS); + if (i > WAIT_TIMES) { + HDF_LOGE("%s: wait thread exit timeout", __func__); + break; + } + } + dprintf("%s, i = %d, running = %d\n", __func__, i, devMgr->running ? 1 : 0); + for (i = 0; i < device->numInterfaces; i++) { + intfMgr = devMgr->interfaceMgr + i; + if (intfMgr) { + UsbFnCloseInterface((UsbFnInterfaceHandle)intfMgr->handle); + } + } + for (i = 0; i < devMgr->numFunc; i++) { + funcMgr = devMgr->funcMgr + i; + if (intfMgr && intfMgr->isOpen) { + UsbFnStopRecvInterfaceEvent(&intfMgr->interface); + } + } + struct UsbFnAdapterOps *fnOps = UsbFnAdapterGetOps(); + ret = OsalThreadDestroy(&devMgr->thread); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%{public}s:%{public}d OsalThreadDestroy failed, ret=%{public}d", + __func__, __LINE__, ret); + return ret; + } + ret = fnOps->delDevice(devMgr->name, devMgr->udcName, devMgr->des); + if (ret) { + HDF_LOGE("%{public}s:%{public}d UsbFnMgrDeviceRemove failed", __func__, __LINE__); + return ret; + } + DListRemove(&device->object.entry); + UsbFnCfgMgrUnRegisterAllProp(); + + return 0; +} + diff --git a/test/unittest/model/usb/src/usb_device_lite_sdk_if_test.c b/test/unittest/model/usb/device/src/usb_device_lite_sdk_if_test.c similarity index 73% rename from test/unittest/model/usb/src/usb_device_lite_sdk_if_test.c rename to test/unittest/model/usb/device/src/usb_device_lite_sdk_if_test.c index d116eaba5..3a2e38ac2 100644 --- a/test/unittest/model/usb/src/usb_device_lite_sdk_if_test.c +++ b/test/unittest/model/usb/device/src/usb_device_lite_sdk_if_test.c @@ -18,9 +18,13 @@ #define HDF_LOG_TAG usb_device_sdk_test static struct AcmDevice *g_acmDevice = NULL; + +#include "usb_device_lite_sdk_io_test.c" + int32_t UsbFnDviceTestCreate(void) { dprintf("%s: start\n", __func__); + remove_usb_device(); g_acmDevice = SetUpAcmDevice(); if (g_acmDevice == NULL || g_acmDevice->fnDev == NULL) { HDF_LOGE("%s: UsbFnDviceTestCreate fail", __func__); @@ -42,7 +46,6 @@ int32_t UsbFnDviceTestCreate002(void) HDF_LOGE("%s: UsbFnDviceTestCreate success!!", __func__); return HDF_FAILURE; } - HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } @@ -58,7 +61,6 @@ int32_t UsbFnDviceTestCreate003(void) HDF_LOGE("%s: UsbFnDviceTestCreate success!!", __func__); return HDF_FAILURE; } - HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } @@ -74,7 +76,6 @@ int32_t UsbFnDviceTestCreate004(void) HDF_LOGE("%s: UsbFnDviceTestCreate success!!", __func__); return HDF_FAILURE; } - HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } @@ -90,13 +91,22 @@ int32_t UsbFnDviceTestCreate005(void) HDF_LOGE("%s: UsbFnDviceTestCreate success!!", __func__); return HDF_FAILURE; } - HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } int32_t UsbFnDviceTestCreate006(void) { - HDF_LOGI("%s: success", __func__); + struct UsbFnDevice *fnDev = NULL; + struct UsbFnDescriptorData descData; + const char *udcName = NULL; + + descData.type = USBFN_DESC_DATA_TYPE_DESC; + descData.descriptor = &g_acmFnDevice; + fnDev = (struct UsbFnDevice *)UsbFnCreateDevice(udcName, &descData); + if (fnDev != NULL) { + HDF_LOGE("%s: UsbFnDviceTestCreate success!!", __func__); + return HDF_FAILURE; + } return HDF_SUCCESS; } @@ -110,7 +120,7 @@ int32_t UsbFnDviceTestStatus(void) } ret = UsbFnGetDeviceState(g_acmDevice->fnDev, &devState); if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: get status error", __LINE__); + HDF_LOGE("%s: get status error", __func__); return HDF_FAILURE; } if (!(devState >= USBFN_STATE_BIND && devState <= USBFN_STATE_RESUME)) { @@ -126,7 +136,7 @@ int32_t UsbFnDviceTestStatus002(void) UsbFnDeviceState devState; ret = UsbFnGetDeviceState(NULL, &devState); if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: get status success!!", __LINE__); + HDF_LOGE("%s: get status success!!", __func__); return HDF_FAILURE; } return HDF_SUCCESS; @@ -135,7 +145,7 @@ int32_t UsbFnDviceTestStatus002(void) int32_t UsbFnDviceTestStatus003(void) { int ret; - int count = 0; + int count; UsbFnDeviceState devState; if (g_acmDevice == NULL || g_acmDevice->fnDev == NULL) { HDF_LOGE("%s: fnDev is invail", __func__); @@ -144,7 +154,7 @@ int32_t UsbFnDviceTestStatus003(void) for (count = 0; count < TEST_TIMES; count++) { ret = UsbFnGetDeviceState(g_acmDevice->fnDev, &devState); if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: get status error", __LINE__); + HDF_LOGE("%s: get status error", __func__); return HDF_FAILURE; } if (!(devState >= USBFN_STATE_BIND && devState <= USBFN_STATE_RESUME)) { @@ -160,7 +170,7 @@ int32_t UsbFnDviceTestStatus004(void) int ret; ret = UsbFnGetDeviceState(NULL, NULL); if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: get status success!!", __LINE__); + HDF_LOGE("%s: get status success!!", __func__); return HDF_FAILURE; } return HDF_SUCCESS; @@ -168,11 +178,17 @@ int32_t UsbFnDviceTestStatus004(void) int32_t UsbFnDviceTestStatus005(void) { - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestStatus006(void) -{ + int ret; + UsbFnDeviceState *devState = NULL; + if (g_acmDevice == NULL || g_acmDevice->fnDev == NULL) { + HDF_LOGE("%s: fnDev is invail", __func__); + return HDF_FAILURE; + } + ret = UsbFnGetDeviceState(g_acmDevice->fnDev, devState); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: get status success!!", __func__); + return HDF_FAILURE; + } return HDF_SUCCESS; } @@ -238,6 +254,13 @@ int32_t UsbFnDviceTestGetDevice005(void) int32_t UsbFnDviceTestGetDevice006(void) { + const struct UsbFnDevice *device = NULL; + const char *udcName = " 100e0000.hidwc3_0"; + device = UsbFnGetDevice(udcName); + if (device != NULL) { + HDF_LOGE("%s: get device success!!", __func__); + return HDF_FAILURE; + } return HDF_SUCCESS; } @@ -254,7 +277,6 @@ int32_t UsbFnDviceTestGetInterface(void) return HDF_FAILURE; } return HDF_SUCCESS; - } int32_t UsbFnDviceTestGetInterface002(void) @@ -444,529 +466,244 @@ int32_t UsbFnDviceTestGetPipeInfo006(void) return HDF_SUCCESS; } -static void ReadComplete(uint8_t pipe, struct UsbFnRequest *req) +static int32_t PropCallBack(const struct UsbFnInterface *intf, const char *name, + const char *value) { - if (NULL == req) { - return; - } - if (req->actual) { - uint8_t *data = (uint8_t *)req->buf; - data[req->actual] = '\0'; - dprintf("receive [%d] bytes data: %s\n", req->actual, data); - if (strcmp((const char *)data, "q") == 0 || \ - strcmp((const char *)data, "q\n") == 0) { - g_acmDevice->submit_exit = 1; - } + if (intf == NULL || name == NULL || value == NULL) { + return HDF_FAILURE; } - g_acmDevice->submit = 1; + return HDF_SUCCESS; } -int32_t UsbFnDviceTestRequestAsync(void) +int32_t UsbFnDviceTestRegistProp(void) { - struct UsbFnRequest *req = NULL; int ret; - - ret = UsbFnSubmitRequestAsync(req); - if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: async Request success!!", __func__); + struct UsbFnRegistInfo info; + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { + HDF_LOGE("%s: ctrlIface.handle is invail", __func__); + return HDF_FAILURE; + } + info.name = "name_test"; + info.value = "test_value"; + info.getProp = PropCallBack; + info.setProp = PropCallBack; + ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, &info); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: Regist Prop error", __func__); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestRequestAsync002(void) +int32_t UsbFnDviceTestRegistProp002(void) { - struct UsbFnRequest *req = NULL; - int ret = HDF_SUCCESS; - int ret1 = HDF_SUCCESS; - int waitMs = 100; - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { - HDF_LOGE("%s: dataIface.fn is invail", __func__); - return HDF_FAILURE; - } - dprintf("wait receiving data form host, please connect\n"); - req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, - g_acmDevice->dataOutPipe.maxPacketSize); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); + int ret; + struct UsbFnRegistInfo info; + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { + HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - req->complete = ReadComplete; - req->context = g_acmDevice; - while (g_acmDevice->connect == false) { - OsalMSleep(waitMs); - } - while (1) { - g_acmDevice->submit = 0; - ret = UsbFnSubmitRequestAsync(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: async Request error", __func__); - ret = HDF_FAILURE; - break; - } - while(g_acmDevice->submit == 0) { - OsalMSleep(waitMs); - } - if (req->actual > 0) { - break; - } - } - ret1 = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret1) { - HDF_LOGE("%s: free Request error", __func__); + info.name = "name_test"; + info.value = "test_value"; + info.getProp = PropCallBack; + info.setProp = PropCallBack; + ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, &info); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: Regist Prop success!!", __func__); return HDF_FAILURE; } - return ret; + return HDF_SUCCESS; } -int32_t UsbFnDviceTestRequestAsync003(void) +int32_t UsbFnDviceTestRegistProp003(void) { - struct UsbFnRequest *req = NULL; - int ret = HDF_SUCCESS; - int ret1 = HDF_SUCCESS; - int waitMs = 100; - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { - HDF_LOGE("%s: dataIface.fn is invail", __func__); - return HDF_FAILURE; - } - dprintf("wait receiving data form host, please connect\n"); - req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, - g_acmDevice->dataOutPipe.maxPacketSize); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); + int ret; + struct UsbFnRegistInfo info; + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { + HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - req->complete = ReadComplete; - req->context = g_acmDevice; - while (g_acmDevice->connect == false) { - OsalMSleep(waitMs); - } - g_acmDevice->submit_exit = 0; - while (g_acmDevice->submit_exit == 0) { - g_acmDevice->submit = 0; - ret = UsbFnSubmitRequestAsync(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: async Request error", __func__); - ret = HDF_FAILURE; - break; - } - while(g_acmDevice->submit == 0) { - OsalMSleep(waitMs); - } - } - ret1 = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret1) { - HDF_LOGE("%s: free Request error", __func__); + info.name = NULL; + info.value = "test_value"; + info.getProp = PropCallBack; + info.setProp = PropCallBack; + ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, &info); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: Regist Prop success!!", __func__); return HDF_FAILURE; } - return ret; -} - -static void WriteComplete(uint8_t pipe, struct UsbFnRequest *req) -{ - dprintf("write data status = %d\n", req->status); - g_acmDevice->submit = 1; + return HDF_SUCCESS; } -int32_t UsbFnDviceTestRequestAsync004(void) +int32_t UsbFnDviceTestRegistProp004(void) { - struct UsbFnRequest *req = NULL; - int ret = HDF_SUCCESS; - - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { - HDF_LOGE("%s: dataIface.fn is invail", __func__); - return HDF_FAILURE; - } - req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, - g_acmDevice->dataInPipe.maxPacketSize); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); - return HDF_FAILURE; - } - req->complete = WriteComplete; - req->context = g_acmDevice; - g_acmDevice->submit = 0; - dprintf("------send \"abc\" to host------\n"); - memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "abc", strlen("abc")); - req->length = strlen("abc"); - ret = UsbFnSubmitRequestAsync(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: async Request error", __func__); + int ret; + struct UsbFnRegistInfo info; + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { + HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - while(g_acmDevice->submit == 0) { - OsalMSleep(1); - } - g_acmDevice->submit = 0; - ret = UsbFnFreeRequest(req); + info.name = "name_test4"; + info.value = "test_value"; + info.getProp = NULL; + info.setProp = PropCallBack; + ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, &info); if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: free Request error", __func__); + HDF_LOGE("%s: Regist Prop error", __func__); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestRequestAsync005(void) +int32_t UsbFnDviceTestRegistProp005(void) { - struct UsbFnRequest *req = NULL; - int loopTime = TEST_TIMES; - int ret = HDF_SUCCESS; + int ret; + struct UsbFnRegistInfo info; + struct UsbFnInterface *fn = NULL; - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { - HDF_LOGE("%s: dataIface.fn is invail", __func__); + info.name = "name_test5"; + info.value = "test_value"; + info.getProp = PropCallBack; + info.setProp = PropCallBack; + ret = UsbFnRegistInterfaceProp(fn, &info); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: Regist Prop success!!", __func__); return HDF_FAILURE; } - dprintf("------send \"xyz\" 10 times to host------\n"); - while (loopTime--) { - req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, - g_acmDevice->dataInPipe.maxPacketSize); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); - return HDF_FAILURE; - } - req->complete = WriteComplete; - req->context = g_acmDevice; - g_acmDevice->submit = 0; - memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "xyz", strlen("xyz")); - req->length = strlen("xyz"); - ret = UsbFnSubmitRequestAsync(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: async Request error", __func__); - return HDF_FAILURE; - } - while(g_acmDevice->submit == 0) { - OsalMSleep(1); - } - g_acmDevice->submit = 0; - ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: free Request error", __func__); - return HDF_FAILURE; - } - } - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestRequestAsync006(void) -{ return HDF_SUCCESS; } -int32_t UsbFnDviceTestRequestSync(void) +int32_t UsbFnDviceTestRegistProp006(void) { - struct UsbFnRequest *req = NULL; int ret; - ret = UsbFnSubmitRequestSync(req, 0); + struct UsbFnRegistInfo *info = NULL; + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { + HDF_LOGE("%s: ctrlIface.handle is invail", __func__); + return HDF_FAILURE; + } + ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, info); if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: sync Request success!!", __func__); + HDF_LOGE("%s: Regist Prop success!!", __func__); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestRequestSync002(void) +int32_t UsbFnDviceTestRegistProp007(void) { - struct UsbFnRequest *req = NULL; int ret; - uint8_t *data; - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { - HDF_LOGE("%s: dataIface.fn is invail", __func__); - return HDF_FAILURE; - } - dprintf("wait receiving data form host\n"); - req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, - g_acmDevice->dataOutPipe.maxPacketSize); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); - return HDF_FAILURE; - } - ret = UsbFnSubmitRequestSync(req, 0); - if (ret != 0 || req->actual <= 0 || req->status != USB_REQUEST_COMPLETED) { - HDF_LOGE("%s: Sync Request error", __func__); + struct UsbFnRegistInfo info; + if (g_acmDevice == NULL || g_acmDevice->dataIface.fn == NULL) { + HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - data = (uint8_t *)req->buf; - data[req->actual] = '\0'; - dprintf("receive data from host: %s\n", data); - ret = UsbFnFreeRequest(req); + info.name = "name_test"; + info.value = "test_value"; + info.getProp = PropCallBack; + info.setProp = PropCallBack; + ret = UsbFnRegistInterfaceProp(g_acmDevice->dataIface.fn, &info); if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: free Request error", __func__); + HDF_LOGE("%s: Regist Prop error", __func__); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestRequestSync003(void) +int32_t UsbFnDviceTestGetProp(void) { - struct UsbFnRequest *req = NULL; int ret; - int submit_exit = 0; - uint8_t *data; - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { - HDF_LOGE("%s: dataIface.fn is invail", __func__); + char buffer[BUFFER_LEN] = {0}; + char *buff = buffer; + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { + HDF_LOGE("%s: ctrlIface.fn is invail", __func__); return HDF_FAILURE; } - dprintf("receive data until 'q' exit\n"); - req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, - g_acmDevice->dataOutPipe.maxPacketSize); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); + ret = UsbFnGetInterfaceProp(g_acmDevice->ctrlIface.fn, "name_test", buff); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: Get Prop error", __func__); return HDF_FAILURE; } - while (submit_exit == 0){ - ret = UsbFnSubmitRequestSync(req, 0); - if (ret != 0 || req->actual <= 0 || req->status != USB_REQUEST_COMPLETED) { - HDF_LOGE("%s: Sync Request error", __func__); - break; - } - data = (uint8_t *)req->buf; - data[req->actual] = '\0'; - if (strcmp((const char *)data, "q") == 0 || \ - strcmp((const char *)data, "q\n") == 0) { - submit_exit = 1; - } - dprintf("receive data from host: %s\n", data); - } - ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: free Request error", __func__); + if (strcmp(buffer, "test_value")) { + HDF_LOGE("%s: Get Prop value error", __func__); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestRequestSync004(void) +int32_t UsbFnDviceTestGetProp002(void) { - struct UsbFnRequest *req = NULL; - int ret = HDF_SUCCESS; - - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { - HDF_LOGE("%s: dataIface.fn is invail", __func__); + int ret; + char buffer[BUFFER_LEN] = {0}; + char *buff = buffer; + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { + HDF_LOGE("%s: ctrlIface.fn is invail", __func__); return HDF_FAILURE; } - req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, - g_acmDevice->dataInPipe.maxPacketSize); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); + ret = UsbFnGetInterfaceProp(g_acmDevice->ctrlIface.fn, "unkown", buff); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: Get Prop success!!", __func__); return HDF_FAILURE; } - dprintf("------send \"abc\" to host------\n"); - memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "abc", strlen("abc")); - req->length = strlen("abc"); - ret = UsbFnSubmitRequestSync(req, 0); - if (HDF_SUCCESS != ret || (req->actual != strlen("abc")) || \ - (req->status != USB_REQUEST_COMPLETED)) { - HDF_LOGE("%s: async Request error", __func__); + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestGetProp003(void) +{ + int ret; + char buffer[BUFFER_LEN] = {0}; + char *buff = buffer; + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { + HDF_LOGE("%s: ctrlIface.fn is invail", __func__); return HDF_FAILURE; } - ret = UsbFnFreeRequest(req); + ret = UsbFnGetInterfaceProp(g_acmDevice->ctrlIface.fn, "idProduct", buff); if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: free Request error", __func__); + HDF_LOGE("%s: Get Prop error", __func__); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestRequestSync005(void) -{ - struct UsbFnRequest *req = NULL; - int loopTime = TEST_TIMES; - int ret = HDF_SUCCESS; - - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { - HDF_LOGE("%s: dataIface.fn is invail", __func__); - return HDF_FAILURE; - } - dprintf("------send \"abcdefg\" 10 times to host------\n"); - while (loopTime--) { - req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, - g_acmDevice->dataInPipe.maxPacketSize); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); - return HDF_FAILURE; - } - memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "abcdefg", strlen("abcdefg")); - req->length = strlen("abcdefg"); - ret = UsbFnSubmitRequestSync(req, 0); - if (HDF_SUCCESS != ret || (req->actual != strlen("abcdefg")) || \ - (req->status != USB_REQUEST_COMPLETED)) { - HDF_LOGE("%s: async Request error", __func__); - return HDF_FAILURE; - } - ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: free Request error", __func__); - return HDF_FAILURE; - } - } - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestRequestSync006(void) -{ - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestRequestSync007(void) -{ - return HDF_SUCCESS; -} - -static int32_t PropCallBack(const struct UsbFnInterface *intf, const char *name, - const char *value) -{ - if (intf == NULL || name == NULL || value == NULL) { - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestRegistProp(void) -{ - int ret; - struct UsbFnRegistInfo info; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { - HDF_LOGE("%s: ctrlIface.handle is invail", __func__); - return HDF_FAILURE; - } - info.name = "name_test"; - info.value = "test_value"; - info.getProp = PropCallBack; - info.setProp = PropCallBack; - ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, &info); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: Regist Prop error", __func__); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestRegistProp002(void) -{ - int ret; - struct UsbFnRegistInfo info; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { - HDF_LOGE("%s: ctrlIface.handle is invail", __func__); - return HDF_FAILURE; - } - info.name = "name_test"; - info.value = "test_value"; - info.getProp = PropCallBack; - info.setProp = PropCallBack; - ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, &info); - if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: Regist Prop success!!", __func__); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestRegistProp003(void) -{ - int ret; - struct UsbFnRegistInfo info; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { - HDF_LOGE("%s: ctrlIface.handle is invail", __func__); - return HDF_FAILURE; - } - info.name = NULL; - info.value = "test_value"; - info.getProp = PropCallBack; - info.setProp = PropCallBack; - ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, &info); - if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: Regist Prop success!!", __func__); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestRegistProp004(void) -{ - int ret; - struct UsbFnRegistInfo info; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { - HDF_LOGE("%s: ctrlIface.handle is invail", __func__); - return HDF_FAILURE; - } - info.name = "name_test4"; - info.value = "test_value"; - info.getProp = NULL; - info.setProp = PropCallBack; - ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, &info); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: Regist Prop error", __func__); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestRegistProp005(void) +int32_t UsbFnDviceTestGetProp004(void) { int ret; - struct UsbFnRegistInfo info; + char buffer[BUFFER_LEN] = {0}; + char *buff = buffer; struct UsbFnInterface *fn = NULL; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { - HDF_LOGE("%s: ctrlIface.handle is invail", __func__); - return HDF_FAILURE; - } - info.name = "name_test5"; - info.value = "test_value"; - info.getProp = PropCallBack; - info.setProp = PropCallBack; - ret = UsbFnRegistInterfaceProp(fn, &info); - if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: Regist Prop success!!", __func__); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} -int32_t UsbFnDviceTestRegistProp006(void) -{ - int ret; - struct UsbFnRegistInfo *info = NULL; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { - HDF_LOGE("%s: ctrlIface.handle is invail", __func__); - return HDF_FAILURE; - } - ret = UsbFnRegistInterfaceProp(g_acmDevice->ctrlIface.fn, info); + ret = UsbFnGetInterfaceProp(fn, "idProduct", buff); if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: Regist Prop success!!", __func__); + HDF_LOGE("%s: Get Prop success!!", __func__); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestGetProp(void) +int32_t UsbFnDviceTestGetProp005(void) { int ret; - char buffer[64] = {0}; + char buffer[BUFFER_LEN] = {0}; + char *buff = buffer; if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { HDF_LOGE("%s: ctrlIface.fn is invail", __func__); return HDF_FAILURE; } - ret = UsbFnGetInterfaceProp(g_acmDevice->ctrlIface.fn, "name_test", buffer); + ret = UsbFnGetInterfaceProp(g_acmDevice->ctrlIface.fn, "idVendor", buff); if (HDF_SUCCESS != ret) { HDF_LOGE("%s: Get Prop error", __func__); return HDF_FAILURE; } - if (strcmp(buffer, "test_value")) { - HDF_LOGE("%s: Get Prop value error", __func__); - return HDF_FAILURE; - } return HDF_SUCCESS; } -int32_t UsbFnDviceTestGetProp002(void) +int32_t UsbFnDviceTestGetProp006(void) { int ret; - char buffer[64] = {0}; if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { HDF_LOGE("%s: ctrlIface.fn is invail", __func__); return HDF_FAILURE; } - ret = UsbFnGetInterfaceProp(g_acmDevice->ctrlIface.fn, "unkown", buffer); + ret = UsbFnGetInterfaceProp(g_acmDevice->ctrlIface.fn, "name_test", NULL); if (HDF_SUCCESS == ret) { HDF_LOGE("%s: Get Prop success!!", __func__); return HDF_FAILURE; @@ -974,45 +711,37 @@ int32_t UsbFnDviceTestGetProp002(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestGetProp003(void) +int32_t UsbFnDviceTestGetProp007(void) { int ret; - char buffer[64] = {0}; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { + char buffer[BUFFER_LEN] = {0}; + char *buff = buffer; + if (g_acmDevice == NULL || g_acmDevice->dataIface.fn == NULL) { HDF_LOGE("%s: ctrlIface.fn is invail", __func__); return HDF_FAILURE; } - ret = UsbFnGetInterfaceProp(g_acmDevice->ctrlIface.fn, "idProduct", buffer); + ret = UsbFnGetInterfaceProp(g_acmDevice->dataIface.fn, "name_test", buff); if (HDF_SUCCESS != ret) { HDF_LOGE("%s: Get Prop error", __func__); return HDF_FAILURE; } - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestGetProp004(void) -{ - int ret; - char buffer[64] = {0}; - struct UsbFnInterface *fn = NULL; - - ret = UsbFnGetInterfaceProp(fn, "idProduct", buffer); - if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: Get Prop success!!", __func__); + if (strcmp(buffer, "test_value")) { + HDF_LOGE("%s: Get Prop value error", __func__); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestGetProp005(void) +int32_t UsbFnDviceTestGetProp008(void) { int ret; - char buffer[64] = {0}; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { + char buffer[BUFFER_LEN] = {0}; + char *buff = buffer; + if (g_acmDevice == NULL || g_acmDevice->dataIface.fn == NULL) { HDF_LOGE("%s: ctrlIface.fn is invail", __func__); return HDF_FAILURE; } - ret = UsbFnGetInterfaceProp(g_acmDevice->ctrlIface.fn, "idVendor", buffer); + ret = UsbFnGetInterfaceProp(g_acmDevice->dataIface.fn, "idVendor", buff); if (HDF_SUCCESS != ret) { HDF_LOGE("%s: Get Prop error", __func__); return HDF_FAILURE; @@ -1020,21 +749,6 @@ int32_t UsbFnDviceTestGetProp005(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestGetProp006(void) -{ - int ret; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { - HDF_LOGE("%s: ctrlIface.fn is invail", __func__); - return HDF_FAILURE; - } - ret = UsbFnGetInterfaceProp(g_acmDevice->ctrlIface.fn, "name_test", NULL); - if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: Get Prop success!!", __func__); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - int32_t UsbFnDviceTestSetProp(void) { int ret; @@ -1069,10 +783,7 @@ int32_t UsbFnDviceTestSetProp003(void) { int ret; struct UsbFnInterface *fn = NULL; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { - HDF_LOGE("%s: ctrlIface.fn is invail", __func__); - return HDF_FAILURE; - } + ret = UsbFnSetInterfaceProp(fn, "name_test", "hellotest"); if (HDF_SUCCESS == ret) { HDF_LOGE("%s: Set Prop success!!", __func__); @@ -1099,6 +810,16 @@ int32_t UsbFnDviceTestSetProp004(void) int32_t UsbFnDviceTestSetProp005(void) { + int ret; + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { + HDF_LOGE("%s: ctrlIface.fn is invail", __func__); + return HDF_FAILURE; + } + ret = UsbFnSetInterfaceProp(g_acmDevice->ctrlIface.fn, "idVendor", "0x625"); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: Set Prop error!!", __func__); + return HDF_FAILURE; + } return HDF_SUCCESS; } @@ -1111,7 +832,22 @@ int32_t UsbFnDviceTestSetProp006(void) } ret = UsbFnSetInterfaceProp(g_acmDevice->ctrlIface.fn, "bLength", "0x14"); if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: Get Prop success!!", __func__); + HDF_LOGE("%s: Set Prop success!!", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestSetProp007(void) +{ + int ret; + if (g_acmDevice == NULL || g_acmDevice->dataIface.fn == NULL) { + HDF_LOGE("%s: ctrlIface.fn is invail", __func__); + return HDF_FAILURE; + } + ret = UsbFnSetInterfaceProp(g_acmDevice->dataIface.fn, "name_test", "hello"); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: Set Prop error", __func__); return HDF_FAILURE; } return HDF_SUCCESS; @@ -1148,7 +884,7 @@ int32_t UsbFnDviceTestAllocCtrlRequest002(void) return HDF_FAILURE; } req = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, - sizeof(struct UsbCdcLineCoding) + sizeof(struct UsbCdcLineCoding)); + sizeof(struct UsbCdcLineCoding) + sizeof(struct UsbCdcLineCoding)); if (req == NULL) { HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; @@ -1208,10 +944,7 @@ int32_t UsbFnDviceTestAllocCtrlRequest005(void) int ret; struct UsbFnRequest *req = NULL; UsbFnInterfaceHandle handle = NULL; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { - HDF_LOGE("%s: dataIface.handle is invail", __func__); - return HDF_FAILURE; - } + req = UsbFnAllocCtrlRequest(handle, g_acmDevice->notifyPipe.maxPacketSize); if (req != NULL) { @@ -1247,38 +980,34 @@ int32_t UsbFnDviceTestAllocCtrlRequest006(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestAllocRequest(void) +int32_t UsbFnDviceTestAllocCtrlRequest007(void) { int ret; struct UsbFnRequest *req = NULL; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { - HDF_LOGE("%s: ctrlIface.handle is invail", __func__); - return HDF_FAILURE; - } - req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.id, - sizeof(struct UsbCdcNotification)); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.handle is invail", __func__); return HDF_FAILURE; } - ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: free Request error", __func__); + req = UsbFnAllocCtrlRequest(g_acmDevice->dataIface.handle, 0); + if (req != NULL) { + HDF_LOGE("%s: alloc req success!!", __func__); + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestAllocRequest002(void) +int32_t UsbFnDviceTestAllocCtrlRequest008(void) { int ret; struct UsbFnRequest *req = NULL; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { - HDF_LOGE("%s: ctrlIface.handle is invail", __func__); - return HDF_FAILURE; - } - req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.id, - 0); + UsbFnInterfaceHandle handle = NULL; + + req = UsbFnAllocCtrlRequest(handle, 0); if (req != NULL) { HDF_LOGE("%s: alloc req success!!", __func__); ret = UsbFnFreeRequest(req); @@ -1291,7 +1020,7 @@ int32_t UsbFnDviceTestAllocRequest002(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestAllocRequest003(void) +int32_t UsbFnDviceTestAllocRequest(void) { int ret; struct UsbFnRequest *req = NULL; @@ -1300,7 +1029,7 @@ int32_t UsbFnDviceTestAllocRequest003(void) return HDF_FAILURE; } req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.id, - 0x800); + sizeof(struct UsbCdcNotification)); if (req == NULL) { HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; @@ -1313,16 +1042,16 @@ int32_t UsbFnDviceTestAllocRequest003(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestAllocRequest004(void) +int32_t UsbFnDviceTestAllocRequest002(void) { int ret; struct UsbFnRequest *req = NULL; - UsbFnInterfaceHandle handle = NULL; if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - req = UsbFnAllocRequest(handle, g_acmDevice->notifyPipe.id, 0x800); + req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, + g_acmDevice->notifyPipe.id, 0); if (req != NULL) { HDF_LOGE("%s: alloc req success!!", __func__); ret = UsbFnFreeRequest(req); @@ -1335,7 +1064,7 @@ int32_t UsbFnDviceTestAllocRequest004(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestAllocRequest005(void) +int32_t UsbFnDviceTestAllocRequest003(void) { int ret; struct UsbFnRequest *req = NULL; @@ -1343,7 +1072,27 @@ int32_t UsbFnDviceTestAllocRequest005(void) HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, 0x20, 0x800); + req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, + g_acmDevice->notifyPipe.id, 0x800); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestAllocRequest004(void) +{ + int ret; + struct UsbFnRequest *req = NULL; + UsbFnInterfaceHandle handle = NULL; + + req = UsbFnAllocRequest(handle, g_acmDevice->notifyPipe.id, 0x800); if (req != NULL) { HDF_LOGE("%s: alloc req success!!", __func__); ret = UsbFnFreeRequest(req); @@ -1356,7 +1105,7 @@ int32_t UsbFnDviceTestAllocRequest005(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestAllocRequest006(void) +int32_t UsbFnDviceTestAllocRequest005(void) { int ret; struct UsbFnRequest *req = NULL; @@ -1364,8 +1113,7 @@ int32_t UsbFnDviceTestAllocRequest006(void) HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, - g_acmDevice->notifyPipe.id, 0x801); + req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, 0x20, 0x800); if (req != NULL) { HDF_LOGE("%s: alloc req success!!", __func__); ret = UsbFnFreeRequest(req); @@ -1378,7 +1126,7 @@ int32_t UsbFnDviceTestAllocRequest006(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestFreeRequest(void) +int32_t UsbFnDviceTestAllocRequest006(void) { int ret; struct UsbFnRequest *req = NULL; @@ -1386,21 +1134,21 @@ int32_t UsbFnDviceTestFreeRequest(void) HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.id, - g_acmDevice->notifyPipe.maxPacketSize); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); - return HDF_FAILURE; - } - ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: free Request error", __func__); + req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, + g_acmDevice->notifyPipe.id, 0x801); + if (req != NULL) { + HDF_LOGE("%s: alloc req success!!", __func__); + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestFreeRequest002(void) +int32_t UsbFnDviceTestAllocRequest007(void) { int ret; struct UsbFnRequest *req = NULL; @@ -1408,21 +1156,21 @@ int32_t UsbFnDviceTestFreeRequest002(void) HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, - g_acmDevice->dataInPipe.maxPacketSize); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); - return HDF_FAILURE; - } - ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: free Request error", __func__); + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, + g_acmDevice->dataOutPipe.id, 0); + if (req != NULL) { + HDF_LOGE("%s: alloc req success!!", __func__); + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestFreeRequest003(void) +int32_t UsbFnDviceTestAllocRequest008(void) { int ret; struct UsbFnRequest *req = NULL; @@ -1430,32 +1178,32 @@ int32_t UsbFnDviceTestFreeRequest003(void) HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, - g_acmDevice->dataOutPipe.maxPacketSize); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); - return HDF_FAILURE; - } - ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: free Request error", __func__); + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, + 0x20, g_acmDevice->dataOutPipe.maxPacketSize); + if (req != NULL) { + HDF_LOGE("%s: alloc req success!!", __func__); + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestFreeRequest004(void) +int32_t UsbFnDviceTestAllocRequest009(void) { int ret; struct UsbFnRequest *req = NULL; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - req = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, - g_acmDevice->notifyPipe.maxPacketSize); + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, + g_acmDevice->dataOutPipe.id, g_acmDevice->dataOutPipe.maxPacketSize); if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); + HDF_LOGE("%s: alloc req success!!", __func__); return HDF_FAILURE; } ret = UsbFnFreeRequest(req); @@ -1466,68 +1214,21 @@ int32_t UsbFnDviceTestFreeRequest004(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestFreeRequest005(void) +int32_t UsbFnDviceTestFreeRequest(void) { int ret; - int count; struct UsbFnRequest *req = NULL; if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - for (count = 0; count < TEST_TIMES; count++) { - req = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, - g_acmDevice->notifyPipe.maxPacketSize); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); - return HDF_FAILURE; - } - ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: free Request error", __func__); - return HDF_FAILURE; - } - } - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestFreeRequest006(void) -{ - int ret; - struct UsbFnRequest *req = NULL; - ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: free Request success!!", __func__); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestGetRequestStatus(void) -{ - int ret; - UsbRequestStatus status; - struct UsbFnRequest *notifyReq = NULL; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { - HDF_LOGE("%s: ctrlIface.handle is invail", __func__); - return HDF_FAILURE; - } - notifyReq = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.id, - sizeof(struct UsbCdcNotification)); - if (notifyReq == NULL) { + req = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.id, + g_acmDevice->notifyPipe.maxPacketSize); + if (req == NULL) { HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; } - ret = UsbFnGetRequestStatus(notifyReq, &status); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: get status error", __func__); - return HDF_FAILURE; - } - if (!(status >= USB_REQUEST_COMPLETED && status <= USB_REQUEST_OVERFLOW)) { - HDF_LOGE("%s: device status error", __func__); - return HDF_FAILURE; - } - ret = UsbFnFreeRequest(notifyReq); + ret = UsbFnFreeRequest(req); if (HDF_SUCCESS != ret) { HDF_LOGE("%s: free Request error", __func__); return HDF_FAILURE; @@ -1535,32 +1236,21 @@ int32_t UsbFnDviceTestGetRequestStatus(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestGetRequestStatus002(void) +int32_t UsbFnDviceTestFreeRequest002(void) { int ret; - UsbRequestStatus status; - struct UsbFnRequest *notifyReq = NULL; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { + struct UsbFnRequest *req = NULL; + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - notifyReq = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, - sizeof(struct UsbCdcNotification)); - if (notifyReq == NULL) { + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, + g_acmDevice->dataInPipe.maxPacketSize); + if (req == NULL) { HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; } - ret = UsbFnGetRequestStatus(notifyReq, &status); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: get status error", __func__); - dprintf("%s: get status error", __func__); - return HDF_FAILURE; - } - if (!(status >= USB_REQUEST_COMPLETED && status <= USB_REQUEST_OVERFLOW)) { - HDF_LOGE("%s: device status error", __func__); - return HDF_FAILURE; - } - ret = UsbFnFreeRequest(notifyReq); + ret = UsbFnFreeRequest(req); if (HDF_SUCCESS != ret) { HDF_LOGE("%s: free Request error", __func__); return HDF_FAILURE; @@ -1568,7 +1258,7 @@ int32_t UsbFnDviceTestGetRequestStatus002(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestGetRequestStatus003(void) +int32_t UsbFnDviceTestFreeRequest003(void) { int ret; struct UsbFnRequest *req = NULL; @@ -1582,50 +1272,29 @@ int32_t UsbFnDviceTestGetRequestStatus003(void) HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; } - ret = UsbFnGetRequestStatus(req, NULL); - if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: get status success!!", __func__); - ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: free Request error", __func__); - return HDF_FAILURE; - } + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); return HDF_FAILURE; } - return HDF_SUCCESS; } -int32_t UsbFnDviceTestGetRequestStatus004(void) +int32_t UsbFnDviceTestFreeRequest004(void) { int ret; - UsbRequestStatus status; - struct UsbFnRequest *notifyReq = NULL; - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + struct UsbFnRequest *req = NULL; + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - notifyReq = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, - g_acmDevice->dataOutPipe.maxPacketSize); - if (notifyReq == NULL) { + req = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, + g_acmDevice->notifyPipe.maxPacketSize); + if (req == NULL) { HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; } - ret = UsbFnSubmitRequestAsync(notifyReq); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: get status error", __func__); - return HDF_FAILURE; - } - ret = UsbFnGetRequestStatus(notifyReq, &status); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: get status error", __func__); - return HDF_FAILURE; - } - if (!(status >= USB_REQUEST_COMPLETED && status <= USB_REQUEST_OVERFLOW)) { - HDF_LOGE("%s: device status error", __func__); - return HDF_FAILURE; - } - ret = UsbFnFreeRequest(notifyReq); + ret = UsbFnFreeRequest(req); if (HDF_SUCCESS != ret) { HDF_LOGE("%s: free Request error", __func__); return HDF_FAILURE; @@ -1633,134 +1302,68 @@ int32_t UsbFnDviceTestGetRequestStatus004(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestGetRequestStatus005(void) -{ - int ret; - UsbRequestStatus status; - struct UsbFnRequest *notifyReq = NULL; - ret = UsbFnGetRequestStatus(notifyReq, &status); - if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: get status success!!", __func__); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestGetRequestStatus006(void) -{ - return HDF_SUCCESS; -} - -static void TestCancelComplete(uint8_t pipe, struct UsbFnRequest *req) -{ - dprintf("%s, req->buf = 0x%x\n", __func__, (uint32_t)req->buf); - g_acmDevice->haved_submit = true; -} - -int32_t UsbFnDviceTestCancelRequest(void) -{ - int ret; - struct UsbFnRequest *notifyReq = NULL; - ret = UsbFnCancelRequest(notifyReq); - if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: cancel request success!!", __func__); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestCancelRequest002(void) +int32_t UsbFnDviceTestFreeRequest005(void) { int ret; + int count; struct UsbFnRequest *req = NULL; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { - HDF_LOGE("%s: CtrlIface.handle is invail", __func__); - return HDF_FAILURE; - } - req = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, - sizeof(struct UsbCdcNotification)); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); + HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - ret = UsbFnCancelRequest(req); - if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: cancel request success", __func__); + for (count = 0; count < TEST_TIMES; count++) { + req = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, + g_acmDevice->notifyPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } ret = UsbFnFreeRequest(req); if (HDF_SUCCESS != ret) { HDF_LOGE("%s: free Request error", __func__); return HDF_FAILURE; } - return HDF_FAILURE; - } - ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: free Request error", __func__); - return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestCancelRequest003(void) +int32_t UsbFnDviceTestFreeRequest006(void) { int ret; struct UsbFnRequest *req = NULL; - - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { - HDF_LOGE("%s: dataIface.handle is invail", __func__); - return HDF_FAILURE; - } - req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, - g_acmDevice->dataInPipe.maxPacketSize); - if (req == NULL) { - HDF_LOGE("%s: alloc req fail", __func__); - return HDF_FAILURE; - } - ret = UsbFnCancelRequest(req); - if (HDF_SUCCESS == ret) { - dprintf("%s: cancel request success\n", __func__); - ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret) { - dprintf("%s: free Request error", __func__); - return HDF_FAILURE; - } - return HDF_FAILURE; - } ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: free Request error", __func__); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: free Request success!!", __func__); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestCancelRequest004(void) +int32_t UsbFnDviceTestGetRequestStatus(void) { int ret; - struct UsbFnRequest *req = NULL; - - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { - HDF_LOGE("%s: dataIface.handle is invail", __func__); + UsbRequestStatus status; + struct UsbFnRequest *notifyReq = NULL; + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { + HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, - g_acmDevice->dataInPipe.maxPacketSize); - if (req == NULL) { + notifyReq = UsbFnAllocRequest(g_acmDevice->ctrlIface.handle, g_acmDevice->notifyPipe.id, + sizeof(struct UsbCdcNotification)); + if (notifyReq == NULL) { HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; } - ret = UsbFnCancelRequest(req); - if (HDF_SUCCESS == ret) { - dprintf("%s: cancel request success\n", __func__); - ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret) { - dprintf("%s: free Request error", __func__); - return HDF_FAILURE; - } + ret = UsbFnGetRequestStatus(notifyReq, &status); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: get status error", __func__); + return HDF_FAILURE; + } + if (!(status >= USB_REQUEST_COMPLETED && status <= USB_REQUEST_OVERFLOW)) { + HDF_LOGE("%s: device status error", __func__); return HDF_FAILURE; } - ret = UsbFnFreeRequest(req); + ret = UsbFnFreeRequest(notifyReq); if (HDF_SUCCESS != ret) { HDF_LOGE("%s: free Request error", __func__); return HDF_FAILURE; @@ -1768,42 +1371,32 @@ int32_t UsbFnDviceTestCancelRequest004(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestCancelRequest005(void) +int32_t UsbFnDviceTestGetRequestStatus002(void) { int ret; - struct UsbFnRequest *req = NULL; - - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { - HDF_LOGE("%s: dataIface.handle is invail", __func__); + UsbRequestStatus status; + struct UsbFnRequest *notifyReq = NULL; + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { + HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, - g_acmDevice->dataInPipe.maxPacketSize); - if (req == NULL) { + notifyReq = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, + sizeof(struct UsbCdcNotification)); + if (notifyReq == NULL) { HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; } - g_acmDevice->haved_submit = false; - req->complete = TestCancelComplete; - req->context = g_acmDevice; - dprintf("------send \"abc\" to host------\n"); - memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "abc", strlen("abc")); - req->length = strlen("abc"); - ret = UsbFnSubmitRequestAsync(req); + ret = UsbFnGetRequestStatus(notifyReq, &status); if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: request async error", __func__); + HDF_LOGE("%s: get status error", __func__); + dprintf("%s: get status error", __func__); return HDF_FAILURE; } - while(g_acmDevice->haved_submit == 0) { - OsalMSleep(1); - } - ret = UsbFnCancelRequest(req); - if (HDF_SUCCESS == ret) { - dprintf("%s: cancel request error", __func__); + if (!(status >= USB_REQUEST_COMPLETED && status <= USB_REQUEST_OVERFLOW)) { + HDF_LOGE("%s: device status error", __func__); return HDF_FAILURE; } - g_acmDevice->haved_submit = false; - ret = UsbFnFreeRequest(req); + ret = UsbFnFreeRequest(notifyReq); if (HDF_SUCCESS != ret) { HDF_LOGE("%s: free Request error", __func__); return HDF_FAILURE; @@ -1811,14 +1404,12 @@ int32_t UsbFnDviceTestCancelRequest005(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestCancelRequest006(void) +int32_t UsbFnDviceTestGetRequestStatus003(void) { int ret; struct UsbFnRequest *req = NULL; - struct UsbFnRequest *req2 = NULL; - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { - HDF_LOGE("%s: dataIface.handle is invail", __func__); + HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, @@ -1827,47 +1418,78 @@ int32_t UsbFnDviceTestCancelRequest006(void) HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; } - g_acmDevice->haved_submit = false; - req->complete = TestCancelComplete; - req->context = g_acmDevice; + ret = UsbFnGetRequestStatus(req, NULL); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: get status success!!", __func__); + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_FAILURE; + } - req2 = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestGetRequestStatus004(void) +{ + int ret; + UsbRequestStatus status; + struct UsbFnRequest *notifyReq = NULL; + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: ctrlIface.handle is invail", __func__); + return HDF_FAILURE; + } + notifyReq = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, g_acmDevice->dataOutPipe.maxPacketSize); - if (req2 == NULL) { + if (notifyReq == NULL) { HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; } - g_acmDevice->submit = false; - req2->complete = ReadComplete; - req2->context = g_acmDevice; - ret = UsbFnSubmitRequestAsync(req); + ret = UsbFnSubmitRequestAsync(notifyReq); if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: request async error", __func__); + HDF_LOGE("%s: get status error", __func__); return HDF_FAILURE; } - ret = UsbFnSubmitRequestAsync(req2); + ret = UsbFnGetRequestStatus(notifyReq, &status); if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: request async error", __func__); + HDF_LOGE("%s: get status error", __func__); return HDF_FAILURE; } - ret = UsbFnCancelRequest(req2); - if (HDF_SUCCESS != ret) { - dprintf("%s: cancel request error", __func__); + if (!(status >= USB_REQUEST_COMPLETED && status <= USB_REQUEST_OVERFLOW)) { + HDF_LOGE("%s: device status error", __func__); return HDF_FAILURE; } - ret = UsbFnCancelRequest(req); + ret = UsbFnFreeRequest(notifyReq); if (HDF_SUCCESS != ret) { - dprintf("%s: cancel request error", __func__); + HDF_LOGE("%s: free Request error", __func__); return HDF_FAILURE; } - ret = UsbFnFreeRequest(req); - if (HDF_SUCCESS != ret) { - dprintf("%s: free Request error", __func__); + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestGetRequestStatus005(void) +{ + int ret; + UsbRequestStatus status; + struct UsbFnRequest *notifyReq = NULL; + ret = UsbFnGetRequestStatus(notifyReq, &status); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: get status success!!", __func__); return HDF_FAILURE; } - ret = UsbFnFreeRequest(req2); - if (HDF_SUCCESS != ret) { - dprintf("%s: free Request error", __func__); + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestGetRequestStatus006(void) +{ + int ret; + UsbRequestStatus *status = NULL; + struct UsbFnRequest *notifyReq = NULL; + ret = UsbFnGetRequestStatus(notifyReq, status); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: get status success!!", __func__); return HDF_FAILURE; } return HDF_SUCCESS; @@ -1930,17 +1552,7 @@ int32_t UsbFnDviceTestStopReceEvent004(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestStopReceEvent005(void) -{ - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestStopReceEvent006(void) -{ - return HDF_SUCCESS; -} - -static void eventCallback(struct UsbFnEvent *event) +static void EventCallBack(struct UsbFnEvent *event) { (void)event; } @@ -1955,26 +1567,42 @@ int32_t UsbFnDviceTestStartReceEvent(void) ret = UsbFnStartRecvInterfaceEvent(g_acmDevice->ctrlIface.fn, 0xff, NULL, g_acmDevice); if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: stop receive event successs!!", __func__); + HDF_LOGE("%s: start receive event successs!!", __func__); return HDF_FAILURE; } return HDF_SUCCESS; } int32_t UsbFnDviceTestStartReceEvent002(void) +{ + int ret; + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { + HDF_LOGE("%s: ctrlIface.handle is invail", __func__); + return HDF_FAILURE; + } + ret = UsbFnStartRecvInterfaceEvent(g_acmDevice->ctrlIface.fn, 0x0, + EventCallBack, g_acmDevice); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: start receive event successs!!", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestStartReceEvent003(void) { int ret; struct UsbFnInterface *fn = NULL; ret = UsbFnStartRecvInterfaceEvent(fn, 0xff, - eventCallback, g_acmDevice); + EventCallBack, g_acmDevice); if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: stop receive event successs!!", __func__); + HDF_LOGE("%s: start receive event successs!!", __func__); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestStartReceEvent003(void) +int32_t UsbFnDviceTestStartReceEvent004(void) { int ret; if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { @@ -1982,15 +1610,15 @@ int32_t UsbFnDviceTestStartReceEvent003(void) return HDF_FAILURE; } ret = UsbFnStartRecvInterfaceEvent(g_acmDevice->ctrlIface.fn, 0xff, - eventCallback, g_acmDevice); + EventCallBack, g_acmDevice); if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: stop receive event error", __func__); + HDF_LOGE("%s: start receive event error", __func__); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t UsbFnDviceTestStartReceEvent004(void) +int32_t UsbFnDviceTestStartReceEvent005(void) { int ret; int count; @@ -2005,7 +1633,7 @@ int32_t UsbFnDviceTestStartReceEvent004(void) return HDF_FAILURE; } ret = UsbFnStartRecvInterfaceEvent(g_acmDevice->ctrlIface.fn, 0xff, - eventCallback, g_acmDevice); + EventCallBack, g_acmDevice); if (HDF_SUCCESS != ret) { HDF_LOGE("%s: stop receive event error", __func__); return HDF_FAILURE; @@ -2014,7 +1642,7 @@ int32_t UsbFnDviceTestStartReceEvent004(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestStartReceEvent005(void) +int32_t UsbFnDviceTestStartReceEvent006(void) { int ret; if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { @@ -2022,7 +1650,7 @@ int32_t UsbFnDviceTestStartReceEvent005(void) return HDF_FAILURE; } ret = UsbFnStartRecvInterfaceEvent(g_acmDevice->ctrlIface.fn, 0xff, - eventCallback, g_acmDevice); + EventCallBack, g_acmDevice); if (HDF_SUCCESS == ret) { HDF_LOGE("%s: start receive event success!!", __func__); return HDF_FAILURE; @@ -2030,7 +1658,7 @@ int32_t UsbFnDviceTestStartReceEvent005(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestStartReceEvent006(void) +int32_t UsbFnDviceTestStartReceEvent007(void) { int ret; if (g_acmDevice == NULL || g_acmDevice->dataIface.fn == NULL) { @@ -2038,7 +1666,7 @@ int32_t UsbFnDviceTestStartReceEvent006(void) return HDF_FAILURE; } ret = UsbFnStartRecvInterfaceEvent(g_acmDevice->dataIface.fn, 0xff, - eventCallback, g_acmDevice); + EventCallBack, g_acmDevice); if (HDF_SUCCESS == ret) { HDF_LOGE("%s: start receive event success!!", __func__); return HDF_FAILURE; @@ -2046,76 +1674,6 @@ int32_t UsbFnDviceTestStartReceEvent006(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestCloseInterface(void) -{ - int ret; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { - HDF_LOGE("%s: ctrlIface.handle is invail", __func__); - return HDF_FAILURE; - } - ret = UsbFnCloseInterface(g_acmDevice->ctrlIface.handle); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: close interface error", __func__); - return HDF_FAILURE; - } - g_acmDevice->ctrlIface.handle = NULL; - - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestCloseInterface002(void) -{ - int ret; - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { - HDF_LOGE("%s: ctrlIface.handle is invail", __func__); - return HDF_FAILURE; - } - ret = UsbFnCloseInterface(g_acmDevice->dataIface.handle); - if (HDF_SUCCESS != ret) { - HDF_LOGE("%s: close interface error", __func__); - return HDF_FAILURE; - } - g_acmDevice->dataIface.handle = NULL; - - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestCloseInterface003(void) -{ - int ret; - - ret = UsbFnCloseInterface(g_acmDevice->ctrlIface.handle); - if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: close interface success!!", __func__); - return HDF_FAILURE; - } - g_acmDevice->ctrlIface.handle = NULL; - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestCloseInterface004(void) -{ - int ret; - - ret = UsbFnCloseInterface(g_acmDevice->dataIface.handle); - if (HDF_SUCCESS == ret) { - HDF_LOGE("%s: close interface success!!", __func__); - return HDF_FAILURE; - } - g_acmDevice->dataIface.handle = NULL; - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestCloseInterface005(void) -{ - return HDF_SUCCESS; -} - -int32_t UsbFnDviceTestCloseInterface006(void) -{ - return HDF_SUCCESS; -} - int32_t UsbFnDviceTestOpenInterface(void) { UsbFnInterfaceHandle handle; @@ -2212,10 +1770,7 @@ int32_t UsbFnDviceTestOpenInterface005(void) { UsbFnInterfaceHandle handle; struct UsbFnInterface *fn = NULL; - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.fn == NULL) { - HDF_LOGE("%s: ctrlIface.handle is invail", __func__); - return HDF_FAILURE; - } + handle = UsbFnOpenInterface(fn); if (NULL != handle) { HDF_LOGE("%s: open interface success!!", __func__); @@ -2224,8 +1779,63 @@ int32_t UsbFnDviceTestOpenInterface005(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestOpenInterface006(void) +int32_t UsbFnDviceTestCloseInterface(void) +{ + int ret; + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { + HDF_LOGE("%s: ctrlIface.handle is invail", __func__); + return HDF_FAILURE; + } + ret = UsbFnCloseInterface(g_acmDevice->ctrlIface.handle); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: close interface error", __func__); + return HDF_FAILURE; + } + g_acmDevice->ctrlIface.handle = NULL; + + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestCloseInterface002(void) +{ + int ret; + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: ctrlIface.handle is invail", __func__); + return HDF_FAILURE; + } + ret = UsbFnCloseInterface(g_acmDevice->dataIface.handle); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: close interface error", __func__); + return HDF_FAILURE; + } + g_acmDevice->dataIface.handle = NULL; + + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestCloseInterface003(void) +{ + int ret; + + ret = UsbFnCloseInterface(g_acmDevice->ctrlIface.handle); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: close interface success!!", __func__); + return HDF_FAILURE; + } + g_acmDevice->ctrlIface.handle = NULL; + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestCloseInterface004(void) { + int ret; + + ret = UsbFnCloseInterface(g_acmDevice->dataIface.handle); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: close interface success!!", __func__); + return HDF_FAILURE; + } + g_acmDevice->dataIface.handle = NULL; return HDF_SUCCESS; } @@ -2261,8 +1871,3 @@ int32_t UsbFnDviceTestRemove002(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestRemove003(void) -{ - return HDF_SUCCESS; -} - diff --git a/test/unittest/model/usb/device/src/usb_device_lite_sdk_io_test.c b/test/unittest/model/usb/device/src/usb_device_lite_sdk_io_test.c new file mode 100644 index 000000000..a806584e8 --- /dev/null +++ b/test/unittest/model/usb/device/src/usb_device_lite_sdk_io_test.c @@ -0,0 +1,634 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +static void ReadComplete(uint8_t pipe, struct UsbFnRequest *req) +{ + if (NULL == req) { + return; + } + if (req->actual) { + uint8_t *data = (uint8_t *)req->buf; + data[req->actual] = '\0'; + dprintf("receive [%d] bytes data: %s\n", req->actual, data); + if (strcmp((const char *)data, "q") == 0 || \ + strcmp((const char *)data, "q\n") == 0) { + g_acmDevice->submitExit = 1; + } + } + g_acmDevice->submit = 1; +} + +int32_t UsbFnDviceTestRequestAsync(void) +{ + struct UsbFnRequest *req = NULL; + int ret; + + ret = UsbFnSubmitRequestAsync(req); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: async Request success!!", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestRequestAsync002(void) +{ + struct UsbFnRequest *req = NULL; + int ret = HDF_SUCCESS; + int ret1; + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.fn is invail", __func__); + return HDF_FAILURE; + } + dprintf("wait receiving data form host, please connect\n"); + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, + g_acmDevice->dataOutPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + req->complete = ReadComplete; + req->context = g_acmDevice; + while (g_acmDevice->connect == false) { + OsalMSleep(WAIT_100MS); + } + while (1) { + g_acmDevice->submit = 0; + ret = UsbFnSubmitRequestAsync(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: async Request error", __func__); + ret = HDF_FAILURE; + break; + } + while (g_acmDevice->submit == 0) { + OsalMSleep(WAIT_100MS); + } + if (req->actual > 0) { + break; + } + } + ret1 = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret1) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + return ret; +} + +int32_t UsbFnDviceTestRequestAsync003(void) +{ + struct UsbFnRequest *req = NULL; + int ret = HDF_SUCCESS; + int ret1; + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.fn is invail", __func__); + return HDF_FAILURE; + } + dprintf("wait receiving data form host, please connect\n"); + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, + g_acmDevice->dataOutPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + req->complete = ReadComplete; + req->context = g_acmDevice; + while (g_acmDevice->connect == false) { + OsalMSleep(WAIT_100MS); + } + g_acmDevice->submitExit = 0; + while (g_acmDevice->submitExit == 0) { + g_acmDevice->submit = 0; + ret = UsbFnSubmitRequestAsync(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: async Request error", __func__); + ret = HDF_FAILURE; + break; + } + while (g_acmDevice->submit == 0) { + OsalMSleep(WAIT_100MS); + } + } + ret1 = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret1) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + return ret; +} + +static void WriteComplete(uint8_t pipe, struct UsbFnRequest *req) +{ + dprintf("write data status = %d\n", req->status); + g_acmDevice->submit = 1; +} + +int32_t UsbFnDviceTestRequestAsync004(void) +{ + struct UsbFnRequest *req = NULL; + int ret; + + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.fn is invail", __func__); + return HDF_FAILURE; + } + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, + g_acmDevice->dataInPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + req->complete = WriteComplete; + req->context = g_acmDevice; + g_acmDevice->submit = 0; + dprintf("------send \"abc\" to host------\n"); + memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "abc", strlen("abc")); + req->length = strlen("abc"); + ret = UsbFnSubmitRequestAsync(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: async Request error", __func__); + return HDF_FAILURE; + } + while (g_acmDevice->submit == 0) { + OsalMSleep(1); + } + g_acmDevice->submit = 0; + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestRequestAsync005(void) +{ + struct UsbFnRequest *req = NULL; + int loopTime = TEST_TIMES; + int ret; + + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.fn is invail", __func__); + return HDF_FAILURE; + } + dprintf("------send \"xyz\" 10 times to host------\n"); + while (loopTime--) { + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, + g_acmDevice->dataInPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + req->complete = WriteComplete; + req->context = g_acmDevice; + g_acmDevice->submit = 0; + memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "xyz", strlen("xyz")); + req->length = strlen("xyz"); + ret = UsbFnSubmitRequestAsync(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: async Request error", __func__); + return HDF_FAILURE; + } + while (g_acmDevice->submit == 0) { + OsalMSleep(1); + } + g_acmDevice->submit = 0; + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestRequestAsync006(void) +{ + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestRequestSync(void) +{ + struct UsbFnRequest *req = NULL; + int ret; + ret = UsbFnSubmitRequestSync(req, 0); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: sync Request success!!", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestRequestSync002(void) +{ + struct UsbFnRequest *req = NULL; + int ret; + uint8_t *data = NULL; + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.fn is invail", __func__); + return HDF_FAILURE; + } + dprintf("wait receiving data form host\n"); + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, + g_acmDevice->dataOutPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + ret = UsbFnSubmitRequestSync(req, 0); + if (ret != 0 || req->actual <= 0 || req->status != USB_REQUEST_COMPLETED) { + HDF_LOGE("%s: Sync Request error", __func__); + return HDF_FAILURE; + } + data = (uint8_t *)req->buf; + data[req->actual] = '\0'; + dprintf("receive data from host: %s\n", data); + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestRequestSync003(void) +{ + struct UsbFnRequest *req = NULL; + int ret; + int submitExit = 0; + uint8_t *data = NULL; + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.fn is invail", __func__); + return HDF_FAILURE; + } + dprintf("receive data until 'q' exit\n"); + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, + g_acmDevice->dataOutPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + while (submitExit == 0) { + ret = UsbFnSubmitRequestSync(req, 0); + if (ret != 0 || req->actual <= 0 || req->status != USB_REQUEST_COMPLETED) { + HDF_LOGE("%s: Sync Request error", __func__); + break; + } + data = (uint8_t *)req->buf; + data[req->actual] = '\0'; + if (strcmp((const char *)data, "q") == 0 || \ + strcmp((const char *)data, "q\n") == 0) { + submitExit = 1; + } + dprintf("receive data from host: %s\n", data); + } + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestRequestSync004(void) +{ + struct UsbFnRequest *req = NULL; + int ret; + + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.fn is invail", __func__); + return HDF_FAILURE; + } + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, + g_acmDevice->dataInPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + dprintf("------send \"abc\" to host------\n"); + memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "abc", strlen("abc")); + req->length = strlen("abc"); + ret = UsbFnSubmitRequestSync(req, 0); + if (HDF_SUCCESS != ret || (req->actual != strlen("abc")) || \ + (req->status != USB_REQUEST_COMPLETED)) { + HDF_LOGE("%s: async Request error", __func__); + return HDF_FAILURE; + } + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestRequestSync005(void) +{ + struct UsbFnRequest *req = NULL; + int loopTime = TEST_TIMES; + int ret; + + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.fn is invail", __func__); + return HDF_FAILURE; + } + dprintf("------send \"abcdefg\" 10 times to host------\n"); + while (loopTime--) { + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, + g_acmDevice->dataInPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "abcdefg", strlen("abcdefg")); + req->length = strlen("abcdefg"); + ret = UsbFnSubmitRequestSync(req, 0); + if (HDF_SUCCESS != ret || (req->actual != strlen("abcdefg")) || \ + (req->status != USB_REQUEST_COMPLETED)) { + HDF_LOGE("%s: async Request error", __func__); + return HDF_FAILURE; + } + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestRequestSync006(void) +{ + struct UsbFnRequest *req = NULL; + int ret; + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.fn is invail", __func__); + return HDF_FAILURE; + } + dprintf("test sync timeout 5s:\n"); + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, + g_acmDevice->dataOutPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + ret = UsbFnSubmitRequestSync(req, SYNC_5000MS); + if (ret == 0) { + HDF_LOGE("%s: Sync Request success", __func__); + return HDF_FAILURE; + } + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestRequestSync007(void) +{ + struct UsbFnRequest *req = NULL; + int ret; + + ret = UsbFnSubmitRequestSync(req, SYNC_5000MS); + if (ret == 0) { + HDF_LOGE("%s: Sync Request error", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static void TestCancelComplete(uint8_t pipe, struct UsbFnRequest *req) +{ + dprintf("%s, req->buf = 0x%x\n", __func__, (uint32_t)req->buf); + g_acmDevice->havedSubmit = true; +} + +int32_t UsbFnDviceTestCancelRequest(void) +{ + int ret; + struct UsbFnRequest *notifyReq = NULL; + ret = UsbFnCancelRequest(notifyReq); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: cancel request success!!", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestCancelRequest002(void) +{ + int ret; + struct UsbFnRequest *req = NULL; + + if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { + HDF_LOGE("%s: CtrlIface.handle is invail", __func__); + return HDF_FAILURE; + } + req = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, + sizeof(struct UsbCdcNotification)); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + ret = UsbFnCancelRequest(req); + if (HDF_SUCCESS == ret) { + HDF_LOGE("%s: cancel request success", __func__); + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_FAILURE; + } + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestCancelRequest003(void) +{ + int ret; + struct UsbFnRequest *req = NULL; + + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.handle is invail", __func__); + return HDF_FAILURE; + } + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, + g_acmDevice->dataInPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + ret = UsbFnCancelRequest(req); + if (HDF_SUCCESS == ret) { + dprintf("%s: cancel request success\n", __func__); + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + dprintf("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_FAILURE; + } + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestCancelRequest004(void) +{ + int ret; + struct UsbFnRequest *req = NULL; + + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.handle is invail", __func__); + return HDF_FAILURE; + } + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, + g_acmDevice->dataInPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + ret = UsbFnCancelRequest(req); + if (HDF_SUCCESS == ret) { + dprintf("%s: cancel request success\n", __func__); + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + dprintf("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_FAILURE; + } + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestCancelRequest005(void) +{ + int ret; + struct UsbFnRequest *req = NULL; + + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.handle is invail", __func__); + return HDF_FAILURE; + } + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataInPipe.id, + g_acmDevice->dataInPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + g_acmDevice->havedSubmit = false; + req->complete = TestCancelComplete; + req->context = g_acmDevice; + dprintf("------send \"abc\" to host------\n"); + memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "abc", strlen("abc")); + req->length = strlen("abc"); + ret = UsbFnSubmitRequestAsync(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: request async error", __func__); + return HDF_FAILURE; + } + while (g_acmDevice->havedSubmit == 0) { + OsalMSleep(1); + } + ret = UsbFnCancelRequest(req); + if (HDF_SUCCESS == ret) { + dprintf("%s: cancel request error", __func__); + return HDF_FAILURE; + } + g_acmDevice->havedSubmit = false; + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t UsbFnDviceTestCancelRequest006(void) +{ + int ret; + struct UsbFnRequest *req = NULL; + struct UsbFnRequest *req2 = NULL; + + if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.handle is invail", __func__); + return HDF_FAILURE; + } + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, + g_acmDevice->dataOutPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + g_acmDevice->havedSubmit = false; + req->complete = TestCancelComplete; + req->context = g_acmDevice; + + req2 = UsbFnAllocRequest(g_acmDevice->dataIface.handle, g_acmDevice->dataOutPipe.id, + g_acmDevice->dataOutPipe.maxPacketSize); + if (req2 == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + g_acmDevice->submit = false; + req2->complete = ReadComplete; + req2->context = g_acmDevice; + ret = UsbFnSubmitRequestAsync(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: request async error", __func__); + return HDF_FAILURE; + } + ret = UsbFnSubmitRequestAsync(req2); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: request async error", __func__); + return HDF_FAILURE; + } + ret = UsbFnCancelRequest(req2); + if (HDF_SUCCESS != ret) { + dprintf("%s: cancel request error", __func__); + return HDF_FAILURE; + } + ret = UsbFnCancelRequest(req); + if (HDF_SUCCESS != ret) { + dprintf("%s: cancel request error", __func__); + return HDF_FAILURE; + } + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + dprintf("%s: free Request error", __func__); + return HDF_FAILURE; + } + ret = UsbFnFreeRequest(req2); + if (HDF_SUCCESS != ret) { + dprintf("%s: free Request error", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + diff --git a/test/unittest/model/usb/host/include/hdf_usb_entry_test.h b/test/unittest/model/usb/host/include/hdf_usb_entry_test.h new file mode 100644 index 000000000..3d8f1196c --- /dev/null +++ b/test/unittest/model/usb/host/include/hdf_usb_entry_test.h @@ -0,0 +1,15 @@ +/* + * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#ifndef HDF_USB_ENTRY_TEST_H +#define HDF_USB_ENTRY_TEST_H + +#include "hdf_main_test.h" + +int32_t HdfUsbUnitTestEntry(HdfTestMsg *msg); +#endif /* HDF_USB_ENTRY_TEST_H */ \ No newline at end of file diff --git a/test/unittest/model/usb/host/include/usb_raw_test.h b/test/unittest/model/usb/host/include/usb_raw_test.h new file mode 100644 index 000000000..093e69baa --- /dev/null +++ b/test/unittest/model/usb/host/include/usb_raw_test.h @@ -0,0 +1,510 @@ +/* + * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#ifndef USB_RAW_TEST_H +#define USB_RAW_TEST_H + +#include "data_fifo.h" +#include "hdf_device_desc.h" +#include "hdf_platform.h" +#include "implementation/global_implementation.h" +#include "usb_interface.h" +#include "usb_raw_api.h" + +enum UsbRawTestCmd { + USB_RAW_SDK_IF_START_IO, + USB_RAW_SDK_IF_INIT_001_TEST, + USB_RAW_SDK_IF_EXIT_001_TEST, + USB_RAW_SDK_IF_INIT_002_TEST, + USB_RAW_SDK_IF_EXIT_002_TEST, + USB_RAW_SDK_IF_INIT_003_TEST, + USB_RAW_SDK_IF_INIT_004_TEST, + USB_RAW_SDK_IF_INIT_005_TEST, + USB_RAW_SDK_IF_OPEN_DEVICE_001_TEST, + USB_RAW_SDK_IF_OPEN_DEVICE_002_TEST, + USB_RAW_SDK_IF_OPEN_DEVICE_003_TEST, + USB_RAW_SDK_IF_OPEN_DEVICE_004_TEST, + USB_RAW_SDK_IF_OPEN_DEVICE_005_TEST, + USB_RAW_SDK_IF_OPEN_DEVICE_006_TEST, + USB_RAW_SDK_IF_RESET_DEVICE_001_TEST, + USB_RAW_SDK_IF_RESET_DEVICE_002_TEST, + USB_RAW_SDK_IF_CLOSE_DEVICE_001_TEST, + USB_RAW_SDK_IF_CLOSE_DEVICE_002_TEST, + USB_RAW_SDK_IF_OPEN_DEVICE_007_TEST, + USB_RAW_SDK_IF_GET_CONFIGURATION_001_TEST, + USB_RAW_SDK_IF_GET_CONFIGURATION_002_TEST, + USB_RAW_SDK_IF_GET_CONFIGURATION_003_TEST, + USB_RAW_SDK_IF_GET_CONFIGURATION_004_TEST, + USB_RAW_SDK_IF_GET_DEVICE_001_TEST, + USB_RAW_SDK_IF_GET_DEVICE_002_TEST, + USB_RAW_SDK_IF_GET_CONFIG_DESC_001_TEST, + USB_RAW_SDK_IF_GET_CONFIG_DESC_002_TEST, + USB_RAW_SDK_IF_GET_CONFIG_DESC_003_TEST, + USB_RAW_SDK_IF_GET_CONFIG_DESC_004_TEST, + USB_RAW_SDK_IF_SET_CONFIGURATION_001_TEST, + USB_RAW_SDK_IF_SET_CONFIGURATION_002_TEST, + USB_RAW_SDK_IF_SET_CONFIGURATION_003_TEST, + USB_RAW_SDK_IF_SET_CONFIGURATION_004_TEST, + USB_RAW_SDK_IF_SET_CONFIGURATION_005_TEST, + USB_RAW_SDK_IF_SET_CONFIGURATION_006_TEST, + USB_RAW_SDK_IF_SET_CONFIGURATION_007_TEST, + USB_RAW_SDK_IF_SET_CONFIGURATION_008_TEST, + USB_RAW_SDK_IF_GET_DEVICE_DESC_001_TEST, + USB_RAW_SDK_IF_GET_DEVICE_DESC_002_TEST, + USB_RAW_SDK_IF_GET_DEVICE_DESC_003_TEST, + USB_RAW_SDK_IF_GET_DEVICE_DESC_004_TEST, + USB_RAW_SDK_IF_GET_CONFIG_DESC_005_TEST, + USB_RAW_SDK_IF_GET_DEVICE_DESC_005_TEST, + USB_RAW_SDK_IF_CLAMIN_INTERFACE_001_TEST, + USB_RAW_SDK_IF_CLAMIN_INTERFACE_002_TEST, + USB_RAW_SDK_IF_CLAMIN_INTERFACE_003_TEST, + USB_RAW_SDK_IF_CLAMIN_INTERFACE_004_TEST, + USB_RAW_SDK_IF_CLAMIN_INTERFACE_005_TEST, + USB_RAW_SDK_IF_RELEASE_INTERFACE_001_TEST, + USB_RAW_SDK_IF_RELEASE_INTERFACE_002_TEST, + USB_RAW_SDK_IF_RELEASE_INTERFACE_003_TEST, + USB_RAW_SDK_IF_RELEASE_INTERFACE_004_TEST, + USB_RAW_SDK_IF_CLAMIN_INTERFACE_006_TEST, + USB_RAW_SDK_IF_ALLOC_REQUEST_001_TEST, + USB_RAW_SDK_IF_ALLOC_REQUEST_002_TEST, + USB_RAW_SDK_IF_ALLOC_REQUEST_003_TEST, + USB_RAW_SDK_IF_ALLOC_REQUEST_004_TEST, + USB_RAW_SDK_IF_ALLOC_REQUEST_005_TEST, + USB_RAW_SDK_IF_ALLOC_REQUEST_006_TEST, + USB_RAW_SDK_IF_ALLOC_REQUEST_007_TEST, + USB_RAW_SDK_IF_ALLOC_REQUEST_008_TEST, + USB_RAW_SDK_IF_ALLOC_REQUEST_010_TEST, + USB_RAW_SDK_IF_ALLOC_REQUEST_011_TEST, + USB_RAW_SDK_IF_FREE_REQUEST_006_TEST, + USB_RAW_SDK_IF_FILL_ISO_REQUEST_001_TEST, + USB_RAW_SDK_IF_FILL_ISO_REQUEST_002_TEST, + USB_RAW_SDK_IF_FILL_ISO_REQUEST_003_TEST, + USB_RAW_SDK_IF_FILL_ISO_REQUEST_004_TEST, + USB_RAW_SDK_IF_FILL_ISO_REQUEST_005_TEST, + USB_RAW_SDK_IF_FILL_ISO_REQUEST_006_TEST, + USB_RAW_SDK_IF_FREE_REQUEST_001_TEST, + USB_RAW_SDK_IF_FREE_REQUEST_002_TEST, + USB_RAW_SDK_IF_FREE_REQUEST_003_TEST, + USB_RAW_SDK_IF_FREE_REQUEST_004_TEST, + USB_RAW_SDK_IF_FREE_REQUEST_005_TEST, + USB_RAW_SDK_IF_ALLOC_REQUEST_009_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_001_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_002_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_003_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_004_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_005_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_006_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_007_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_008_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_009_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_010_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_011_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_012_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_013_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_014_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_015_TEST, + USB_RAW_SDK_IF_GET_DESCRIPTION_016_TEST, + USB_RAW_SDK_IF_FILL_BULK_REQUEST_001_TEST, + USB_RAW_SDK_IF_FILL_BULK_REQUEST_002_TEST, + USB_RAW_SDK_IF_FILL_INT_REQUEST_001_TEST, + USB_RAW_SDK_IF_FILL_INT_REQUEST_002_TEST, + USB_RAW_SDK_IF_FILL_INT_REQUEST_003_TEST, + USB_RAW_SDK_IF_FILL_INT_REQUEST_004_TEST, + USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_001_TEST, + USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_002_TEST, + USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_003_TEST, + USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_004_TEST, + USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_005_TEST, + USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_006_TEST, + USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_007_TEST, + USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_008_TEST, + USB_RAW_SDK_IF_FILL_CONTROL_SETUP_001_TEST, + USB_RAW_SDK_IF_FILL_CONTROL_SETUP_002_TEST, + USB_RAW_SDK_IF_FILL_CONTROL_SETUP_003_TEST, + USB_RAW_SDK_IF_FILL_CONTROL_SETUP_004_TEST, + USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_001_TEST, + USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_002_TEST, + USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_003_TEST, + USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_004_TEST, + USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_005_TEST, + USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_006_TEST, + USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_007_TEST, + USB_RAW_SDK_IF_SEND_BULK_REQUEST_001_TEST, + USB_RAW_SDK_IF_SEND_BULK_REQUEST_002_TEST, + USB_RAW_SDK_IF_SEND_BULK_REQUEST_003_TEST, + USB_RAW_SDK_IF_SEND_BULK_REQUEST_004_TEST, + USB_RAW_SDK_IF_SEND_BULK_REQUEST_005_TEST, + USB_RAW_SDK_IF_SEND_INT_REQUEST_001_TEST, + USB_RAW_SDK_IF_SEND_INT_REQUEST_002_TEST, + USB_RAW_SDK_IF_SEND_INT_REQUEST_003_TEST, + USB_RAW_SDK_IF_SEND_INT_REQUEST_004_TEST, + USB_RAW_SDK_IF_FILL_BULK_REQUEST_003_TEST, + USB_RAW_SDK_IF_FILL_BULK_REQUEST_004_TEST, + USB_RAW_SDK_IF_FILL_INT_REQUEST_005_TEST, + USB_RAW_SDK_IF_SUBMIT_REQUEST_001_TEST, + USB_RAW_SDK_IF_SUBMIT_REQUEST_002_TEST, + USB_RAW_SDK_IF_SUBMIT_REQUEST_003_TEST, + USB_RAW_SDK_IF_SUBMIT_REQUEST_004_TEST, + USB_RAW_SDK_IF_CANCEL_REQUEST_001_TEST, + USB_RAW_SDK_IF_CANCEL_REQUEST_002_TEST, + USB_RAW_SDK_IF_CANCEL_REQUEST_003_TEST, + USB_RAW_SDK_IF_CANCEL_REQUEST_004_TEST, + USB_RAW_SDK_IF_STOP_IO, +}; + +#define USB_MAX_INTERFACES 32 +#define USB_CTRL_REQ_SIZE 256 + +#define DATARATE 9600 +#define CHARFORMAT 8 +#define ACM_NW 16 +#define ACM_NR 16 +#define READ_BUF_SIZE 8192 +#define USB_CTRL_SET_TIMEOUT 5000 +#define USB_PIPE_DIR_OFFSET 7 +#define USB_DEVICE_VENDOR_ID 0x12D1 +#define USB_DEVICE_PRODUCT_ID 0x5000 +#define USB_MAX_BYTE 255 +#define BITS_PER_WORD 10 +#define MAX_SPEED_HZ 10000000 +#define TEST_SLEEP_TIME 500 +#define USB_LOOP_NUM 100 +#define USB_DESC_TYPE 2 +#define USB_ISO_PACKAT_CNT 16 + +#define USB_RAW_REQUEST_TIME_ZERO_MS 0 +#define USB_RAW_IO_SLEEP_MS_TIME 500 +#define USB_IO_THREAD_STACK_SIZE 8192 + +struct AcmRawDevice; +struct RawWb { + struct UsbRawRequest *request; + struct AcmRawDevice *instance; + uint8_t *buf; + int len; + int use; +}; + +struct RawRb { + uint8_t *base; + int size; + int index; + int use; + struct AcmRawDevice *instance; +}; + +struct SerialRawDevice { + struct AcmRawDevice *acm; + struct UsbCdcLineCoding lineCoding; + struct OsalMutex lock; + struct DataFifo readFifo; +}; + +struct UsbEndpoint { + uint8_t addr; + uint8_t interval; + uint16_t maxPacketSize; +}; + +struct AcmRawDevice { + struct IDeviceIoService service; + struct HdfDeviceObject *device; + uint8_t ctrlIface; + uint8_t dataIface; + struct UsbEndpoint notifyEp; + struct UsbEndpoint dataInEp; + struct UsbEndpoint dataOutEp; + struct UsbEndpoint isoEp; + struct UsbRawConfigDescriptor *config; + struct RawWb wb[ACM_NW]; + struct RawRb rb[ACM_NR]; + struct OsalMutex writeLock; + struct OsalMutex readLock; + struct UsbRawRequest *notifyReq; + struct UsbRawRequest *readReq[ACM_NR]; + struct UsbRawRequest *writeReq; + struct UsbRawRequest *ctrlReq; + struct UsbRawRequest *isoReq; + struct OsalMutex lock; + UsbRawHandle *devHandle; + struct UsbSession *session; + struct SerialRawDevice *port; + uint32_t nbIndex; + uint32_t nbSize; + int transmitting; + uint8_t busNum; + uint8_t devAddr; + uint8_t interfaceCnt; + uint8_t *notificationBuffer; + uint8_t interfaceIndex[USB_MAX_INTERFACES]; + struct UsbCdcLineCoding lineCoding; + struct OsalThread ioThread; +}; + +typedef void (*UsbRequestCallback)(struct UsbRequest *request); + +typedef enum { + /* select a configuration for the device */ + USB_REQUEST_SELECT_CONFIGURATION, + /* select an alternate setting for an interface */ + USB_REQUEST_SELECT_INTERFACE, + /* get the device descriptor from a specific USB device/interface/endpoint */ + USB_REQUEST_GET_DESCRIPTOR, + /* set descriptor on a device/interface/endpoint */ + USB_REQUEST_SET_DESCRIPTOR, + /* set a feature on a device/interface/endpoint/other */ + USB_REQUEST_SET_FEATURE, + /* clear a USB-defined feature on a device/interface/endpoint/other */ + USB_REQUEST_CLEAR_FEATURE, + /* get status form a USB device/interface/endpoint/other */ + USB_REQUEST_GET_STATUS, + /* get the current configuration on a USB device */ + USB_REQUEST_GET_CONFIGURATION = 0x08, + /* get the current setting for an interface */ + USB_REQUEST_GET_INTERFACE, +} UsbStandardRequest; + +typedef enum { + USB_REQUEST_TYPE_CONTROL = 0U, + USB_REQUEST_TYPE_ISOCHRONOUS = 1U, + USB_REQUEST_TYPE_BULK = 2U, + USB_REQUEST_TYPE_INTERRUPT = 3U, +} UsbRequestType; + +struct UsbIsoPacketDesc { + unsigned int length; + unsigned int actualLength; + unsigned int status; +}; + +struct UsbAdapterUrb { + unsigned char type; + unsigned char endPoint; + int status; + unsigned int flags; + void *buffer; + int bufferLength; + int actualLength; + int startFrame; + int numberOfPackets; + int errorCount; + unsigned int signr; + void *userContext; + struct UsbIsoPacketDesc isoFrameDesc[0]; +}; + +/* Note:The first five fields of the definition must be consistent with the UsbRawRequest structure definition. */ +struct UsbHostRequest { + /* the address of data buffer */ + unsigned char *buffer; + /* the length of data buffer */ + int length; + /* the actual length of the requested data */ + int actualLength; + /* the status of the request */ + UsbRequestStatus status; + /* private user data */ + void *userData; + + /* the following fields are not visible to user */ + struct UsbDeviceHandle *devHandle; + UsbRawRequestCallback callback; + UsbRequestCallback userCallback; + /* the length of data buffer */ + int bufLen; + struct OsalSem sem; + unsigned char endPoint; + unsigned int timeout; + unsigned char requestType; + union { + void *urbs; + void **isoUrbs; + }; + int numUrbs; + int numRetired; + UsbRequestStatus reqStatus; + int isoPacketOffset; + struct OsalMutex lock; + void *privateObj; + int numIsoPackets; + /* isopacketdesc ptr */ + struct UsbIsoPacketDesc isoPacketDesc[0]; +}__attribute__((aligned(4))); + +/* Note:The first seven fields of this definition must be consistent with the UsbRawFillRequestData + * structure definition. + */ +struct UsbFillRequestData { + unsigned char endPoint; + unsigned char *buffer; + int length; + int numIsoPackets; + UsbRawRequestCallback callback; + void *userData; + unsigned int timeout; + UsbRequestCallback userCallback; +}; + +extern struct AcmRawDevice *g_acm; + +struct UsbRawTestFunc { + enum UsbRawTestCmd type; + int32_t (*Func)(void); +}; + +int UsbParseConfigDescriptor(struct AcmRawDevice *acm, struct UsbRawConfigDescriptor *config); +int AcmWriteBufAlloc(struct AcmRawDevice *acm); +void AcmNotifyReqCallback(void *requestArg); +void AcmReadBulkCallback(void *requestArg); +void AcmWriteIsoCallback(void *requestArg); +void AcmWriteBulkCallback(void *requestArg); +int UsbStopIo(void); +int UsbStartIo(void); +int UsbIoThread(void *data); +void AcmWriteBufFree(struct AcmRawDevice *acm); +void AcmCtrlReqCallback(void *requestArg); +int32_t CheckRawSdkIfInit001(void); +int32_t CheckRawSdkIfExit001(void); +int32_t CheckRawSdkIfInit002(void); +int32_t CheckRawSdkIfExit002(void); +int32_t CheckRawSdkIfInit003(void); +int32_t CheckRawSdkIfInit004(void); +int32_t CheckRawSdkIfInit005(void); +int32_t CheckRawSdkIfOpenDevice001(void); +int32_t CheckRawSdkIfOpenDevice002(void); +int32_t CheckRawSdkIfOpenDevice003(void); +int32_t CheckRawSdkIfOpenDevice004(void); +int32_t CheckRawSdkIfOpenDevice005(void); +int32_t CheckRawSdkIfOpenDevice006(void); +int32_t CheckRawSdkIfResetDevice001(void); +int32_t CheckRawSdkIfResetDevice002(void); +int32_t CheckRawSdkIfCloseDevice001(void); +int32_t CheckRawSdkIfCloseDevice002(void); +int32_t CheckRawSdkIfOpenDevice007(void); +int32_t CheckRawSdkIfGetConfiguration001(void); +int32_t CheckRawSdkIfGetConfiguration002(void); +int32_t CheckRawSdkIfGetConfiguration003(void); +int32_t CheckRawSdkIfGetConfiguration004(void); +int32_t CheckRawSdkIfGetDevice001(void); +int32_t CheckRawSdkIfGetDevice002(void); +int32_t CheckRawSdkIfGetConfigDescriptor001(void); +int32_t CheckRawSdkIfGetConfigDescriptor002(void); +int32_t CheckRawSdkIfGetConfigDescriptor003(void); +int32_t CheckRawSdkIfGetConfigDescriptor004(void); +int32_t CheckRawSdkIfSetConfiguration001(void); +int32_t CheckRawSdkIfSetConfiguration002(void); +int32_t CheckRawSdkIfSetConfiguration003(void); +int32_t CheckRawSdkIfSetConfiguration004(void); +int32_t CheckRawSdkIfSetConfiguration005(void); +int32_t CheckRawSdkIfSetConfiguration006(void); +int32_t CheckRawSdkIfSetConfiguration007(void); +int32_t CheckRawSdkIfSetConfiguration008(void); +int32_t CheckRawSdkIfGetDeviceDescriptor001(void); +int32_t CheckRawSdkIfGetDeviceDescriptor002(void); +int32_t CheckRawSdkIfGetDeviceDescriptor003(void); +int32_t CheckRawSdkIfGetDeviceDescriptor004(void); +int32_t CheckRawSdkIfGetConfigDescriptor005(void); +int32_t CheckRawSdkIfGetDeviceDescriptor005(void); +int32_t CheckRawSdkIfClaimInterface001(void); +int32_t CheckRawSdkIfClaimInterface002(void); +int32_t CheckRawSdkIfClaimInterface003(void); +int32_t CheckRawSdkIfClaimInterface004(void); +int32_t CheckRawSdkIfClaimInterface005(void); +int32_t CheckRawSdkIfReleaseInterface001(void); +int32_t CheckRawSdkIfReleaseInterface002(void); +int32_t CheckRawSdkIfReleaseInterface003(void); +int32_t CheckRawSdkIfReleaseInterface004(void); +int32_t CheckRawSdkIfClaimInterface006(void); +int32_t CheckRawSdkIfAllocRequest001(void); +int32_t CheckRawSdkIfAllocRequest002(void); +int32_t CheckRawSdkIfAllocRequest003(void); +int32_t CheckRawSdkIfAllocRequest004(void); +int32_t CheckRawSdkIfAllocRequest005(void); +int32_t CheckRawSdkIfAllocRequest006(void); +int32_t CheckRawSdkIfAllocRequest007(void); +int32_t CheckRawSdkIfAllocRequest008(void); +int32_t CheckRawSdkIfAllocRequest010(void); +int32_t CheckRawSdkIfAllocRequest011(void); +int32_t CheckRawSdkIfFreeRequest006(void); +int32_t CheckRawSdkIfFillIsoRequest001(void); +int32_t CheckRawSdkIfFillIsoRequest002(void); +int32_t CheckRawSdkIfFillIsoRequest003(void); +int32_t CheckRawSdkIfFillIsoRequest004(void); +int32_t CheckRawSdkIfFillIsoRequest005(void); +int32_t CheckRawSdkIfFillIsoRequest006(void); +int32_t CheckRawSdkIfFreeRequest001(void); +int32_t CheckRawSdkIfFreeRequest002(void); +int32_t CheckRawSdkIfFreeRequest003(void); +int32_t CheckRawSdkIfFreeRequest004(void); +int32_t CheckRawSdkIfFreeRequest005(void); +int32_t CheckRawSdkIfAllocRequest009(void); +int32_t CheckRawSdkIfGetDescriptor001(void); +int32_t CheckRawSdkIfGetDescriptor002(void); +int32_t CheckRawSdkIfGetDescriptor003(void); +int32_t CheckRawSdkIfGetDescriptor004(void); +int32_t CheckRawSdkIfGetDescriptor005(void); +int32_t CheckRawSdkIfGetDescriptor006(void); +int32_t CheckRawSdkIfGetDescriptor007(void); +int32_t CheckRawSdkIfGetDescriptor008(void); +int32_t CheckRawSdkIfGetDescriptor009(void); +int32_t CheckRawSdkIfGetDescriptor010(void); +int32_t CheckRawSdkIfGetDescriptor011(void); +int32_t CheckRawSdkIfGetDescriptor012(void); +int32_t CheckRawSdkIfGetDescriptor013(void); +int32_t CheckRawSdkIfGetDescriptor014(void); +int32_t CheckRawSdkIfGetDescriptor015(void); +int32_t CheckRawSdkIfGetDescriptor016(void); +int32_t CheckRawSdkIfFillBulkRequest001(void); +int32_t CheckRawSdkIfFillBulkRequest002(void); +int32_t CheckRawSdkIfFillInterruptRequest001(void); +int32_t CheckRawSdkIfFillInterruptRequest002(void); +int32_t CheckRawSdkIfFillInterruptRequest003(void); +int32_t CheckRawSdkIfFillInterruptRequest004(void); +int32_t CheckRawSdkIfFillControlRequest001(void); +int32_t CheckRawSdkIfFillControlRequest002(void); +int32_t CheckRawSdkIfFillControlRequest003(void); +int32_t CheckRawSdkIfFillControlRequest004(void); +int32_t CheckRawSdkIfFillControlRequest005(void); +int32_t CheckRawSdkIfFillControlRequest006(void); +int32_t CheckRawSdkIfFillControlRequest007(void); +int32_t CheckRawSdkIfFillControlRequest008(void); +int32_t CheckRawSdkIfFillControlSetup001(void); +int32_t CheckRawSdkIfFillControlSetup002(void); +int32_t CheckRawSdkIfFillControlSetup003(void); +int32_t CheckRawSdkIfFillControlSetup004(void); +int32_t CheckRawSdkIfSendControlRequest001(void); +int32_t CheckRawSdkIfSendControlRequest002(void); +int32_t CheckRawSdkIfSendControlRequest003(void); +int32_t CheckRawSdkIfSendControlRequest004(void); +int32_t CheckRawSdkIfSendControlRequest005(void); +int32_t CheckRawSdkIfSendControlRequest006(void); +int32_t CheckRawSdkIfSendControlRequest007(void); +int32_t CheckRawSdkIfSendBulkRequest001(void); +int32_t CheckRawSdkIfSendBulkRequest002(void); +int32_t CheckRawSdkIfSendBulkRequest003(void); +int32_t CheckRawSdkIfSendBulkRequest004(void); +int32_t CheckRawSdkIfSendBulkRequest005(void); +int32_t CheckRawSdkIfSendInterruptRequest001(void); +int32_t CheckRawSdkIfSendInterruptRequest002(void); +int32_t CheckRawSdkIfSendInterruptRequest003(void); +int32_t CheckRawSdkIfSendInterruptRequest004(void); +int32_t CheckRawSdkIfFillBulkRequest003(void); +int32_t CheckRawSdkIfFillBulkRequest004(void); +int32_t CheckRawSdkIfFillInterruptRequest005(void); +int32_t CheckRawSdkIfSubmitRequest001(void); +int32_t CheckRawSdkIfSubmitRequest002(void); +int32_t CheckRawSdkIfSubmitRequest003(void); +int32_t CheckRawSdkIfSubmitRequest004(void); +int32_t CheckRawSdkIfCancelRequest001(void); +int32_t CheckRawSdkIfCancelRequest002(void); +int32_t CheckRawSdkIfCancelRequest003(void); +int32_t CheckRawSdkIfCancelRequest004(void); + +int32_t UsbRawTestEntry(int32_t cmd); + +#endif /* USB_TEST_H */ diff --git a/test/unittest/model/usb/host/include/usb_test.h b/test/unittest/model/usb/host/include/usb_test.h new file mode 100644 index 000000000..b92a374d5 --- /dev/null +++ b/test/unittest/model/usb/host/include/usb_test.h @@ -0,0 +1,236 @@ +/* + * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#ifndef USB_TEST_H +#define USB_TEST_H + +#include "data_fifo.h" +#include "hdf_device_desc.h" +#include "hdf_platform.h" +#include "implementation/global_implementation.h" +#include "usb_ddk.h" +#include "usb_interface.h" + +enum UsbTestCmd { + USB_WRITE_TEST = 0, + USB_HOSTSDK_INIT_001_TEST, + Usb_HOSTSDK_EXIT_001_TEST, + USB_HOSTSDK_INIT_002_TEST, + USB_HOSTSDK_EXIT_002_TEST, + USB_HOSTSDK_INIT_003_TEST, + USB_HOSTSDK_INIT_004_TEST, + USB_HOSTSDK_INIT_005_TEST, + USB_HOSTSDK_CLAIM_INTERFACE_001_TEST, + USB_HOSTSDK_RELEASE_INTERFACE_001_TEST, + USB_HOSTSDK_CLAIM_INTERFACE_002_TEST, + USB_HOSTSDK_RELEASE_INTERFACE_002_TEST, + USB_HOSTSDK_CLAIM_INTERFACE_003_TEST, + USB_HOSTSDK_RELEASE_INTERFACE_003_TEST, + USB_HOSTSDK_CLAIM_INTERFACE_004_TEST, + USB_HOSTSDK_CLAIM_INTERFACE_005_TEST, + USB_HOSTSDK_CLAIM_INTERFACE_006_TEST, + USB_HOSTSDK_OPEN_INTERFACE_001_TEST, + USB_HOSTSDK_CLOSE_INTERFACE_001_TEST, + USB_HOSTSDK_OPEN_INTERFACE_002_TEST, + USB_HOSTSDK_CLOSE_INTERFACE_002_TEST, + USB_HOSTSDK_OPEN_INTERFACE_003_TEST, + USB_HOSTSDK_CLOSE_INTERFACE_003_TEST, + USB_HOSTSDK_OPEN_INTERFACE_004_TEST, + USB_HOSTSDK_OPEN_INTERFACE_005_TEST, + USB_HOSTSDK_OPEN_INTERFACE_006_TEST, + USB_HOSTSDK_SELECT_INTERFACE_001_TEST, + USB_HOSTSDK_SELECT_INTERFACE_002_TEST, + USB_HOSTSDK_SELECT_INTERFACE_003_TEST, + USB_HOSTSDK_SELECT_INTERFACE_004_TEST, + USB_HOSTSDK_SELECT_INTERFACE_005_TEST, + USB_HOSTSDK_SELECT_INTERFACE_006_TEST, + USB_HOSTSDK_CLAIM_INTERFACE_007_TEST, + USB_HOSTSDK_CLAIM_INTERFACE_008_TEST, + USB_HOSTSDK_GET_PIPE_001_TEST, + USB_HOSTSDK_GET_PIPE_002_TEST, + USB_HOSTSDK_GET_PIPE_003_TEST, + USB_HOSTSDK_GET_PIPE_004_TEST, + USB_HOSTSDK_GET_PIPE_005_TEST, + USB_HOSTSDK_GET_PIPE_006_TEST, + USB_HOSTSDK_GET_PIPE_007_TEST, + USB_HOSTSDK_GET_PIPE_008_TEST, + USB_HOSTSDK_ALLOC_REQUEST_001_TEST, + USB_HOSTSDK_ALLOC_REQUEST_002_TEST, + USB_HOSTSDK_FREE_REQUEST_001_TEST, + USB_HOSTSDK_ALLOC_REQUEST_003_TEST, + USB_HOSTSDK_ALLOC_REQUEST_004_TEST, + USB_HOSTSDK_FREE_REQUEST_002_TEST, + USB_HOSTSDK_ALLOC_REQUEST_005_TEST, + USB_HOSTSDK_ALLOC_REQUEST_006_TEST, + USB_HOSTSDK_FREE_REQUEST_003_TEST, + USB_HOSTSDK_ALLOC_REQUEST_007_TEST, + USB_HOSTSDK_ALLOC_REQUEST_008_TEST, + + USB_HOSTSDK_ALLOC_REQUEST_010_TEST, + USB_HOSTSDK_ALLOC_REQUEST_011_TEST, + USB_HOSTSDK_FREE_REQUEST_006_TEST, + USB_HOSTSDK_FILL_ISO_REQUEST_001_TEST, + USB_HOSTSDK_FILL_ISO_REQUEST_002_TEST, + USB_HOSTSDK_FILL_ISO_REQUEST_003_TEST, + USB_HOSTSDK_FILL_ISO_REQUEST_004_TEST, + USB_HOSTSDK_FILL_ISO_REQUEST_005_TEST, + USB_HOSTSDK_FILL_ISO_REQUEST_006_TEST, + + USB_HOSTSDK_FREE_REQUEST_004_TEST, + USB_HOSTSDK_ALLOC_REQUEST_009_TEST, + USB_HOSTSDK_FILL_REQUEST_001_TEST, + USB_HOSTSDK_FILL_REQUEST_002_TEST, + USB_HOSTSDK_FILL_REQUEST_003_TEST, + USB_HOSTSDK_FILL_REQUEST_004_TEST, + USB_HOSTSDK_SUBMIT_REQUEST_SYNC_001_TEST, + USB_HOSTSDK_SUBMIT_REQUEST_SYNC_002_TEST, + USB_HOSTSDK_SUBMIT_REQUEST_SYNC_003_TEST, + USB_HOSTSDK_SUBMIT_REQUEST_SYNC_004_TEST, + USB_HOSTSDK_FILL_REQUEST_005_TEST, + USB_HOSTSDK_FILL_REQUEST_006_TEST, + USB_HOSTSDK_FILL_REQUEST_007_TEST, + USB_HOSTSDK_FILL_REQUEST_008_TEST, + USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_001_TEST, + USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_001_TEST, + USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_002_TEST, + USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_002_TEST, + USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_003_TEST, + USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_003_TEST, + USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_004_TEST, + USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_004_TEST, + USB_HOSTSDK_CLEAR_INTERFACE_HALT_002_TEST, + USB_HOSTSDK_CLEAR_INTERFACE_HALT_003_TEST, + USB_HOSTSDK_CLEAR_INTERFACE_HALT_004_TEST, + USB_HOSTSDK_REMOVE_INTERFACE_001_TEST, + USB_HOSTSDK_ADD_INTERFACE_001_TEST, + USB_HOSTSDK_REMOVE_INTERFACE_002_TEST, + USB_HOSTSDK_ADD_INTERFACE_002_TEST, + USB_HOSTSDK_REMOVE_INTERFACE_003_TEST, + USB_HOSTSDK_ADD_INTERFACE_003_TEST, +}; + +#define TARGET_MASK 0x3 +#define REQUEST_TYPE_MASK 0x3 + +#define DATARATE 9600 +#define CHARFORMAT 8 +#define ACM_NW 16 +#define ACM_NR 16 +#define READ_BUF_SIZE 8192 +#define DIRECTION_MASK 0x1 +#define USB_CTRL_SET_TIMEOUT 5000 +#define USB_PIPE_DIR_OFFSET 7 +#define USB_DEVICE_VENDOR_ID 0x12D1 +#define USB_DEVICE_PRODUCT_ID 0x5000 +#define USB_MAX_BYTE 255 + +struct AcmDevice; + +struct AcmWb { + struct UsbRequest *request; + struct AcmDevice *instance; + uint8_t *buf; + int len; + int use; +}; + +struct AcmRb { + uint8_t *base; + int size; + int index; + int use; + struct AcmDevice *instance; +}; + +struct SerialDevice { + struct AcmDevice *acm; + struct UsbCdcLineCoding lineCoding; + struct OsalMutex lock; + struct DataFifo readFifo; +}; + +struct AcmDevice { + struct IDeviceIoService service; + struct HdfDeviceObject *device; + struct UsbInterface *ctrIface; + struct UsbInterface *intIface; + struct UsbInterface *dataIface; + struct UsbPipeInfo *ctrPipe; + struct UsbPipeInfo *intPipe; + struct UsbPipeInfo *dataInPipe; + struct UsbPipeInfo *dataOutPipe; + struct UsbPipeInfo *isoPipe; + struct AcmWb wb[ACM_NW]; + struct AcmRb rb[ACM_NR]; + struct UsbPipeInfo wPipeInfo; + struct OsalMutex writeLock; + struct OsalMutex readLock; + uint8_t *notificationBuffer; + struct UsbRequest *notifyReq; + struct UsbRequest *readReq[ACM_NR]; + struct UsbRequest *writeReq; + struct UsbRequest *ctrlReq; + struct UsbRequest *isoReq; + struct OsalMutex lock; + struct UsbInterface *itface; + UsbInterfaceHandle *devHandle; + UsbInterfaceHandle *data_devHandle; + UsbInterfaceHandle *ctrl_devHandle; + UsbInterfaceHandle *int_devHandle; + UsbInterfaceHandle *iso_devHandle; + struct UsbSession *session; + struct SerialDevice *port; + uint32_t nbIndex; + uint32_t nbSize; + int transmitting; + int32_t ctrlReqNum; + uint8_t busNum; + uint8_t devAddr; + uint8_t interfaceIndex; + uint32_t ctrlSize; + uint32_t intSize; + uint32_t writeSize; + uint32_t readSize; + struct UsbCdcLineCoding lineCoding; +}; + +struct UsbTest { + struct IDeviceIoService service; + struct HdfDeviceObject *device; + int32_t (*TestEntry)(struct UsbTest *test, int32_t cmd); + uint32_t port; + uint32_t len; + uint8_t *wbuf; + uint8_t *rbuf; + DevHandle handle; +}; + +struct TestControlMsgData { + uint8_t request; + uint8_t requestType; + uint16_t value; + uint16_t index; + void *data; + uint16_t size; +}; + + +struct UsbTestFunc { + enum UsbTestCmd type; + int32_t (*Func)(void); +}; + +#define BITS_PER_WORD 10 +#define MAX_SPEED_HZ 10000000 +#define USB_LOOP_NUM 100 +#define USB_ISO_PACKAT_CNT 16 + +#define USB_RAW_REQUEST_TIME_ZERO_MS 0 + +int32_t UsbTestEntry(int32_t cmd); +#endif /* USB_TEST_H */ diff --git a/test/unittest/model/usb/host/src/hdf_usb_entry_test.c b/test/unittest/model/usb/host/src/hdf_usb_entry_test.c new file mode 100644 index 000000000..67fb14043 --- /dev/null +++ b/test/unittest/model/usb/host/src/hdf_usb_entry_test.c @@ -0,0 +1,29 @@ +/* + * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#include "hdf_usb_entry_test.h" +#include "hdf_log.h" +#include "usb_test.h" +#include "usb_raw_test.h" + +#define HDF_LOG_TAG hdf_usb_entry_test + +int32_t HdfUsbUnitTestEntry(HdfTestMsg *msg) +{ + if (msg == NULL) { + return HDF_FAILURE; + } + dprintf("---%s::command[%u], subCommand[%u]\n", __func__, msg->cmd, msg->subCmd); + if (msg->cmd == TEST_USB_HOST_TYPE){ + msg->result = UsbTestEntry(msg->subCmd); + }else if (msg->cmd == TEST_USB_HOST_RAW_TYPE){ + msg->result = UsbRawTestEntry(msg->subCmd); + } + dprintf("%s::command[%u], subCommand[%u], result:%d\n", __func__, msg->cmd, msg->subCmd, msg->result); + return msg->result; +} diff --git a/test/unittest/model/usb/host/src/usb_raw_io.c b/test/unittest/model/usb/host/src/usb_raw_io.c new file mode 100644 index 000000000..d19eb1369 --- /dev/null +++ b/test/unittest/model/usb/host/src/usb_raw_io.c @@ -0,0 +1,1091 @@ +#include "usb_raw_test.h" +#include "data_fifo.h" +#include "device_resource_if.h" +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "hdf_dlist.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "osal_time.h" +#include "usb_interface.h" +#ifdef LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY +#include "usb_pnp_notify.h" +#endif + +bool g_writeBufFlag = 0; +struct UsbSession *g_session = NULL; +struct AcmRawDevice g_deviceService; +struct AcmRawDevice *g_acm = &g_deviceService; +UsbRawHandle *g_devHandle = NULL; +UsbRawDevice *g_dev = NULL; +int g_activeConfig; +bool g_initFlag; +bool g_stopIoThreadFlag = false; + +int UsbIoThread(void *data) +{ + int ret; + struct AcmRawDevice *acm = (struct AcmRawDevice *)data; + + for (; ;) { + printf("%s:%d\n", __func__, __LINE__); + if (acm == NULL) { + printf("%s:%d acm is NULL\n", __func__, __LINE__); + OsalMSleep(USB_RAW_IO_SLEEP_MS_TIME); + continue; + } + + if (acm->devHandle == NULL) { + printf("%s:%d acm->devHandle is NULL!\n", __func__, __LINE__); + OsalMSleep(USB_RAW_IO_SLEEP_MS_TIME); + continue; + } + + printf("%s:%d\n", __func__, __LINE__); + ret = UsbRawHandleRequests(acm->devHandle); + printf("%s:%d, ret=%d\n", __func__, __LINE__, ret); + if (ret < 0) { + printf("%s:%d UsbRawHandleRequests faile, ret=%d \n", __func__, __LINE__, ret); + if (ret == HDF_DEV_ERR_NO_DEVICE) { + printf("%s:%d, ret=%d\n", __func__, __LINE__, ret); + OsalMSleep(USB_RAW_IO_SLEEP_MS_TIME); + } + } + + if (g_stopIoThreadFlag == true) { + printf("%s:%d\n", __func__, __LINE__); + break; + } + } + + printf("%s:%d exit\n", __func__, __LINE__); + + return HDF_SUCCESS; +} + + +int UsbStartIo(void) +{ + struct OsalThreadParam threadCfg; + int ret; + + printf("%s start\n", __func__); + + /* creat Io thread */ + (void)memset_s(&threadCfg, sizeof(threadCfg), 0, sizeof(threadCfg)); + threadCfg.name = (char *)("usb io thread"); + threadCfg.priority = OSAL_THREAD_PRI_LOW; + threadCfg.stackSize = USB_IO_THREAD_STACK_SIZE; + + ret = OsalThreadCreate(&g_acm->ioThread, \ + (OsalThreadEntry)UsbIoThread, (void *)g_acm); + if (ret != HDF_SUCCESS) { + printf("%s:%d OsalThreadCreate faile, ret=%d \n", __func__, __LINE__, ret); + return ret; + } + + ret = OsalThreadStart(&g_acm->ioThread, &threadCfg); + if (ret != HDF_SUCCESS) { + printf("%s:%d OsalThreadStart faile, ret=%d \n", __func__, __LINE__, ret); + return ret; + } + + return HDF_SUCCESS; +} + +int UsbStopIo(void) +{ + int ret; + g_stopIoThreadFlag = true; + HDF_LOGD("%{public}s:%{public}d", __func__, __LINE__); + OsalMDelay(TEST_SLEEP_TIME); + ret = OsalThreadDestroy(&g_acm->ioThread); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%{public}s:%{public}d OsalThreadDestroy faile, ret=%{public}d ", __func__, __LINE__, ret); + return ret; + } + g_stopIoThreadFlag = false; + return HDF_SUCCESS; +} + +void AcmWriteBulkCallback(void *requestArg) +{ + struct UsbRawRequest *req = (struct UsbRawRequest *)requestArg; + + printf("%s:%d entry!", __func__, __LINE__); + + if (req == NULL) { + printf("%s:%d req is NULL!", __func__, __LINE__); + return; + } + struct RawWb *wb = (struct RawWb *)req->userData; + if (wb == NULL) { + printf("%s:%d userData(wb) is NULL!", __func__, __LINE__); + return; + } + + if (req->status != USB_REQUEST_COMPLETED) { + printf("%s: write req failed, status=%d", __func__, req->status); + } + + wb->use = 0; +} + +void AcmWriteIsoCallback(void *requestArg) +{ + struct UsbRawRequest *req = (struct UsbRawRequest *)requestArg; + printf("%s:%d status:%d\n", __func__, __LINE__, req->status); +} + +void AcmReadBulkCallback(void *requestArg) +{ + struct UsbRawRequest *req = (struct UsbRawRequest *)requestArg; + + printf("%s:%d entry!", __func__, __LINE__); + + if (req == NULL) { + printf("%s:%d req is NULL!", __func__, __LINE__); + return; + } + struct AcmRawDevice *acm = (struct AcmRawDevice *)req->userData; + if (acm == NULL) { + printf("%s:%d userData(acm) is NULL!", __func__, __LINE__); + return; + } + size_t size = req->actualLength; + + switch (req->status) { + case USB_REQUEST_COMPLETED: + HDF_LOGD("Bulk status: %{public}d+size:%{public}u\n", req->status, size); + if (size) { + uint8_t *data = req->buffer; + printf("rcv:%s\n", (char *)data); + + } + break; + case USB_REQUEST_CANCELLED: + printf("%s: the request is cancelled request:%p\n", __func__, req); + return; + default: + printf("%s: the request is failed\n", __func__); + break; + } + + if (UsbRawSubmitRequest(req)) { + printf("%s - UsbRawSubmitRequest failed", __func__); + } +} +void AcmNotifyReqCallback(void *requestArg) +{ + struct UsbRawRequest *req = (struct UsbRawRequest *)requestArg; + + printf("%s:%d entry!", __func__, __LINE__); + + if (req == NULL) { + printf("%s:%d req is NULL!", __func__, __LINE__); + return; + } + struct AcmRawDevice *acm = (struct AcmRawDevice *)req->userData; + if (acm == NULL) { + printf("%s:%d userData(acm) is NULL!", __func__, __LINE__); + return; + } + struct UsbCdcNotification *dr = (struct UsbCdcNotification *)req->buffer; + if (dr == NULL) { + printf("%s:%d req->buffer(dr) is NULL!", __func__, __LINE__); + return; + } + unsigned int currentSize = req->actualLength; + + printf("Irqstatus:%d,actualLength:%u\n", req->status, currentSize); +} + +int AcmWriteBufAlloc(struct AcmRawDevice *acm) +{ + int i; + if (!g_writeBufFlag) { + struct RawWb *wb; + for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) { + wb->buf = OsalMemCalloc(acm->dataOutEp.maxPacketSize); + if (!wb->buf) { + while (i != 0) { + --i; + --wb; + OsalMemFree(wb->buf); + wb->buf = NULL; + } + return -HDF_ERR_MALLOC_FAIL; + } + g_writeBufFlag = true; + } + } + return HDF_SUCCESS; +} + +void AcmWriteBufFree(struct AcmRawDevice *acm) +{ + int i; + struct RawWb *wb; + for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) { + if (wb->buf) { + OsalMemFree(wb->buf); + wb->buf = NULL; + } + } + g_writeBufFlag = false; + return; +} + +void AcmCtrlReqCallback(void *requestArg) +{ + printf("%s:%d entry!", __func__, __LINE__); +} + +int UsbParseConfigDescriptor(struct AcmRawDevice *acm, struct UsbRawConfigDescriptor *config) +{ + uint8_t numInterfaces; + uint8_t i; + uint8_t j; + int ret; + uint8_t ifaceClass; + uint8_t numEndpoints; + const struct UsbRawInterface *interface = NULL; + + numInterfaces = config->configDescriptor.bNumInterfaces; + printf("------numInterfaces = [%d]------\n", numInterfaces); + for (i = 0; i < numInterfaces; i++) { + interface = config->interface[i]; + ifaceClass = interface->altsetting->interfaceDescriptor.bInterfaceClass; + numEndpoints = interface->altsetting->interfaceDescriptor.bNumEndpoints; + + printf("------UsbRawClaimInterface start------\n"); + ret = UsbRawClaimInterface(acm->devHandle, i); + if (ret) { + printf("%s:%d claim interface %u failed\n", __func__, __LINE__, i); + continue; + } + printf("------UsbRawClaimInterface end------\n"); + switch (ifaceClass) { + case USB_DDK_CLASS_COMM: + acm->ctrlIface = i; + /* get the first endpoint by default */ + acm->notifyEp.addr = interface->altsetting->endPoint[0].endpointDescriptor.bEndpointAddress; + acm->notifyEp.interval = interface->altsetting->endPoint[0].endpointDescriptor.bInterval; + acm->notifyEp.maxPacketSize = interface->altsetting->endPoint[0].endpointDescriptor.wMaxPacketSize; + break; + case USB_DDK_CLASS_CDC_DATA: + acm->dataIface = i; + for (j = 0; j < numEndpoints; j++) { + const struct UsbRawEndpointDescriptor *endPoint = &interface->altsetting->endPoint[j]; + + /* get bulk in endpoint */ + if ((endPoint->endpointDescriptor.bEndpointAddress + & USB_DDK_ENDPOINT_DIR_MASK) == USB_DDK_DIR_IN) { + acm->dataInEp.addr = endPoint->endpointDescriptor.bEndpointAddress; + acm->dataInEp.interval = endPoint->endpointDescriptor.bInterval; + acm->dataInEp.maxPacketSize = endPoint->endpointDescriptor.wMaxPacketSize; + } else { /* get bulk out endpoint */ + acm->dataOutEp.addr = endPoint->endpointDescriptor.bEndpointAddress; + acm->dataOutEp.interval = endPoint->endpointDescriptor.bInterval; + acm->dataOutEp.maxPacketSize = endPoint->endpointDescriptor.wMaxPacketSize; + } + } + break; + default: + printf("%s:%d wrong descriptor type\n", __func__, __LINE__); + break; + } + } + + return HDF_SUCCESS; +} + + +struct UsbRawTestFunc g_usbRawFunc[] = { + { USB_RAW_SDK_IF_START_IO, UsbStartIo}, + { USB_RAW_SDK_IF_INIT_001_TEST, CheckRawSdkIfInit001}, + { USB_RAW_SDK_IF_EXIT_001_TEST, CheckRawSdkIfExit001}, + { USB_RAW_SDK_IF_INIT_002_TEST, CheckRawSdkIfInit002}, + { USB_RAW_SDK_IF_EXIT_002_TEST, CheckRawSdkIfExit002}, + { USB_RAW_SDK_IF_INIT_003_TEST, CheckRawSdkIfInit003}, + { USB_RAW_SDK_IF_INIT_004_TEST, CheckRawSdkIfInit004}, + { USB_RAW_SDK_IF_INIT_005_TEST, CheckRawSdkIfInit005}, + { USB_RAW_SDK_IF_OPEN_DEVICE_001_TEST, CheckRawSdkIfOpenDevice001}, + { USB_RAW_SDK_IF_OPEN_DEVICE_002_TEST, CheckRawSdkIfOpenDevice002}, + { USB_RAW_SDK_IF_OPEN_DEVICE_003_TEST, CheckRawSdkIfOpenDevice003}, + { USB_RAW_SDK_IF_OPEN_DEVICE_004_TEST, CheckRawSdkIfOpenDevice004}, + { USB_RAW_SDK_IF_OPEN_DEVICE_005_TEST, CheckRawSdkIfOpenDevice005}, + { USB_RAW_SDK_IF_OPEN_DEVICE_006_TEST, CheckRawSdkIfOpenDevice006}, + { USB_RAW_SDK_IF_RESET_DEVICE_001_TEST, CheckRawSdkIfResetDevice001}, + { USB_RAW_SDK_IF_RESET_DEVICE_002_TEST, CheckRawSdkIfResetDevice002}, + { USB_RAW_SDK_IF_CLOSE_DEVICE_001_TEST, CheckRawSdkIfCloseDevice001}, + { USB_RAW_SDK_IF_CLOSE_DEVICE_002_TEST, CheckRawSdkIfCloseDevice002}, + { USB_RAW_SDK_IF_OPEN_DEVICE_007_TEST, CheckRawSdkIfOpenDevice007}, + { USB_RAW_SDK_IF_GET_CONFIGURATION_001_TEST, CheckRawSdkIfGetConfiguration001}, + { USB_RAW_SDK_IF_GET_CONFIGURATION_002_TEST, CheckRawSdkIfGetConfiguration002}, + { USB_RAW_SDK_IF_GET_CONFIGURATION_003_TEST, CheckRawSdkIfGetConfiguration003}, + { USB_RAW_SDK_IF_GET_CONFIGURATION_004_TEST, CheckRawSdkIfGetConfiguration004}, + { USB_RAW_SDK_IF_GET_DEVICE_001_TEST, CheckRawSdkIfGetDevice001}, + { USB_RAW_SDK_IF_GET_DEVICE_002_TEST, CheckRawSdkIfGetDevice002}, + { USB_RAW_SDK_IF_GET_CONFIG_DESC_001_TEST, CheckRawSdkIfGetConfigDescriptor001}, + { USB_RAW_SDK_IF_GET_CONFIG_DESC_002_TEST, CheckRawSdkIfGetConfigDescriptor002}, + { USB_RAW_SDK_IF_GET_CONFIG_DESC_003_TEST, CheckRawSdkIfGetConfigDescriptor003}, + { USB_RAW_SDK_IF_GET_CONFIG_DESC_004_TEST, CheckRawSdkIfGetConfigDescriptor004}, + { USB_RAW_SDK_IF_SET_CONFIGURATION_001_TEST, CheckRawSdkIfSetConfiguration001}, + { USB_RAW_SDK_IF_SET_CONFIGURATION_002_TEST, CheckRawSdkIfSetConfiguration002}, + { USB_RAW_SDK_IF_SET_CONFIGURATION_003_TEST, CheckRawSdkIfSetConfiguration003}, + { USB_RAW_SDK_IF_SET_CONFIGURATION_004_TEST, CheckRawSdkIfSetConfiguration004}, + { USB_RAW_SDK_IF_SET_CONFIGURATION_005_TEST, CheckRawSdkIfSetConfiguration005}, + { USB_RAW_SDK_IF_SET_CONFIGURATION_006_TEST, CheckRawSdkIfSetConfiguration006}, + { USB_RAW_SDK_IF_SET_CONFIGURATION_007_TEST, CheckRawSdkIfSetConfiguration007}, + { USB_RAW_SDK_IF_SET_CONFIGURATION_008_TEST, CheckRawSdkIfSetConfiguration008}, + { USB_RAW_SDK_IF_GET_DEVICE_DESC_001_TEST, CheckRawSdkIfGetDeviceDescriptor001}, + { USB_RAW_SDK_IF_GET_DEVICE_DESC_002_TEST, CheckRawSdkIfGetDeviceDescriptor002}, + { USB_RAW_SDK_IF_GET_DEVICE_DESC_003_TEST, CheckRawSdkIfGetDeviceDescriptor003}, + { USB_RAW_SDK_IF_GET_DEVICE_DESC_004_TEST, CheckRawSdkIfGetDeviceDescriptor004}, + { USB_RAW_SDK_IF_GET_CONFIG_DESC_005_TEST, CheckRawSdkIfGetConfigDescriptor005}, + { USB_RAW_SDK_IF_GET_DEVICE_DESC_005_TEST, CheckRawSdkIfGetDeviceDescriptor005}, + { USB_RAW_SDK_IF_CLAMIN_INTERFACE_001_TEST, CheckRawSdkIfClaimInterface001}, + { USB_RAW_SDK_IF_CLAMIN_INTERFACE_002_TEST, CheckRawSdkIfClaimInterface002}, + { USB_RAW_SDK_IF_CLAMIN_INTERFACE_003_TEST, CheckRawSdkIfClaimInterface003}, + { USB_RAW_SDK_IF_CLAMIN_INTERFACE_004_TEST, CheckRawSdkIfClaimInterface004}, + { USB_RAW_SDK_IF_CLAMIN_INTERFACE_005_TEST, CheckRawSdkIfClaimInterface005}, + { USB_RAW_SDK_IF_RELEASE_INTERFACE_001_TEST, CheckRawSdkIfReleaseInterface001}, + { USB_RAW_SDK_IF_RELEASE_INTERFACE_002_TEST, CheckRawSdkIfReleaseInterface002}, + { USB_RAW_SDK_IF_RELEASE_INTERFACE_003_TEST, CheckRawSdkIfReleaseInterface003}, + { USB_RAW_SDK_IF_RELEASE_INTERFACE_004_TEST, CheckRawSdkIfReleaseInterface004}, + { USB_RAW_SDK_IF_CLAMIN_INTERFACE_006_TEST, CheckRawSdkIfClaimInterface006}, + { USB_RAW_SDK_IF_ALLOC_REQUEST_001_TEST, CheckRawSdkIfAllocRequest001}, + { USB_RAW_SDK_IF_ALLOC_REQUEST_002_TEST, CheckRawSdkIfAllocRequest002}, + { USB_RAW_SDK_IF_ALLOC_REQUEST_003_TEST, CheckRawSdkIfAllocRequest003}, + { USB_RAW_SDK_IF_ALLOC_REQUEST_004_TEST, CheckRawSdkIfAllocRequest004}, + { USB_RAW_SDK_IF_ALLOC_REQUEST_005_TEST, CheckRawSdkIfAllocRequest005}, + { USB_RAW_SDK_IF_ALLOC_REQUEST_006_TEST, CheckRawSdkIfAllocRequest006}, + { USB_RAW_SDK_IF_ALLOC_REQUEST_007_TEST, CheckRawSdkIfAllocRequest007}, + { USB_RAW_SDK_IF_ALLOC_REQUEST_008_TEST, CheckRawSdkIfAllocRequest008}, + { USB_RAW_SDK_IF_ALLOC_REQUEST_010_TEST, CheckRawSdkIfAllocRequest010}, + { USB_RAW_SDK_IF_ALLOC_REQUEST_011_TEST, CheckRawSdkIfAllocRequest011}, + { USB_RAW_SDK_IF_FREE_REQUEST_006_TEST, CheckRawSdkIfFreeRequest006}, + { USB_RAW_SDK_IF_FILL_ISO_REQUEST_001_TEST, CheckRawSdkIfFillIsoRequest001}, + { USB_RAW_SDK_IF_FILL_ISO_REQUEST_002_TEST, CheckRawSdkIfFillIsoRequest002}, + { USB_RAW_SDK_IF_FILL_ISO_REQUEST_003_TEST, CheckRawSdkIfFillIsoRequest003}, + { USB_RAW_SDK_IF_FILL_ISO_REQUEST_004_TEST, CheckRawSdkIfFillIsoRequest004}, + { USB_RAW_SDK_IF_FILL_ISO_REQUEST_005_TEST, CheckRawSdkIfFillIsoRequest005}, + { USB_RAW_SDK_IF_FILL_ISO_REQUEST_006_TEST, CheckRawSdkIfFillIsoRequest006}, + { USB_RAW_SDK_IF_FREE_REQUEST_001_TEST, CheckRawSdkIfFreeRequest001}, + { USB_RAW_SDK_IF_FREE_REQUEST_002_TEST, CheckRawSdkIfFreeRequest002}, + { USB_RAW_SDK_IF_FREE_REQUEST_003_TEST, CheckRawSdkIfFreeRequest003}, + { USB_RAW_SDK_IF_FREE_REQUEST_004_TEST, CheckRawSdkIfFreeRequest004}, + { USB_RAW_SDK_IF_FREE_REQUEST_005_TEST, CheckRawSdkIfFreeRequest005}, + { USB_RAW_SDK_IF_ALLOC_REQUEST_009_TEST, CheckRawSdkIfAllocRequest009}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_001_TEST, CheckRawSdkIfGetDescriptor001}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_002_TEST, CheckRawSdkIfGetDescriptor002}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_003_TEST, CheckRawSdkIfGetDescriptor003}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_004_TEST, CheckRawSdkIfGetDescriptor004}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_005_TEST, CheckRawSdkIfGetDescriptor005}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_006_TEST, CheckRawSdkIfGetDescriptor006}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_007_TEST, CheckRawSdkIfGetDescriptor007}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_008_TEST, CheckRawSdkIfGetDescriptor008}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_009_TEST, CheckRawSdkIfGetDescriptor009}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_010_TEST, CheckRawSdkIfGetDescriptor010}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_011_TEST, CheckRawSdkIfGetDescriptor011}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_012_TEST, CheckRawSdkIfGetDescriptor012}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_013_TEST, CheckRawSdkIfGetDescriptor013}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_014_TEST, CheckRawSdkIfGetDescriptor014}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_015_TEST, CheckRawSdkIfGetDescriptor015}, + { USB_RAW_SDK_IF_GET_DESCRIPTION_016_TEST, CheckRawSdkIfGetDescriptor016}, + { USB_RAW_SDK_IF_FILL_BULK_REQUEST_001_TEST, CheckRawSdkIfFillBulkRequest001}, + { USB_RAW_SDK_IF_FILL_BULK_REQUEST_002_TEST, CheckRawSdkIfFillBulkRequest002}, + { USB_RAW_SDK_IF_FILL_INT_REQUEST_001_TEST, CheckRawSdkIfFillInterruptRequest001}, + { USB_RAW_SDK_IF_FILL_INT_REQUEST_002_TEST, CheckRawSdkIfFillInterruptRequest002}, + { USB_RAW_SDK_IF_FILL_INT_REQUEST_003_TEST, CheckRawSdkIfFillInterruptRequest003}, + { USB_RAW_SDK_IF_FILL_INT_REQUEST_004_TEST, CheckRawSdkIfFillInterruptRequest004}, + { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_001_TEST, CheckRawSdkIfFillControlRequest001}, + { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_002_TEST, CheckRawSdkIfFillControlRequest002}, + { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_003_TEST, CheckRawSdkIfFillControlRequest003}, + { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_004_TEST, CheckRawSdkIfFillControlRequest004}, + { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_005_TEST, CheckRawSdkIfFillControlRequest005}, + { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_006_TEST, CheckRawSdkIfFillControlRequest006}, + { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_007_TEST, CheckRawSdkIfFillControlRequest007}, + { USB_RAW_SDK_IF_FILL_CONTROL_REQUEST_008_TEST, CheckRawSdkIfFillControlRequest008}, + { USB_RAW_SDK_IF_FILL_CONTROL_SETUP_001_TEST, CheckRawSdkIfFillControlSetup001}, + { USB_RAW_SDK_IF_FILL_CONTROL_SETUP_002_TEST, CheckRawSdkIfFillControlSetup002}, + { USB_RAW_SDK_IF_FILL_CONTROL_SETUP_003_TEST, CheckRawSdkIfFillControlSetup003}, + { USB_RAW_SDK_IF_FILL_CONTROL_SETUP_004_TEST, CheckRawSdkIfFillControlSetup004}, + { USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_001_TEST, CheckRawSdkIfSendControlRequest001}, + { USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_002_TEST, CheckRawSdkIfSendControlRequest002}, + { USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_003_TEST, CheckRawSdkIfSendControlRequest003}, + { USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_004_TEST, CheckRawSdkIfSendControlRequest004}, + { USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_005_TEST, CheckRawSdkIfSendControlRequest005}, + { USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_006_TEST, CheckRawSdkIfSendControlRequest006}, + { USB_RAW_SDK_IF_SEND_CONTROL_REQUEST_007_TEST, CheckRawSdkIfSendControlRequest007}, + { USB_RAW_SDK_IF_SEND_BULK_REQUEST_001_TEST, CheckRawSdkIfSendBulkRequest001}, + { USB_RAW_SDK_IF_SEND_BULK_REQUEST_002_TEST, CheckRawSdkIfSendBulkRequest002}, + { USB_RAW_SDK_IF_SEND_BULK_REQUEST_003_TEST, CheckRawSdkIfSendBulkRequest003}, + { USB_RAW_SDK_IF_SEND_BULK_REQUEST_004_TEST, CheckRawSdkIfSendBulkRequest004}, + { USB_RAW_SDK_IF_SEND_BULK_REQUEST_005_TEST, CheckRawSdkIfSendBulkRequest005}, + { USB_RAW_SDK_IF_SEND_INT_REQUEST_001_TEST, CheckRawSdkIfSendInterruptRequest001}, + { USB_RAW_SDK_IF_SEND_INT_REQUEST_002_TEST, CheckRawSdkIfSendInterruptRequest002}, + { USB_RAW_SDK_IF_SEND_INT_REQUEST_003_TEST, CheckRawSdkIfSendInterruptRequest003}, + { USB_RAW_SDK_IF_SEND_INT_REQUEST_004_TEST, CheckRawSdkIfSendInterruptRequest004}, + { USB_RAW_SDK_IF_FILL_BULK_REQUEST_003_TEST, CheckRawSdkIfFillBulkRequest003}, + { USB_RAW_SDK_IF_FILL_BULK_REQUEST_004_TEST, CheckRawSdkIfFillBulkRequest004}, + { USB_RAW_SDK_IF_FILL_INT_REQUEST_005_TEST, CheckRawSdkIfFillInterruptRequest005}, + { USB_RAW_SDK_IF_SUBMIT_REQUEST_001_TEST, CheckRawSdkIfSubmitRequest001}, + { USB_RAW_SDK_IF_SUBMIT_REQUEST_002_TEST, CheckRawSdkIfSubmitRequest002}, + { USB_RAW_SDK_IF_SUBMIT_REQUEST_003_TEST, CheckRawSdkIfSubmitRequest003}, + { USB_RAW_SDK_IF_SUBMIT_REQUEST_004_TEST, CheckRawSdkIfSubmitRequest004}, + { USB_RAW_SDK_IF_CANCEL_REQUEST_001_TEST, CheckRawSdkIfCancelRequest001}, + { USB_RAW_SDK_IF_CANCEL_REQUEST_002_TEST, CheckRawSdkIfCancelRequest002}, + { USB_RAW_SDK_IF_CANCEL_REQUEST_003_TEST, CheckRawSdkIfCancelRequest003}, + { USB_RAW_SDK_IF_CANCEL_REQUEST_004_TEST, CheckRawSdkIfCancelRequest004}, + { USB_RAW_SDK_IF_STOP_IO, UsbStopIo}, + +}; + +int32_t UsbRawTestEntry(int32_t cmd) +{ + int32_t i; + int32_t ret = HDF_ERR_NOT_SUPPORT; + + if (g_initFlag == false) { +#ifdef LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY + struct UsbGetDevicePara paraData; + struct usb_device *usbPnpDevice = NULL; + paraData.type = USB_PNP_DEVICE_VENDOR_PRODUCT_TYPE; + paraData.vendorId = USB_DEVICE_VENDOR_ID; + paraData.productId = USB_DEVICE_PRODUCT_ID; + usbPnpDevice = UsbPnpNotifyGetUsbDevice(paraData); + if (usbPnpDevice == NULL) { + HDF_LOGE("%s:%d UsbPnpNotifyGetUsbDevice is NULL!", __func__, __LINE__); + return HDF_ERR_INVALID_PARAM; + } + g_acm->busNum = usbPnpDevice->address; + g_acm->devAddr = usbPnpDevice->port_no; + HDF_LOGE("%s: busNum %d++devAddr %d", __func__, g_acm->busNum, g_acm->devAddr); + g_initFlag = true; +#else + HDF_LOGE("%s:%d pnp notify module is not support!", __func__, __LINE__); + return HDF_ERR_NOT_SUPPORT; +#endif + } + for (i = 0; i < sizeof(g_usbRawFunc) / sizeof(g_usbRawFunc[0]); i++) { + if (cmd == g_usbRawFunc[i].type && g_usbRawFunc[i].Func != NULL) { + ret = g_usbRawFunc[i].Func(); + HDF_LOGE("%s: cmd %d ret %d", __func__, cmd, ret); + break; + } + } + return ret; +} + +int32_t CheckRawSdkIfInit001(void) +{ + int32_t ret; + + ret = UsbRawInit(&g_session); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->session = g_session; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfExit001(void) +{ + int32_t ret; + + ret = UsbRawExit(g_acm->session); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_session = NULL; + g_acm->session = g_session; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfInit002(void) +{ + int32_t ret; + + ret = UsbRawInit(NULL); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfExit002(void) +{ + int32_t ret; + + ret = UsbRawExit(NULL); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfInit003(void) +{ + int ret; + int i; + + for (i = 0; i < USB_LOOP_NUM; i++) { + ret = UsbRawInit(&g_session); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->session = g_session; + ret = UsbRawExit(g_acm->session); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_session = NULL; + g_acm->session = g_session; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfInit004(void) +{ + int ret; + int i; + + for (i = 0; i < USB_LOOP_NUM; i++) { + ret = UsbRawInit(NULL); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + ret = UsbRawExit(NULL); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfInit005(void) +{ + int32_t ret; + + ret = UsbRawInit(&g_session); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->session = g_session; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfOpenDevice001(void) +{ + g_devHandle = UsbRawOpenDevice(NULL, g_acm->busNum, g_acm->devAddr); + if (g_devHandle) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->devHandle = g_devHandle; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfOpenDevice002(void) +{ + uint8_t busNum = 1U; + uint8_t devAddr = 100U; + g_devHandle = UsbRawOpenDevice(g_acm->session, busNum, devAddr); + if (g_devHandle) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->devHandle = g_devHandle; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfOpenDevice003(void) +{ + uint8_t busNum = 1U; + uint8_t devAddr = 255U; + g_devHandle = UsbRawOpenDevice(g_acm->session, busNum, devAddr); + if (g_devHandle) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->devHandle = g_devHandle; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfOpenDevice004(void) +{ + uint8_t busNum = 100U; + uint8_t devAddr = 2U; + g_devHandle = UsbRawOpenDevice(g_acm->session, busNum, devAddr); + if (g_devHandle) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->devHandle = g_devHandle; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfOpenDevice005(void) +{ + uint8_t busNum = 255U; + uint8_t devAddr = 2U; + g_devHandle = UsbRawOpenDevice(g_acm->session, busNum, devAddr); + if (g_devHandle) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->devHandle = g_devHandle; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfOpenDevice006(void) +{ + g_devHandle = UsbRawOpenDevice(g_acm->session, g_acm->busNum, g_acm->devAddr); + if (g_devHandle == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->devHandle = g_devHandle; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfResetDevice001(void) +{ + int32_t ret; + + ret = UsbRawResetDevice(NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfResetDevice002(void) +{ + int32_t ret; + + ret = UsbRawResetDevice(g_acm->devHandle); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfCloseDevice001(void) +{ + int32_t ret; + + ret = UsbRawCloseDevice(NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfCloseDevice002(void) +{ + int32_t ret; + + ret = UsbRawCloseDevice(g_acm->devHandle); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->devHandle = NULL; + g_devHandle = g_acm->devHandle; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfOpenDevice007(void) +{ + g_devHandle = UsbRawOpenDevice(g_session, g_acm->busNum, g_acm->devAddr); + if (g_devHandle == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->devHandle = g_devHandle; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetConfiguration001(void) +{ + int32_t ret; + + ret = UsbRawGetConfiguration(NULL, &g_activeConfig); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetConfiguration002(void) +{ + int32_t ret; + + ret = UsbRawGetConfiguration(g_acm->devHandle, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetConfiguration003(void) +{ + int32_t ret; + + ret = UsbRawGetConfiguration(NULL, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetConfiguration004(void) +{ + int32_t ret; + + ret = UsbRawGetConfiguration(g_acm->devHandle, &g_activeConfig); + printf("------g_activeConfig = [%d]------\n", g_activeConfig); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDevice001(void) +{ + g_dev = UsbRawGetDevice(NULL); + if (g_dev) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDevice002(void) +{ + g_dev = UsbRawGetDevice(g_acm->devHandle); + if (g_dev == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + + +int32_t CheckRawSdkIfClaimInterface002(void) +{ + int ret; + int interfaceNumber = 1; + + ret = UsbRawClaimInterface(g_devHandle, interfaceNumber); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfClaimInterface003(void) +{ + int ret; + int interfaceNumber = 0; + + ret = UsbRawClaimInterface(g_devHandle, interfaceNumber); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfClaimInterface004(void) +{ + int ret; + int interfaceNumber = USB_MAX_BYTE; + + ret = UsbRawClaimInterface(g_devHandle, interfaceNumber); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDeviceDescriptor002(void) +{ + int ret; + + ret = UsbRawGetDeviceDescriptor(g_dev, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDeviceDescriptor003(void) +{ + int ret; + + ret = UsbRawGetDeviceDescriptor(NULL, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDeviceDescriptor004(void) +{ + struct UsbDeviceDescriptor desc; + int ret; + + ret = UsbRawGetDeviceDescriptor(g_dev, &desc); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetConfigDescriptor005(void) +{ + int32_t ret; + + printf("------g_activeConfig = [%d]------\n", g_activeConfig); + ret = UsbRawGetConfigDescriptor(g_dev, g_activeConfig, &g_acm->config); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDeviceDescriptor005(void) +{ + struct UsbDeviceDescriptor desc; + int ret; + + ret = UsbRawGetDeviceDescriptor(g_dev, &desc); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetConfigDescriptor001(void) +{ + int32_t ret; + + ret = UsbRawGetConfigDescriptor(NULL, g_activeConfig, &g_acm->config); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetConfigDescriptor002(void) +{ + int32_t ret; + + ret = UsbRawGetConfigDescriptor(g_dev, g_activeConfig, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetConfigDescriptor003(void) +{ + int32_t ret; + + ret = UsbRawGetConfigDescriptor(NULL, g_activeConfig, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetConfigDescriptor004(void) +{ + int32_t ret; + + printf("------g_activeConfig = [%d]------\n", g_activeConfig); + ret = UsbRawGetConfigDescriptor(g_dev, g_activeConfig, &g_acm->config); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSetConfiguration001(void) +{ + int32_t ret; + int config = 0; + + ret = UsbRawSetConfiguration(NULL, config); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSetConfiguration002(void) +{ + int32_t ret; + int config = 0; + + ret = UsbRawSetConfiguration(g_acm->devHandle, config); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSetConfiguration003(void) +{ + int32_t ret; + int config = 1; + + ret = UsbRawSetConfiguration(g_acm->devHandle, config); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSetConfiguration004(void) +{ + int32_t ret; + int config = 10; + + ret = UsbRawSetConfiguration(g_acm->devHandle, config); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: error", __func__); + return HDF_SUCCESS; + } + HDF_LOGE("%s: success", __func__); + return HDF_FAILURE; +} + +int32_t CheckRawSdkIfSetConfiguration005(void) +{ + int32_t ret; + int config = 100; + + ret = UsbRawSetConfiguration(g_acm->devHandle, config); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: error", __func__); + return HDF_SUCCESS; + } + HDF_LOGE("%s: success", __func__); + return HDF_FAILURE; +} + +int32_t CheckRawSdkIfSetConfiguration006(void) +{ + int32_t ret; + int config = 200; + + ret = UsbRawSetConfiguration(g_acm->devHandle, config); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: error", __func__); + return HDF_SUCCESS; + } + HDF_LOGE("%s: success", __func__); + return HDF_FAILURE; +} + +int32_t CheckRawSdkIfSetConfiguration007(void) +{ + int32_t ret; + int config = USB_MAX_BYTE; + + ret = UsbRawSetConfiguration(g_acm->devHandle, config); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: error", __func__); + return HDF_SUCCESS; + } + HDF_LOGE("%s: success", __func__); + return HDF_FAILURE; +} + +int32_t CheckRawSdkIfSetConfiguration008(void) +{ + int32_t ret; + int config = 0; + + ret = UsbRawSetConfiguration(g_acm->devHandle, config); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} diff --git a/test/unittest/model/usb/host/src/usb_raw_test.c b/test/unittest/model/usb/host/src/usb_raw_test.c new file mode 100644 index 000000000..8788875e3 --- /dev/null +++ b/test/unittest/model/usb/host/src/usb_raw_test.c @@ -0,0 +1,1752 @@ +/* + * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#include "usb_raw_test.h" +#include "data_fifo.h" +#include "device_resource_if.h" +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "hdf_dlist.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "osal_time.h" +#include "usb_interface.h" +#ifdef LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY +#include "usb_pnp_notify.h" +#endif + +#define HDF_LOG_TAG usb_raw_test_c + +int32_t CheckRawSdkIfGetDeviceDescriptor001(void) +{ + struct UsbDeviceDescriptor desc; + int ret; + ret = UsbRawGetDeviceDescriptor(NULL, &desc); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfClaimInterface001(void) +{ + int ret; + int interfaceNumber = 1; + + ret = UsbRawClaimInterface(NULL, interfaceNumber); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfClaimInterface005(void) +{ + int ret; + + ret = UsbParseConfigDescriptor(g_acm, g_acm->config); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfReleaseInterface001(void) +{ + int ret; + + ret = UsbRawReleaseInterface(NULL, g_acm->ctrlIface); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfReleaseInterface002(void) +{ + int ret; + + ret = UsbRawReleaseInterface(g_acm->devHandle, g_acm->ctrlIface); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfReleaseInterface003(void) +{ + int ret; + + ret = UsbRawReleaseInterface(NULL, g_acm->dataIface); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfReleaseInterface004(void) +{ + int ret; + + ret = UsbRawReleaseInterface(g_acm->devHandle, g_acm->dataIface); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfClaimInterface006(void) +{ + int ret; + + ret = UsbParseConfigDescriptor(g_acm, g_acm->config); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfAllocRequest001(void) +{ + int i; + int ret; + + ret = AcmWriteBufAlloc(g_acm); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + + for (i = 0; i < ACM_NW; i++) { + g_acm->wb[i].request = UsbRawAllocRequest(NULL, 0, g_acm->dataOutEp.maxPacketSize); + g_acm->wb[i].instance = g_acm; + if (g_acm->wb[i].request) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfAllocRequest002(void) +{ + int i; + int ret; + + ret = AcmWriteBufAlloc(g_acm); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + + for (i = 0; i < ACM_NW; i++) { + g_acm->wb[i].request = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->dataOutEp.maxPacketSize); + g_acm->wb[i].instance = g_acm; + ((struct UsbHostRequest *)(g_acm->wb[i].request))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle; + if (g_acm->wb[i].request == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfAllocRequest003(void) +{ + int i; + + for (i = 0; i < ACM_NR; i++) { + g_acm->readReq[i] = UsbRawAllocRequest(NULL, 0, g_acm->dataInEp.maxPacketSize); + if (g_acm->readReq[i]) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfAllocRequest004(void) +{ + int i; + + for (i = 0; i < ACM_NR; i++) { + g_acm->readReq[i] = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->dataInEp.maxPacketSize); + ((struct UsbHostRequest *)(g_acm->readReq[i]))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle; + if (g_acm->readReq[i] == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfAllocRequest005(void) +{ + g_acm->ctrlReq = UsbRawAllocRequest(NULL, 0, USB_CTRL_REQ_SIZE); + if (g_acm->ctrlReq) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfAllocRequest006(void) +{ + g_acm->ctrlReq = UsbRawAllocRequest(g_acm->devHandle, 0, USB_CTRL_REQ_SIZE); + ((struct UsbHostRequest *)(g_acm->ctrlReq))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle; + if (g_acm->ctrlReq == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfAllocRequest007(void) +{ + g_acm->notifyReq = UsbRawAllocRequest(NULL, 0, g_acm->notifyEp.maxPacketSize); + if (g_acm->notifyReq) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfAllocRequest008(void) +{ + g_acm->notifyReq = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->notifyEp.maxPacketSize); + ((struct UsbHostRequest *)(g_acm->notifyReq))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle; + if (g_acm->notifyReq == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} +int32_t CheckRawSdkIfAllocRequest010(void) +{ + g_acm->isoReq = UsbRawAllocRequest(NULL, USB_ISO_PACKAT_CNT, g_acm->isoEp.maxPacketSize); + if (g_acm->isoReq == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + ((struct UsbHostRequest *)(g_acm->isoReq))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} +int32_t CheckRawSdkIfAllocRequest011(void) +{ + g_acm->isoReq = UsbRawAllocRequest(g_acm->devHandle, USB_ISO_PACKAT_CNT, g_acm->isoEp.maxPacketSize); + if (g_acm->isoReq == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + ((struct UsbHostRequest *)(g_acm->isoReq))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFreeRequest006(void) +{ + int32_t ret; + + ret = UsbRawFreeRequest(g_acm->isoReq); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->isoReq = NULL; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillIsoRequest001(void) +{ + struct UsbRawFillRequestData reqData; + int32_t ret; + int i; + uint32_t size; + char sendData[] = {"abcde\0"}; + size = strlen(sendData) + 1; + printf("---size:%d\n", size); + size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size; + for (i = 0; i < 1; i++) { + reqData.endPoint = g_acm->isoEp.addr; + reqData.numIsoPackets = USB_ISO_PACKAT_CNT; + reqData.callback = AcmWriteIsoCallback; + reqData.timeout = USB_CTRL_SET_TIMEOUT; + reqData.buffer = (unsigned char*)sendData; + reqData.length = size; + ret = UsbRawFillIsoRequest(g_acm->isoReq, g_acm->devHandle, &reqData); + if (ret) { + printf("%s: error++ret", __func__, ret); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillIsoRequest002(void) +{ + struct UsbRawFillRequestData reqData; + int32_t ret; + int i; + uint32_t size; + char sendData[] = {"abcde\0"}; + size = strlen(sendData) + 1; + printf("---size:%d\n", size); + size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size; + for (i = 0; i < 1; i++) { + reqData.endPoint = g_acm->isoEp.addr; + reqData.numIsoPackets = USB_ISO_PACKAT_CNT; + reqData.callback = AcmWriteIsoCallback; + reqData.timeout = USB_CTRL_SET_TIMEOUT; + reqData.buffer = (unsigned char*)sendData; + reqData.length = size; + ret = UsbRawFillIsoRequest(NULL, g_acm->devHandle, &reqData); + if (ret) { + printf("%s: error++ret", __func__, ret); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillIsoRequest003(void) +{ + struct UsbRawFillRequestData reqData; + int32_t ret; + int i; + uint32_t size; + char sendData[] = {"abcde\0"}; + size = strlen(sendData) + 1; + printf("---size:%d\n", size); + size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size; + for (i = 0; i < 1; i++) { + reqData.endPoint = g_acm->isoEp.addr; + reqData.numIsoPackets = USB_ISO_PACKAT_CNT; + reqData.callback = AcmWriteIsoCallback; + reqData.timeout = USB_CTRL_SET_TIMEOUT; + reqData.buffer = (unsigned char*)sendData; + reqData.length = size; + ret = UsbRawFillIsoRequest(g_acm->isoReq, g_acm->devHandle, NULL); + if (ret) { + printf("%s: error++ret", __func__, ret); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillIsoRequest004(void) +{ + struct UsbRawFillRequestData reqData; + int32_t ret; + int i; + uint32_t size; + char sendData[] = {"abcde\0"}; + size = strlen(sendData) + 1; + printf("---size:%d\n", size); + size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size; + for (i = 0; i < 1; i++) { + reqData.endPoint = g_acm->isoEp.addr; + reqData.numIsoPackets = USB_ISO_PACKAT_CNT; + reqData.callback = AcmWriteIsoCallback; + reqData.timeout = USB_CTRL_SET_TIMEOUT; + reqData.buffer = (unsigned char*)sendData; + reqData.length = size; + ret = UsbRawFillIsoRequest(g_acm->isoReq, NULL, &reqData); + if (ret) { + printf("%s: error++ret", __func__, ret); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillIsoRequest005(void) +{ + struct UsbRawFillRequestData reqData; + int32_t ret; + int i; + uint32_t size; + char sendData[] = {"abcde\0"}; + size = strlen(sendData) + 1; + printf("---size:%d\n", size); + size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size; + for (i = 0; i < 1; i++) { + reqData.endPoint = g_acm->isoEp.addr; + reqData.numIsoPackets = USB_ISO_PACKAT_CNT; + reqData.callback = AcmWriteIsoCallback; + reqData.timeout = USB_CTRL_SET_TIMEOUT; + reqData.buffer = (unsigned char*)sendData; + reqData.length = size; + ret = UsbRawFillIsoRequest(NULL, NULL, &reqData); + if (ret) { + printf("%s: error++ret", __func__, ret); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillIsoRequest006(void) +{ + struct UsbRawFillRequestData reqData; + int32_t ret; + int i; + uint32_t size; + char sendData[] = {"abcde\0"}; + size = strlen(sendData) + 1; + printf("---size:%d\n", size); + size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size; + for (i = 0; i < 1; i++) { + reqData.endPoint = g_acm->isoEp.addr; + reqData.numIsoPackets = USB_ISO_PACKAT_CNT; + reqData.callback = AcmWriteIsoCallback; + reqData.timeout = USB_CTRL_SET_TIMEOUT; + reqData.buffer = (unsigned char*)sendData; + reqData.length = size; + ret = UsbRawFillIsoRequest(NULL, NULL, NULL); + if (ret) { + printf("%s: error++ret", __func__, ret); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} +int32_t CheckRawSdkIfFreeRequest001(void) +{ + int32_t ret; + int i; + + for (i = 0; i < ACM_NW; i++) { + ret = UsbRawFreeRequest(g_acm->wb[i].request); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->wb[i].request = NULL; + } + AcmWriteBufFree(g_acm); + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFreeRequest002(void) +{ + int32_t ret; + int i; + + for (i = 0; i < ACM_NW; i++) { + ret = UsbRawFreeRequest(g_acm->readReq[i]); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->readReq[i] = NULL; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFreeRequest003(void) +{ + int32_t ret; + + ret = UsbRawFreeRequest(g_acm->ctrlReq); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->ctrlReq = NULL; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFreeRequest004(void) +{ + int32_t ret; + + ret = UsbRawFreeRequest(g_acm->notifyReq); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->notifyReq = NULL; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFreeRequest005(void) +{ + int32_t ret; + + ret = UsbRawFreeRequest(NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfAllocRequest009(void) +{ + int i; + int ret; + + ret = AcmWriteBufAlloc(g_acm); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + + for (i = 0; i < ACM_NW; i++) { + g_acm->wb[i].request = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->dataOutEp.maxPacketSize); + g_acm->wb[i].instance = g_acm; + if (g_acm->wb[i].request == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + + for (i = 0; i < ACM_NR; i++) { + g_acm->readReq[i] = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->dataInEp.maxPacketSize); + if (g_acm->readReq[i] == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + + g_acm->ctrlReq = UsbRawAllocRequest(g_acm->devHandle, 0, USB_CTRL_REQ_SIZE); + if (g_acm->ctrlReq == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + + g_acm->notifyReq = UsbRawAllocRequest(g_acm->devHandle, 0, g_acm->notifyEp.maxPacketSize); + if (g_acm->notifyReq == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor001(void) +{ + struct UsbRawDescriptorParam param; + unsigned char data[100]; + int ret; + + ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, ¶m, data); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor002(void) +{ + struct UsbRawDescriptorParam param; + unsigned char data[100]; + int ret; + + ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, ¶m, data); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor003(void) +{ + struct UsbRawDescriptorParam param; + unsigned char data[100]; + int ret; + + ret = UsbRawGetDescriptor(NULL, NULL, ¶m, data); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor004(void) +{ + unsigned char data[100]; + int ret; + + ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, NULL, data); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor005(void) +{ + struct UsbRawDescriptorParam param; + int ret; + + ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, ¶m, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor006(void) +{ + struct UsbRawDescriptorParam param; + unsigned char data[256]; + int ret; + + param.descType = USB_DESC_TYPE; + param.descIndex = 0; + param.length = sizeof(data); + + ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, ¶m, data); + if (ret < 0) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor007(void) +{ + unsigned char data[100]; + int ret; + + ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, NULL, data); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor008(void) +{ + int ret; + + ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, NULL, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor009(void) +{ + unsigned char data[100]; + int ret; + + ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, NULL, data); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor010(void) +{ + struct UsbRawDescriptorParam param; + unsigned char data[100]; + int ret; + + param.descType = 0; + param.descIndex = 0; + param.length = sizeof(data); + + ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, ¶m, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor011(void) +{ + struct UsbRawDescriptorParam param; + unsigned char data[100]; + int ret; + + param.descType = 0; + param.descIndex = 0; + param.length = sizeof(data); + + ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, ¶m, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor012(void) +{ + unsigned char data[100]; + int ret; + + ret = UsbRawGetDescriptor(NULL, NULL, NULL, data); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor013(void) +{ + struct UsbRawDescriptorParam param; + unsigned char data[100]; + int ret; + + param.descType = 0; + param.descIndex = 0; + param.length = sizeof(data); + + ret = UsbRawGetDescriptor(NULL, NULL, ¶m, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor014(void) +{ + int ret; + + ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, NULL, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor015(void) +{ + int ret; + + ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, NULL, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfGetDescriptor016(void) +{ + int ret; + + ret = UsbRawGetDescriptor(NULL, NULL, NULL, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillBulkRequest001(void) +{ + struct UsbRawFillRequestData reqData; + int32_t ret; + int i; + uint32_t size; + char sendData[] = {"abcde\0"}; + + size = strlen(sendData) + 1; + printf("---size:%d\n", size); + + size = (size > g_acm->dataOutEp.maxPacketSize) ? g_acm->dataOutEp.maxPacketSize : size; + for (i = 0; i < 1; i++) { + struct RawWb *snd = &g_acm->wb[i]; + snd->len = size; + ret = memcpy_s(snd->buf, g_acm->dataOutEp.maxPacketSize, sendData, size); + if (ret) { + printf("memcpy_s fial"); + } + g_acm->transmitting++; + + reqData.endPoint = g_acm->dataOutEp.addr; + reqData.numIsoPackets = 0; + reqData.callback = AcmWriteBulkCallback; + reqData.userData = (void *)snd; + reqData.timeout = USB_CTRL_SET_TIMEOUT; + reqData.buffer = snd->buf; + reqData.length = snd->len; + printf("maxPacketSize:%d+snd->request:%p\n", g_acm->dataOutEp.maxPacketSize, snd->request); + ret = UsbRawFillBulkRequest(snd->request, g_acm->devHandle, &reqData); + if (ret) { + printf("%s: error++ret", __func__, ret); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillBulkRequest002(void) +{ + struct UsbRawFillRequestData reqData; + int32_t ret; + int i; + int size = g_acm->dataInEp.maxPacketSize; + + for (i = 0; i < 1; i++) { + reqData.endPoint = g_acm->dataInEp.addr; + reqData.numIsoPackets = 0; + reqData.callback = AcmReadBulkCallback; + reqData.userData = (void *)g_acm; + reqData.timeout = USB_CTRL_SET_TIMEOUT; + reqData.length = size; + + ret = UsbRawFillBulkRequest(g_acm->readReq[i], g_acm->devHandle, &reqData); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillInterruptRequest001(void) +{ + struct UsbRawFillRequestData fillRequestData; + int32_t ret; + int size = g_acm->notifyEp.maxPacketSize; + + fillRequestData.endPoint = g_acm->notifyEp.addr; + fillRequestData.length = size; + fillRequestData.numIsoPackets = 0; + fillRequestData.callback = AcmNotifyReqCallback; + fillRequestData.userData = (void *)g_acm; + fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + + ret = UsbRawFillInterruptRequest(g_acm->notifyReq, g_acm->devHandle, &fillRequestData); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillInterruptRequest002(void) +{ + struct UsbRawFillRequestData fillRequestData; + int32_t ret; + int size = g_acm->notifyEp.maxPacketSize; + + fillRequestData.endPoint = g_acm->notifyEp.addr; + fillRequestData.length = size; + fillRequestData.numIsoPackets = 0; + fillRequestData.callback = AcmNotifyReqCallback; + fillRequestData.userData = (void *)g_acm; + fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + + ret = UsbRawFillInterruptRequest(NULL, g_acm->devHandle, &fillRequestData); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillInterruptRequest003(void) +{ + struct UsbRawFillRequestData fillRequestData; + int32_t ret; + int size = g_acm->notifyEp.maxPacketSize; + + fillRequestData.endPoint = g_acm->notifyEp.addr; + fillRequestData.length = size; + fillRequestData.numIsoPackets = 0; + fillRequestData.callback = AcmNotifyReqCallback; + fillRequestData.userData = (void *)g_acm; + fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + + ret = UsbRawFillInterruptRequest(g_acm->notifyReq, NULL, &fillRequestData); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillInterruptRequest004(void) +{ + struct UsbRawFillRequestData fillRequestData; + int32_t ret; + int size = g_acm->notifyEp.maxPacketSize; + + fillRequestData.endPoint = g_acm->notifyEp.addr; + fillRequestData.length = size; + fillRequestData.numIsoPackets = 0; + fillRequestData.callback = AcmNotifyReqCallback; + fillRequestData.userData = (void *)g_acm; + fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + + ret = UsbRawFillInterruptRequest(g_acm->notifyReq, g_acm->devHandle, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillControlRequest001(void) +{ + struct UsbRawFillRequestData fillRequestData; + int ret; + int completed = 0; + + fillRequestData.callback = AcmCtrlReqCallback; + fillRequestData.userData = &completed; + fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawFillControlRequest(g_acm->ctrlReq, g_acm->devHandle, &fillRequestData); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillControlRequest002(void) +{ + struct UsbRawFillRequestData fillRequestData; + int ret; + int completed = 0; + + fillRequestData.callback = AcmCtrlReqCallback; + fillRequestData.userData = &completed; + fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawFillControlRequest(NULL, g_acm->devHandle, &fillRequestData); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillControlRequest003(void) +{ + struct UsbRawFillRequestData fillRequestData; + int ret; + int completed = 0; + + fillRequestData.callback = AcmCtrlReqCallback; + fillRequestData.userData = &completed; + fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawFillControlRequest(g_acm->ctrlReq, NULL, &fillRequestData); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillControlRequest004(void) +{ + struct UsbRawFillRequestData fillRequestData; + int ret; + int completed = 0; + + fillRequestData.callback = AcmCtrlReqCallback; + fillRequestData.userData = &completed; + fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawFillControlRequest(g_acm->ctrlReq, g_acm->devHandle, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillControlRequest005(void) +{ + struct UsbRawFillRequestData fillRequestData; + int ret; + int completed = 0; + + fillRequestData.callback = AcmCtrlReqCallback; + fillRequestData.userData = &completed; + fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawFillControlRequest(NULL, g_acm->devHandle, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillControlRequest006(void) +{ + struct UsbRawFillRequestData fillRequestData; + int ret; + int completed = 0; + + fillRequestData.callback = AcmCtrlReqCallback; + fillRequestData.userData = &completed; + fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawFillControlRequest(g_acm->ctrlReq, NULL, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillControlRequest007(void) +{ + struct UsbRawFillRequestData fillRequestData; + int ret; + int completed = 0; + + fillRequestData.callback = AcmCtrlReqCallback; + fillRequestData.userData = &completed; + fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawFillControlRequest(NULL, NULL, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillControlRequest008(void) +{ + struct UsbRawFillRequestData fillRequestData; + int ret; + int completed = 0; + + fillRequestData.callback = AcmCtrlReqCallback; + fillRequestData.userData = &completed; + fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawFillControlRequest(NULL, NULL, &fillRequestData); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillControlSetup001(void) +{ + struct UsbControlRequestData ctrlReq; + int ret; + + g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + g_acm->lineCoding.bCharFormat = CHARFORMAT; + g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY; + g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS; + + ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE; + ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING; + ctrlReq.value = CpuToLe16(0); + ctrlReq.index = 0; + ctrlReq.data = (unsigned char *)&g_acm->lineCoding; + ctrlReq.length = sizeof(struct UsbCdcLineCoding); + ctrlReq.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawFillControlSetup(NULL, &ctrlReq); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillControlSetup002(void) +{ + unsigned char setup[100] = {0}; + int ret; + + ret = UsbRawFillControlSetup(setup, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillControlSetup003(void) +{ + int ret; + + ret = UsbRawFillControlSetup(NULL, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillControlSetup004(void) +{ + struct UsbControlRequestData ctrlReq; + unsigned char setup[100] = {0}; + int ret; + g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + g_acm->lineCoding.bCharFormat = CHARFORMAT; + g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY; + g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS; + + ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE; + ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING; + ctrlReq.value = CpuToLe16(0); + ctrlReq.index = 0; + ctrlReq.data = (unsigned char *)&g_acm->lineCoding; + ctrlReq.length = sizeof(struct UsbCdcLineCoding); + ctrlReq.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawFillControlSetup(setup, &ctrlReq); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendControlRequest001(void) +{ + struct UsbControlRequestData ctrlReq; + int ret; + + g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + g_acm->lineCoding.bCharFormat = CHARFORMAT; + g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY; + g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS; + ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE; + ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING; + ctrlReq.value = CpuToLe16(0); + ctrlReq.index = 0; + ctrlReq.data = (unsigned char *)&g_acm->lineCoding; + ctrlReq.length = sizeof(struct UsbCdcLineCoding); + ctrlReq.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawSendControlRequest(NULL, g_acm->devHandle, &ctrlReq); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendControlRequest002(void) +{ + struct UsbControlRequestData ctrlReq; + int ret; + + g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + g_acm->lineCoding.bCharFormat = CHARFORMAT; + g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY; + g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS; + ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE; + ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING; + ctrlReq.value = CpuToLe16(0); + ctrlReq.index = 0; + ctrlReq.data = (unsigned char *)&g_acm->lineCoding; + ctrlReq.length = sizeof(struct UsbCdcLineCoding); + ctrlReq.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawSendControlRequest(g_acm->ctrlReq, NULL, &ctrlReq); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendControlRequest003(void) +{ + int ret; + ret = UsbRawSendControlRequest(g_acm->ctrlReq, g_acm->devHandle, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendControlRequest004(void) +{ + struct UsbControlRequestData ctrlReq; + int ret; + + g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + g_acm->lineCoding.bCharFormat = CHARFORMAT; + g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY; + g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS; + ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE; + ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING; + ctrlReq.value = CpuToLe16(0); + ctrlReq.index = 2; + ctrlReq.data = (unsigned char *)&g_acm->lineCoding; + ctrlReq.length = sizeof(struct UsbCdcLineCoding); + ctrlReq.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawSendControlRequest(g_acm->ctrlReq, g_acm->devHandle, &ctrlReq); + if (ret < 0) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendControlRequest005(void) +{ + struct UsbControlRequestData ctrlReq; + int ret; + + g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + g_acm->lineCoding.bCharFormat = CHARFORMAT; + g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY; + g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS; + ctrlReq.requestType = USB_DDK_DIR_OUT | USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE; + ctrlReq.requestCmd = USB_DDK_CDC_REQ_SET_LINE_CODING; + ctrlReq.value = CpuToLe16(0); + ctrlReq.index = 0; + ctrlReq.data = (unsigned char *)&g_acm->lineCoding; + ctrlReq.length = sizeof(struct UsbCdcLineCoding); + ctrlReq.timeout = USB_CTRL_SET_TIMEOUT; + + ret = UsbRawSendControlRequest(NULL, NULL, &ctrlReq); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendControlRequest006(void) +{ + int ret; + + ret = UsbRawSendControlRequest(NULL, g_acm->devHandle, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendControlRequest007(void) +{ + int ret; + + ret = UsbRawSendControlRequest(g_acm->ctrlReq, NULL, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendBulkRequest001(void) +{ + struct UsbRequestData reqData; + int32_t ret; + int i; + uint32_t size; + char sendData[] = {"abcd\0"}; + + size = strlen(sendData) + 1; + size = (size > g_acm->dataOutEp.maxPacketSize) ? g_acm->dataOutEp.maxPacketSize : size; + + for (i = 0; i < 1; i++) { + struct RawWb *snd = &g_acm->wb[i]; + snd->len = size; + ret = memcpy_s(snd->buf, g_acm->dataOutEp.maxPacketSize, sendData, size); + if (ret) { + printf("memcpy_s fial"); + } + g_acm->transmitting++; + + reqData.endPoint = g_acm->dataOutEp.addr; + reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + reqData.data = snd->buf; + reqData.length = snd->len; + reqData.requested = (int *)&size; + } + + for (i = 0; i < 1; i++) { + struct RawWb *snd = &g_acm->wb[i]; + printf("UsbRawSendBulkRequest i = [%d]\n", i); + ret = UsbRawSendBulkRequest(snd->request, g_acm->devHandle, &reqData); + if (ret) { + printf("%s: error+ret:%d", __func__, ret); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendBulkRequest002(void) +{ + struct UsbRequestData reqData; + int32_t ret; + int i; + int size = g_acm->dataInEp.maxPacketSize; + + for (i = 0; i < 1; i++) { + reqData.endPoint = g_acm->dataInEp.addr; + reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + reqData.length = size; + reqData.data = ((struct UsbRawRequest *)g_acm->readReq[i])->buffer; + reqData.requested = (int *)&size; + } + + for (i = 0; i < 1; i++) { + printf("UsbRawSendBulkRequest i = [%d]\n", i); + ret = UsbRawSendBulkRequest(g_acm->readReq[i], g_acm->devHandle, &reqData); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendBulkRequest003(void) +{ + struct UsbRequestData reqData; + int32_t ret; + int i; + int size = g_acm->dataInEp.maxPacketSize; + + for (i = 0; i < 1; i++) { + reqData.endPoint = g_acm->dataInEp.addr; + reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + reqData.length = size; + reqData.data = ((struct UsbRawRequest *)g_acm->readReq[i])->buffer; + reqData.requested = (int *)&size; + } + + for (i = 0; i < 1; i++) { + printf("UsbRawSendBulkRequest i = [%d]\n", i); + ret = UsbRawSendBulkRequest(NULL, g_acm->devHandle, &reqData); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendBulkRequest004(void) +{ + struct UsbRequestData reqData; + int32_t ret; + int i; + int size = g_acm->dataInEp.maxPacketSize; + + for (i = 0; i < 1; i++) { + reqData.endPoint = g_acm->dataInEp.addr; + reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + reqData.length = size; + reqData.data = ((struct UsbRawRequest *)g_acm->readReq[i])->buffer; + reqData.requested = (int *)&size; + } + for (i = 0; i < 1; i++) { + printf("UsbRawSendBulkRequest i = [%d]\n", i); + ret = UsbRawSendBulkRequest(g_acm->readReq[i], NULL, &reqData); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendBulkRequest005(void) +{ + int32_t ret; + int i; + + for (i = 0; i < 1; i++) { + printf("UsbRawSendBulkRequest i = [%d]\n", i); + ret = UsbRawSendBulkRequest(g_acm->readReq[i], g_acm->devHandle, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendInterruptRequest001(void) +{ + struct UsbRequestData reqData; + int32_t ret; + int size = g_acm->notifyEp.maxPacketSize; + + reqData.endPoint = g_acm->notifyEp.addr; + reqData.length = size; + reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + reqData.data = ((struct UsbRawRequest *)g_acm->notifyReq)->buffer; + reqData.requested = (int *)&size; + ret = UsbRawSendInterruptRequest(g_acm->notifyReq, g_acm->devHandle, &reqData); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendInterruptRequest002(void) +{ + struct UsbRequestData reqData; + int32_t ret; + int size = g_acm->notifyEp.maxPacketSize; + + reqData.endPoint = g_acm->notifyEp.addr; + reqData.length = size; + reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + reqData.data = ((struct UsbRawRequest *)g_acm->notifyReq)->buffer; + reqData.requested = (int *)&size; + + ret = UsbRawSendInterruptRequest(NULL, g_acm->devHandle, &reqData); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendInterruptRequest003(void) +{ + struct UsbRequestData reqData; + int32_t ret; + int size = g_acm->notifyEp.maxPacketSize; + + reqData.endPoint = g_acm->notifyEp.addr; + reqData.length = size; + reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + reqData.data = ((struct UsbRawRequest *)g_acm->notifyReq)->buffer; + reqData.requested = (int *)&size; + + ret = UsbRawSendInterruptRequest(g_acm->notifyReq, NULL, &reqData); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSendInterruptRequest004(void) +{ + int32_t ret; + + ret = UsbRawSendInterruptRequest(g_acm->notifyReq, g_acm->devHandle, NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillBulkRequest003(void) +{ + struct UsbRawFillRequestData reqData; + int32_t ret; + int i; + uint32_t size; + char sendData[] = {"abcde\0"}; + size = strlen(sendData) + 1; + size = (size > g_acm->dataOutEp.maxPacketSize) ? g_acm->dataOutEp.maxPacketSize : size; + + for (i = 0; i < ACM_NW; i++) { + struct RawWb *snd = &g_acm->wb[i]; + snd->len = size; + ret = memcpy_s(snd->buf, g_acm->dataOutEp.maxPacketSize, sendData, size); + if (ret) { + printf("memcpy_s fial"); + } + g_acm->transmitting++; + + reqData.endPoint = g_acm->dataOutEp.addr; + reqData.numIsoPackets = 0; + reqData.callback = AcmWriteBulkCallback; + reqData.userData = (void *)snd; + reqData.timeout = USB_CTRL_SET_TIMEOUT; + reqData.buffer = snd->buf; + reqData.length = snd->len; + + ret = UsbRawFillBulkRequest(snd->request, g_acm->devHandle, &reqData); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillBulkRequest004(void) +{ + struct UsbRawFillRequestData reqData; + int32_t ret; + int i; + int size = g_acm->dataInEp.maxPacketSize; + + for (i = 0; i < ACM_NW; i++) { + reqData.endPoint = g_acm->dataInEp.addr; + reqData.numIsoPackets = 0; + reqData.callback = AcmReadBulkCallback; + reqData.userData = (void *)g_acm; + reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + reqData.length = size; + ret = UsbRawFillBulkRequest(g_acm->readReq[i], g_acm->devHandle, &reqData); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfFillInterruptRequest005(void) +{ + struct UsbRawFillRequestData fillRequestData; + int32_t ret; + int size = g_acm->notifyEp.maxPacketSize; + fillRequestData.endPoint = g_acm->notifyEp.addr; + fillRequestData.length = size; + fillRequestData.numIsoPackets = 0; + fillRequestData.callback = AcmNotifyReqCallback; + fillRequestData.userData = (void *)g_acm; + fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; + ret = UsbRawFillInterruptRequest(g_acm->notifyReq, g_acm->devHandle, &fillRequestData); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSubmitRequest001(void) +{ + int32_t ret; + int i; + + for (i = 0; i < ACM_NW; i++) { + struct RawWb *snd = &g_acm->wb[i]; + printf("UsbRawSubmitRequest i = [%d]\n", i); + ret = UsbRawSubmitRequest(snd->request); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSubmitRequest002(void) +{ + int32_t ret; + int i; + + for (i = 0; i < ACM_NW; i++) { + printf("UsbRawSubmitRequest i = [%d]\n", i); + ret = UsbRawSubmitRequest(g_acm->readReq[i]); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSubmitRequest003(void) +{ + int32_t ret; + + ret = UsbRawSubmitRequest(g_acm->notifyReq); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfSubmitRequest004(void) +{ + int32_t ret; + + ret = UsbRawSubmitRequest(NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfCancelRequest001(void) +{ + int32_t ret; + int i; + + for (i = 0; i < ACM_NW; i++) { + struct RawWb *snd = &g_acm->wb[i]; + ret = UsbRawCancelRequest(snd->request); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfCancelRequest002(void) +{ + int32_t ret; + int i; + + for (i = 0; i < ACM_NR; i++) { + ret = UsbRawCancelRequest(g_acm->readReq[i]); + printf("%s+%d+ret:%d\n", __func__, __LINE__, ret); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfCancelRequest003(void) +{ + int32_t ret; + + ret = UsbRawCancelRequest(g_acm->notifyReq); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t CheckRawSdkIfCancelRequest004(void) +{ + int32_t ret; + + ret = UsbRawCancelRequest(NULL); + if (ret != HDF_ERR_INVALID_PARAM) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} diff --git a/test/unittest/model/usb/host/src/usb_test.c b/test/unittest/model/usb/host/src/usb_test.c new file mode 100644 index 000000000..dcc3dc7d0 --- /dev/null +++ b/test/unittest/model/usb/host/src/usb_test.c @@ -0,0 +1,1986 @@ +/* + * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * + * HDF is dual licensed: you can use it either under the terms of + * the GPL, or the BSD license, at your option. + * See the LICENSE file in the root of this repository for complete details. + */ + +#include "usb_test.h" +#include "device_resource_if.h" +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "osal_time.h" +#include "usb_interface.h" +#ifdef LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY +#include "usb_pnp_notify.h" +#endif + +#define HDF_LOG_TAG USB_TEST_C + +static struct UsbSession *g_session = NULL; +static struct AcmDevice g_deviceService; +static struct AcmDevice *g_acm = &g_deviceService; +static struct UsbInterface *g_ecmDataIface = NULL; +static struct UsbInterface *g_ecmIntIface = NULL; +static UsbInterfaceHandle *g_ecmDataDevHandle = NULL; +static UsbInterfaceHandle *g_ecmIntDevHandle = NULL; +static bool g_initFlag; +static bool g_writeBufFlag = 0; + +static void AcmReadBulk(struct UsbRequest *req) +{ + uint32_t size; + int status = req->compInfo.status; + size = req->compInfo.actualLength; + printf("Bulk status:%d,actualLength:%d\n", status, size); + switch (status) { + case 0: + break; + case -ECONNRESET: + case -ENOENT: + case -ESHUTDOWN: + return; + default: + goto exit; + } +exit: + return; +} + +static void AcmWriteBulk(struct UsbRequest *req) +{ + int status; + + if (req == NULL) { + printf("%s:%d req is NULL!", __func__, __LINE__); + return; + } + + status = req->compInfo.status; + printf("Bulk Write status:%d\n", status); + struct AcmWb *wb = (struct AcmWb *)req->compInfo.userData; + switch (status) { + case 0: + wb->use = 0; + break; + case -ECONNRESET: + case -ENOENT: + case -ESHUTDOWN: + return; + default: + return; + } + + return; +} + +static void AcmWriteIsoCallback(struct UsbRequest *requestArg) +{ + struct UsbRequest *req = requestArg; + printf("%s:%d status:%d\n", __func__, __LINE__, req->compInfo.status); +} + +static int AcmWriteBufAlloc(struct AcmDevice *acm) +{ + int i; + if (!g_writeBufFlag) { + struct AcmWb *wb; + for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) { + wb->buf = (uint8_t *)OsalMemCalloc(acm->writeSize); + if (!wb->buf) { + while (i != 0) { + --i; + --wb; + OsalMemFree(wb->buf); + wb->buf = NULL; + } + return -HDF_ERR_MALLOC_FAIL; + } + g_writeBufFlag = true; + } + } + return HDF_SUCCESS; +} + +static void AcmWriteBufFree(struct AcmDevice *acm) +{ + int i; + struct AcmWb *wb; + for (wb = &acm->wb[0], i = 0; i < ACM_NW; i++, wb++) { + if (wb->buf) { + OsalMemFree(wb->buf); + wb->buf = NULL; + } + } + g_writeBufFlag = false; + return; +} + +static void AcmCtrlIrq(struct UsbRequest *req) +{ + if (req == NULL) { + printf("%s:%d req is NULL!", __func__, __LINE__); + return; + } + int status = req->compInfo.status; + unsigned int currentSize = req->compInfo.actualLength; + printf("Irqstatus:%d,actualLength:%u\n", status, currentSize); +} + +static struct UsbControlRequest UsbControlMsg(struct TestControlMsgData msgData) +{ + struct UsbControlRequest dr; + dr.target = (UsbRequestTargetType)(msgData.requestType & TARGET_MASK); + dr.reqType = (UsbControlRequestType)((msgData.requestType >> USB_TYPE_OFFSET) & REQUEST_TYPE_MASK); + dr.directon = (UsbRequestDirection)((msgData.requestType >> USB_DIR_OFFSET) & DIRECTION_MASK); + dr.request = msgData.request; + dr.value = CpuToLe16(msgData.value); + dr.index = CpuToLe16(msgData.index); + dr.buffer = msgData.data; + dr.length = CpuToLe16(msgData.size); + return dr; +} + +static int32_t CheckHostSdkIfInit001(void) +{ + int ret; + ret = UsbInitHostSdk(&g_session); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->session = g_session; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfExit001(void) +{ + int ret; + + ret = UsbExitHostSdk(g_acm->session); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->session = NULL; + g_session = g_acm->session; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfInit002(void) +{ + int ret; + + ret = UsbInitHostSdk(NULL); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfExit002(void) +{ + int ret; + + ret = UsbExitHostSdk(NULL); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfInit003(void) +{ + int ret; + int i; + + for (i = 0; i < USB_LOOP_NUM; i++) { + ret = UsbInitHostSdk(&g_session); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->session = g_session; + ret = UsbExitHostSdk(g_acm->session); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->session = NULL; + g_session = g_acm->session; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfInit004(void) +{ + int ret; + int i; + + for (i = 0; i < USB_LOOP_NUM; i++) { + ret = UsbInitHostSdk(NULL); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + ret = UsbExitHostSdk(NULL); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfInit005(void) +{ + int ret; + + ret = UsbInitHostSdk(&g_session); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->session = g_session; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfClaimInterface001(void) +{ + g_acm->interfaceIndex = 1U; + + g_acm->dataIface = (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum, + g_acm->devAddr, g_acm->interfaceIndex); + if (g_acm->dataIface == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfReleaseInterface001(void) +{ + int ret; + + ret = UsbReleaseInterface(g_acm->dataIface); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfClaimInterface002(void) +{ + g_acm->interfaceIndex = 0U; + + g_acm->intIface = (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum, + g_acm->devAddr, g_acm->interfaceIndex); + if (g_acm->intIface == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfReleaseInterface002(void) +{ + int ret; + + ret = UsbReleaseInterface(g_acm->intIface); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfClaimInterface003(void) +{ + g_acm->interfaceIndex = USB_CTRL_INTERFACE_ID; + + g_acm->ctrIface = (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum, + g_acm->devAddr, g_acm->interfaceIndex); + if (g_acm->ctrIface == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfReleaseInterface003(void) +{ + int ret; + + ret = UsbReleaseInterface(g_acm->ctrIface); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfClaimInterface004(void) +{ + g_acm->interfaceIndex = 2U; + + g_acm->dataIface = (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum, + g_acm->devAddr, g_acm->interfaceIndex); + if (g_acm->dataIface == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfClaimInterface005(void) +{ + g_acm->interfaceIndex = 3U; + + g_acm->dataIface = (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum, + g_acm->devAddr, g_acm->interfaceIndex); + if (g_acm->dataIface == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfClaimInterface006(void) +{ + g_acm = &g_deviceService; + g_acm->interfaceIndex = 3U; + g_acm->dataIface = (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum, + g_acm->devAddr, g_acm->interfaceIndex); + if (g_acm->dataIface == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + + g_acm->interfaceIndex = 2U; + g_acm->intIface = (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum, + g_acm->devAddr, g_acm->interfaceIndex); + if (g_acm->intIface == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + + g_acm->interfaceIndex = 0U; + g_ecmIntIface = (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum, + g_acm->devAddr, g_acm->interfaceIndex); + if (g_ecmIntIface == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + + g_acm->interfaceIndex = 1U; + g_ecmDataIface = (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum, + g_acm->devAddr, g_acm->interfaceIndex); + if (g_ecmDataIface == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + + g_acm->interfaceIndex = USB_CTRL_INTERFACE_ID; + g_acm->ctrIface = (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum, + g_acm->devAddr, g_acm->interfaceIndex); + if (g_acm->ctrIface == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfOpenInterface001(void) +{ + g_acm->data_devHandle = UsbOpenInterface(g_acm->dataIface); + if (g_acm->data_devHandle == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfCloseInterface001(void) +{ + int ret; + + ret = UsbCloseInterface(g_acm->data_devHandle); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfOpenInterface002(void) +{ + g_acm->int_devHandle = UsbOpenInterface(g_acm->intIface); + if (g_acm->int_devHandle == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfCloseInterface002(void) +{ + int ret; + + ret = UsbCloseInterface(g_acm->int_devHandle); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfOpenInterface003(void) +{ + g_acm->ctrl_devHandle = UsbOpenInterface(g_acm->ctrIface); + if (g_acm->ctrl_devHandle == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfCloseInterface003(void) +{ + int ret; + ret = UsbCloseInterface(g_acm->ctrl_devHandle); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfOpenInterface004(void) +{ + g_acm->data_devHandle = UsbOpenInterface(NULL); + if (g_acm->data_devHandle == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_SUCCESS; + } + HDF_LOGE("%s: success", __func__); + return HDF_FAILURE; +} + +static int32_t CheckHostSdkIfOpenInterface005(void) +{ + int i; + for (i = 0; i < USB_LOOP_NUM; i++) { + g_acm->data_devHandle = UsbOpenInterface(g_acm->dataIface); + if (g_acm->data_devHandle == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfOpenInterface006(void) +{ + g_acm->data_devHandle = UsbOpenInterface(g_acm->dataIface); + if (g_acm->data_devHandle == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->int_devHandle = UsbOpenInterface(g_acm->intIface); + if (g_acm->int_devHandle == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->ctrl_devHandle = UsbOpenInterface(g_acm->ctrIface); + if (g_acm->ctrl_devHandle == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_ecmDataDevHandle = UsbOpenInterface(g_ecmDataIface); + if (g_ecmDataDevHandle == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_ecmIntDevHandle = UsbOpenInterface(g_ecmIntIface); + if (g_ecmIntDevHandle == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfSelectInterfaceSetting001(void) +{ + int ret; + int settingIndex = 0; + ret = UsbSelectInterfaceSetting(g_ecmDataDevHandle, settingIndex, &g_ecmDataIface); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfSelectInterfaceSetting002(void) +{ + int ret; + int settingIndex = 10; + ret = UsbSelectInterfaceSetting(g_ecmDataDevHandle, settingIndex, &g_ecmDataIface); + if (ret != HDF_FAILURE) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfSelectInterfaceSetting003(void) +{ + int ret; + int settingIndex = 100; + ret = UsbSelectInterfaceSetting(g_ecmDataDevHandle, settingIndex, &g_ecmDataIface); + if (ret != HDF_FAILURE) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfSelectInterfaceSetting004(void) +{ + int ret; + int settingIndex = 200; + ret = UsbSelectInterfaceSetting(g_ecmDataDevHandle, settingIndex, &g_ecmDataIface); + if (ret != HDF_FAILURE) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfSelectInterfaceSetting005(void) +{ + int ret; + int settingIndex = USB_MAX_BYTE; + ret = UsbSelectInterfaceSetting(g_ecmDataDevHandle, settingIndex, &g_ecmDataIface); + if (ret != HDF_FAILURE) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfSelectInterfaceSetting006(void) +{ + int ret; + int settingIndex = 1; + ret = UsbSelectInterfaceSetting(g_ecmDataDevHandle, settingIndex, &g_ecmDataIface); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfClaimInterface007(void) +{ + g_acm->interfaceIndex = 0U; + + g_ecmIntIface = (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum, + g_acm->devAddr, g_acm->interfaceIndex); + if (g_ecmIntIface == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfClaimInterface008(void) +{ + g_acm->interfaceIndex = 1U; + g_ecmDataIface = (struct UsbInterface *)UsbClaimInterface(g_acm->session, g_acm->busNum, + g_acm->devAddr, g_acm->interfaceIndex); + if (g_ecmDataIface == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfGetPipe001(void) +{ + int ret; + struct UsbPipeInfo p; + int i; + for (i = 0; i <= g_acm->dataIface->info.pipeNum; i++) { + ret = UsbGetPipeInfo(NULL, g_acm->dataIface->info.curAltSetting, i, &p); + if (ret < 0) { + continue; + } + if ((p.pipeDirection == USB_PIPE_DIRECTION_IN) && (p.pipeType == USB_PIPE_TYPE_BULK)) { + struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(*pi)); + if (pi) { + HDF_LOGE("%s: error", __func__); + return HDF_SUCCESS; + } + p.interfaceId = g_acm->dataIface->info.interfaceIndex; + *pi = p; + g_acm->dataInPipe = pi; + break; + } + } + if (i > g_acm->dataIface->info.pipeNum) { + return HDF_FAILURE; + } + if (g_acm->dataInPipe == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfGetPipe002(void) +{ + int ret; + struct UsbPipeInfo p; + int i; + for (i = 0; i <= g_acm->dataIface->info.pipeNum; i++) { + ret = UsbGetPipeInfo(g_acm->data_devHandle, g_acm->dataIface->info.curAltSetting, i, &p); + if (ret < 0) { + continue; + } + if ((p.pipeDirection == USB_PIPE_DIRECTION_IN) && (p.pipeType == USB_PIPE_TYPE_BULK)) { + struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(*pi)); + p.interfaceId = g_acm->dataIface->info.interfaceIndex; + *pi = p; + g_acm->dataInPipe = pi; + break; + } + } + if (g_acm->dataInPipe == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfGetPipe003(void) +{ + int ret; + struct UsbPipeInfo p; + int i; + for (i = 0; i <= g_acm->dataIface->info.pipeNum; i++) { + ret = UsbGetPipeInfo(NULL, g_acm->dataIface->info.curAltSetting, i, &p); + if (ret < 0) { + continue; + } + if ((p.pipeDirection == USB_PIPE_DIRECTION_OUT) && (p.pipeType == USB_PIPE_TYPE_BULK)) { + struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(*pi)); + if (pi) { + HDF_LOGE("%s: error", __func__); + return HDF_SUCCESS; + } + p.interfaceId = g_acm->dataIface->info.interfaceIndex; + *pi = p; + g_acm->dataOutPipe = pi; + break; + } + } + if (i > g_acm->dataIface->info.pipeNum) { + return HDF_FAILURE; + } + if (g_acm->dataOutPipe == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfGetPipe004(void) +{ + int ret; + struct UsbPipeInfo p; + int i; + for (i = 0; i <= g_acm->dataIface->info.pipeNum; i++) { + ret = UsbGetPipeInfo(g_acm->data_devHandle, g_acm->dataIface->info.curAltSetting, i, &p); + if (ret < 0) { + continue; + } + if ((p.pipeDirection == USB_PIPE_DIRECTION_OUT) && (p.pipeType == USB_PIPE_TYPE_BULK)) { + struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(*pi)); + p.interfaceId = g_acm->dataIface->info.interfaceIndex; + *pi = p; + g_acm->dataOutPipe = pi; + break; + } + } + if (g_acm->dataOutPipe == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfGetPipe005(void) +{ + int ret; + struct UsbPipeInfo p; + int i; + for (i = 0; i <= g_acm->intIface->info.pipeNum; i++) { + ret = UsbGetPipeInfo(NULL, g_acm->intIface->info.curAltSetting, i, &p); + if (ret < 0) { + continue; + } + if ((p.pipeDirection == USB_PIPE_DIRECTION_IN) && (p.pipeType == USB_PIPE_TYPE_INTERRUPT)) { + struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(*pi)); + p.interfaceId = g_acm->intIface->info.interfaceIndex; + *pi = p; + g_acm->intPipe = pi; + break; + } + } + if (i > g_acm->intIface->info.pipeNum) { + return HDF_FAILURE; + } + if (g_acm->intPipe == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfGetPipe006(void) +{ + int ret; + struct UsbPipeInfo p; + int i; + for (i = 0; i <= g_acm->intIface->info.pipeNum; i++) { + ret = UsbGetPipeInfo(g_acm->int_devHandle, g_acm->intIface->info.curAltSetting, i, &p); + if (ret < 0) { + continue; + } + if ((p.pipeDirection == USB_PIPE_DIRECTION_IN) && (p.pipeType == USB_PIPE_TYPE_INTERRUPT)) { + struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(*pi)); + p.interfaceId = g_acm->intIface->info.interfaceIndex; + *pi = p; + g_acm->intPipe = pi; + break; + } + } + if (g_acm->intPipe == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfGetPipe007(void) +{ + int ret; + struct UsbPipeInfo p; + int i; + g_acm->interfaceIndex = USB_CTRL_INTERFACE_ID; + for (i = 0; i <= g_acm->ctrIface->info.pipeNum; i++) { + ret = UsbGetPipeInfo(NULL, g_acm->ctrIface->info.curAltSetting, i, &p); + if (ret < 0) { + continue; + } + if ((p.pipeDirection == USB_PIPE_DIRECTION_OUT) && (p.pipeType == USB_PIPE_TYPE_CONTROL)) { + struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(*pi)); + p.interfaceId = g_acm->interfaceIndex; + *pi = p; + g_acm->ctrPipe = pi; + break; + } + } + if (i > g_acm->ctrIface->info.pipeNum) { + return HDF_FAILURE; + } + if (g_acm->ctrPipe == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfGetPipe008(void) +{ + int ret; + struct UsbPipeInfo p; + int i; + g_acm->interfaceIndex = USB_CTRL_INTERFACE_ID; + for (i = 0; i <= g_acm->ctrIface->info.pipeNum; i++) { + ret = UsbGetPipeInfo(g_acm->ctrl_devHandle, g_acm->ctrIface->info.curAltSetting, i, &p); + if (ret < 0) { + continue; + } + if ((p.pipeDirection == USB_PIPE_DIRECTION_OUT) && (p.pipeType == USB_PIPE_TYPE_CONTROL)) { + struct UsbPipeInfo *pi = (struct UsbPipeInfo *)OsalMemCalloc(sizeof(*pi)); + p.interfaceId = g_acm->interfaceIndex; + *pi = p; + g_acm->ctrPipe = pi; + break; + } + } + if (g_acm->ctrPipe == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfAllocRequest001(void) +{ + int i; + g_acm->readSize = g_acm->dataInPipe->maxPacketSize; + printf("------readSize = [%d]------\n", g_acm->readSize); + for (i = 0; i < ACM_NR; i++) { + g_acm->readReq[i] = UsbAllocRequest(NULL, 0, g_acm->readSize); + if (g_acm->readReq[i] == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_SUCCESS; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_FAILURE; +} + +static int32_t CheckHostSdkIfAllocRequest002(void) +{ + int i; + g_acm->readSize = g_acm->dataInPipe->maxPacketSize; + printf("------readSize = [%d]------\n", g_acm->readSize); + for (i = 0; i < ACM_NR; i++) { + g_acm->readReq[i] = UsbAllocRequest(g_acm->data_devHandle, 0, g_acm->readSize); + if (g_acm->readReq[i] == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFreeRequest001(void) +{ + int ret; + int i; + for (i = 0; i < ACM_NR; i++) { + ret = UsbFreeRequest(g_acm->readReq[i]); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->readReq[i] = NULL; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfAllocRequest003(void) +{ + int i; + int ret; + g_acm->writeSize = g_acm->dataOutPipe->maxPacketSize; + ret = AcmWriteBufAlloc(g_acm); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + for (i = 0; i < ACM_NW; i++) { + g_acm->wb[i].request = UsbAllocRequest(NULL, 0, g_acm->writeSize); + g_acm->wb[i].instance = g_acm; + if (g_acm->wb[i].request == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_SUCCESS; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_FAILURE; +} + +static int32_t CheckHostSdkIfAllocRequest004(void) +{ + int i; + int ret; + g_acm->writeSize = g_acm->dataOutPipe->maxPacketSize; + ret = AcmWriteBufAlloc(g_acm); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + + for (i = 0; i < ACM_NW; i++) { + g_acm->wb[i].request = UsbAllocRequest(g_acm->data_devHandle, 0, g_acm->writeSize); + g_acm->wb[i].instance = g_acm; + if (g_acm->wb[i].request == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFreeRequest002(void) +{ + int ret; + int i; + for (i = 0; i < ACM_NR; i++) { + ret = UsbFreeRequest(g_acm->wb[i].request); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->wb[i].request = NULL; + } + AcmWriteBufFree(g_acm); + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfAllocRequest005(void) +{ + g_acm->intSize = g_acm->intPipe->maxPacketSize; + g_acm->notifyReq = UsbAllocRequest(NULL, 0, g_acm->intSize); + if (g_acm->notifyReq == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_SUCCESS; + } + HDF_LOGE("%s: success", __func__); + return HDF_FAILURE; +} + +static int32_t CheckHostSdkIfAllocRequest006(void) +{ + g_acm->intSize = g_acm->intPipe->maxPacketSize; + g_acm->notifyReq = UsbAllocRequest(g_acm->int_devHandle, 0, g_acm->intSize); + if (g_acm->notifyReq == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFreeRequest003(void) +{ + int ret; + + ret = UsbFreeRequest(g_acm->notifyReq); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->notifyReq = NULL; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfAllocRequest007(void) +{ + g_acm->ctrlSize = sizeof (struct UsbCdcLineCoding); + g_acm->ctrlReq = UsbAllocRequest(NULL, 0, g_acm->ctrlSize); + if (g_acm->ctrlReq == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_SUCCESS; + } + HDF_LOGE("%s: success", __func__); + return HDF_FAILURE; +} + +static int32_t CheckHostSdkIfAllocRequest008(void) +{ + g_acm->ctrlSize = sizeof (struct UsbCdcLineCoding); + g_acm->ctrlReq = UsbAllocRequest(g_acm->ctrl_devHandle, 0, g_acm->ctrlSize); + if (g_acm->ctrlReq == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfAllocRequest010(void) +{ + size_t size = g_acm->dataOutPipe->maxPacketSize; + g_acm->isoReq = UsbAllocRequest(NULL, USB_ISO_PACKAT_CNT, size); + if (g_acm->isoReq == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} +static int32_t CheckHostSdkIfAllocRequest011(void) +{ + size_t size = g_acm->dataOutPipe->maxPacketSize; + g_acm->isoReq = UsbAllocRequest(g_acm->iso_devHandle, USB_ISO_PACKAT_CNT, size); + if (g_acm->isoReq == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFreeRequest006(void) +{ + int ret; + + ret = UsbFreeRequest(g_acm->isoReq); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->isoReq = NULL; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFillIsoRequest001(void) +{ + int ret; + struct UsbRequestParams parmas; + int i; + char sendData[] = {"abcde\0"}; + uint32_t size = strlen(sendData) + 1; + if (g_acm->isoPipe == NULL){ + return HDF_FAILURE; + } + for (i = 0; i < 1; i++) { + parmas.interfaceId = g_acm->isoPipe->interfaceId; + parmas.pipeAddress = g_acm->isoPipe->pipeAddress; + parmas.pipeId = g_acm->isoPipe->pipeId; + parmas.callback = AcmWriteIsoCallback; + parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; + parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + parmas.dataReq.numIsoPackets = USB_ISO_PACKAT_CNT; + parmas.dataReq.directon = USB_REQUEST_DIR_TO_DEVICE; + parmas.dataReq.length = size; + parmas.dataReq.buffer = (unsigned char *)sendData; + ret = UsbFillRequest(g_acm->isoReq, g_acm->iso_devHandle, &parmas); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFillIsoRequest002(void) +{ + int ret; + struct UsbRequestParams parmas; + int i; + char sendData[] = {"abcde\0"}; + uint32_t size = strlen(sendData) + 1; + if (g_acm->isoPipe == NULL){ + return HDF_FAILURE; + } + for (i = 0; i < 1; i++) { + parmas.interfaceId = g_acm->isoPipe->interfaceId; + parmas.pipeAddress = g_acm->isoPipe->pipeAddress; + parmas.pipeId = g_acm->isoPipe->pipeId; + parmas.callback = AcmWriteIsoCallback; + parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; + parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + parmas.dataReq.numIsoPackets = USB_ISO_PACKAT_CNT; + parmas.dataReq.directon = USB_REQUEST_DIR_TO_DEVICE; + parmas.dataReq.length = size; + parmas.dataReq.buffer = (unsigned char *)sendData; + ret = UsbFillRequest(NULL, g_acm->iso_devHandle, &parmas); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFillIsoRequest003(void) +{ + int ret; + struct UsbRequestParams parmas; + int i; + char sendData[] = {"abcde\0"}; + uint32_t size = strlen(sendData) + 1; + if (g_acm->isoPipe == NULL){ + return HDF_FAILURE; + } + for (i = 0; i < 1; i++) { + parmas.interfaceId = g_acm->isoPipe->interfaceId; + parmas.pipeAddress = g_acm->isoPipe->pipeAddress; + parmas.pipeId = g_acm->isoPipe->pipeId; + parmas.callback = AcmWriteIsoCallback; + parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; + parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + parmas.dataReq.numIsoPackets = USB_ISO_PACKAT_CNT; + parmas.dataReq.directon = USB_REQUEST_DIR_TO_DEVICE; + parmas.dataReq.length = size; + parmas.dataReq.buffer = (unsigned char *)sendData; + ret = UsbFillRequest(g_acm->isoReq, NULL, &parmas); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFillIsoRequest004(void) +{ + int ret; + struct UsbRequestParams parmas; + int i; + char sendData[] = {"abcde\0"}; + uint32_t size = strlen(sendData) + 1; + if (g_acm->isoPipe == NULL){ + return HDF_FAILURE; + } + for (i = 0; i < 1; i++) { + parmas.interfaceId = g_acm->isoPipe->interfaceId; + parmas.pipeAddress = g_acm->isoPipe->pipeAddress; + parmas.pipeId = g_acm->isoPipe->pipeId; + parmas.callback = AcmWriteIsoCallback; + parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; + parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + parmas.dataReq.numIsoPackets = USB_ISO_PACKAT_CNT; + parmas.dataReq.directon = USB_REQUEST_DIR_TO_DEVICE; + parmas.dataReq.length = size; + parmas.dataReq.buffer = (unsigned char *)sendData; + ret = UsbFillRequest(g_acm->isoReq, g_acm->iso_devHandle, NULL); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFillIsoRequest005(void) +{ + int ret; + struct UsbRequestParams parmas; + int i; + char sendData[] = {"abcde\0"}; + uint32_t size = strlen(sendData) + 1; + if (g_acm->isoPipe == NULL){ + return HDF_FAILURE; + } + for (i = 0; i < 1; i++) { + parmas.interfaceId = g_acm->isoPipe->interfaceId; + parmas.pipeAddress = g_acm->isoPipe->pipeAddress; + parmas.pipeId = g_acm->isoPipe->pipeId; + parmas.callback = AcmWriteIsoCallback; + parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; + parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + parmas.dataReq.numIsoPackets = USB_ISO_PACKAT_CNT; + parmas.dataReq.directon = USB_REQUEST_DIR_TO_DEVICE; + parmas.dataReq.length = size; + parmas.dataReq.buffer = (unsigned char *)sendData; + ret = UsbFillRequest(NULL, NULL, &parmas); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFillIsoRequest006(void) +{ + int ret; + struct UsbRequestParams parmas; + int i; + char sendData[] = {"abcde\0"}; + uint32_t size = strlen(sendData) + 1; + if (g_acm->isoPipe == NULL){ + return HDF_FAILURE; + } + for (i = 0; i < 1; i++) { + parmas.interfaceId = g_acm->isoPipe->interfaceId; + parmas.pipeAddress = g_acm->isoPipe->pipeAddress; + parmas.pipeId = g_acm->isoPipe->pipeId; + parmas.callback = AcmWriteIsoCallback; + parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; + parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + parmas.dataReq.numIsoPackets = USB_ISO_PACKAT_CNT; + parmas.dataReq.directon = USB_REQUEST_DIR_TO_DEVICE; + parmas.dataReq.length = size; + parmas.dataReq.buffer = (unsigned char *)sendData; + ret = UsbFillRequest(g_acm->isoReq, NULL, NULL); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFreeRequest004(void) +{ + int ret; + ret = UsbFreeRequest(g_acm->ctrlReq); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->ctrlReq = NULL; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfAllocRequest009(void) +{ + int i; + int ret; + g_acm->readSize = g_acm->dataInPipe->maxPacketSize; + for (i = 0; i < ACM_NR; i++) { + g_acm->readReq[i] = UsbAllocRequest(g_acm->data_devHandle, 0, g_acm->readSize); + if (g_acm->readReq[i] == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + + g_acm->writeSize = g_acm->dataOutPipe->maxPacketSize; + ret = AcmWriteBufAlloc(g_acm); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + for (int i = 0; i < ACM_NW; i++) { + g_acm->wb[i].request = UsbAllocRequest(g_acm->data_devHandle, 0, g_acm->writeSize); + g_acm->wb[i].instance = g_acm; + if (g_acm->wb[i].request == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + g_acm->intSize = g_acm->intPipe->maxPacketSize; + g_acm->notifyReq = UsbAllocRequest(g_acm->int_devHandle, 0, g_acm->intSize); + if (g_acm->notifyReq == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + g_acm->ctrlSize = sizeof (struct UsbCdcLineCoding); + g_acm->ctrlReq = UsbAllocRequest(g_acm->ctrl_devHandle, 0, g_acm->ctrlSize); + if (g_acm->ctrlReq == NULL) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFillRequest001(void) +{ + int ret; + struct UsbRequestParams readParmas; + int i; + for (i = 0; i < 1; i++) { + readParmas.userData = (void *)g_acm; + readParmas.pipeAddress = g_acm->dataInPipe->pipeAddress; + readParmas.pipeId = g_acm->dataInPipe->pipeId; + readParmas.interfaceId = g_acm->dataInPipe->interfaceId; + readParmas.callback = AcmReadBulk; + readParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; + readParmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + readParmas.dataReq.numIsoPackets = 0; + readParmas.dataReq.directon = (UsbRequestDirection)((g_acm->dataInPipe->pipeDirection >> USB_DIR_OFFSET) + & DIRECTION_MASK); + readParmas.dataReq.length = g_acm->readSize; + ret = UsbFillRequest(g_acm->readReq[i], g_acm->data_devHandle, &readParmas); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFillRequest002(void) +{ + int ret; + struct UsbRequestParams parmas; + int i; + char sendData[] = {"abcde\0"}; + uint32_t size = strlen(sendData) + 1; + g_acm->writeSize = g_acm->dataOutPipe->maxPacketSize; + size = (size > g_acm->writeSize) ? g_acm->writeSize : size; + + for (i = 0; i < 1; i++) { + g_acm->wb[i].len = size; + ret = memcpy_s(g_acm->wb[i].buf, g_acm->writeSize, sendData, size); + if (ret) { + printf("memcpy_s fial"); + } + parmas.interfaceId = g_acm->dataOutPipe->interfaceId; + parmas.pipeAddress = g_acm->dataOutPipe->pipeAddress; + parmas.pipeId = g_acm->dataOutPipe->pipeId; + parmas.callback = AcmWriteBulk; + parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; + parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + parmas.dataReq.numIsoPackets = 0; + parmas.userData = (void *)&g_acm->wb[i]; + parmas.dataReq.directon = USB_REQUEST_DIR_TO_DEVICE; + parmas.dataReq.length = g_acm->wb[i].len; + parmas.dataReq.buffer = g_acm->wb[i].buf; + ret = UsbFillRequest(g_acm->wb[i].request, g_acm->data_devHandle, &parmas); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFillRequest003(void) +{ + int ret; + struct UsbRequestParams intParmas; + intParmas.userData = (void *)g_acm; + intParmas.pipeAddress = g_acm->intPipe->pipeAddress; + intParmas.pipeId = g_acm->intPipe->pipeId; + intParmas.interfaceId = g_acm->intPipe->interfaceId; + intParmas.callback = AcmCtrlIrq; + intParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; + intParmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + intParmas.dataReq.numIsoPackets = 0; + intParmas.dataReq.directon = (UsbRequestDirection)((g_acm->intPipe->pipeDirection >> USB_PIPE_DIR_OFFSET) + & DIRECTION_MASK); + intParmas.dataReq.length = g_acm->intSize; + ret = UsbFillRequest(g_acm->notifyReq, g_acm->int_devHandle, &intParmas); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFillRequest004(void) +{ + int ret; + struct UsbRequestParams parmas; + uint16_t index = 2; + uint16_t value = 0; + struct TestControlMsgData msgData; + parmas.interfaceId = USB_CTRL_INTERFACE_ID; + parmas.pipeAddress = 0; + parmas.pipeId = 0; + parmas.callback = AcmCtrlIrq; + parmas.requestType = USB_REQUEST_PARAMS_CTRL_TYPE; + parmas.timeout = USB_CTRL_SET_TIMEOUT; + g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + g_acm->lineCoding.bCharFormat = CHARFORMAT; + g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY; + g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS; + msgData.request = USB_DDK_CDC_REQ_SET_LINE_CODING; + msgData.requestType = USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE; + msgData.value = value; + msgData.index = index; + msgData.data = &g_acm->lineCoding; + msgData.size = sizeof(struct UsbCdcLineCoding); + parmas.ctrlReq = UsbControlMsg(msgData); + ret = UsbFillRequest(g_acm->ctrlReq, g_acm->ctrl_devHandle, &parmas); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfSubmitRequestSync001(void) +{ + int ret; + int i; + for (i = 0; i < 1; i++) { + printf("------UsbSubmitRequestSync i = [%d]------\n", i); + ret = UsbSubmitRequestSync(g_acm->readReq[i]); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfSubmitRequestSync002(void) +{ + int ret; + int i; + for (i = 0; i < 1; i++) { + printf("------UsbSubmitRequestSync i = [%d]------\n", i); + ret = UsbSubmitRequestSync(g_acm->wb[i].request); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfSubmitRequestSync003(void) +{ + int ret; + + ret = UsbSubmitRequestSync(g_acm->ctrlReq); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfSubmitRequestSync004(void) +{ + int ret; + ret = UsbSubmitRequestSync(g_acm->notifyReq); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFillRequest005(void) +{ + int ret; + struct UsbRequestParams readParmas; + int i; + for (i = 0; i < ACM_NR; i++) { + readParmas.userData = (void *)g_acm; + readParmas.pipeAddress = g_acm->dataInPipe->pipeAddress; + readParmas.pipeId = g_acm->dataInPipe->pipeId; + readParmas.interfaceId = g_acm->dataInPipe->interfaceId; + readParmas.callback = AcmReadBulk; + readParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; + readParmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + readParmas.dataReq.numIsoPackets = 0; + readParmas.dataReq.directon = (UsbRequestDirection)((g_acm->dataInPipe->pipeDirection >> USB_DIR_OFFSET) + & DIRECTION_MASK); + readParmas.dataReq.length = g_acm->readSize; + ret = UsbFillRequest(g_acm->readReq[i], g_acm->data_devHandle, &readParmas); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFillRequest006(void) +{ + int ret; + struct UsbRequestParams parmas; + int i; + char sendData[] = {"abcde\0"}; + uint32_t size = strlen(sendData) + 1; + g_acm->writeSize = g_acm->dataOutPipe->maxPacketSize; + size = (size > g_acm->writeSize) ? g_acm->writeSize : size; + for (i = 0; i < ACM_NR; i++) { + g_acm->wb[i].len = size; + ret = memcpy_s(g_acm->wb[i].buf, g_acm->writeSize, sendData, size); + if (ret) { + printf("memcpy_s fial"); + } + parmas.interfaceId = g_acm->dataOutPipe->interfaceId; + parmas.pipeAddress = g_acm->dataOutPipe->pipeAddress; + parmas.pipeId = g_acm->dataOutPipe->pipeId; + parmas.callback = AcmWriteBulk; + parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; + parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + parmas.dataReq.numIsoPackets = 0; + parmas.userData = (void *)&g_acm->wb[i]; + parmas.dataReq.length = g_acm->wb[i].len; + parmas.dataReq.buffer = g_acm->wb[i].buf; + ret = UsbFillRequest(g_acm->wb[i].request, g_acm->data_devHandle, &parmas); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFillRequest007(void) +{ + int ret; + struct UsbRequestParams intParmas; + intParmas.userData = (void *)g_acm; + intParmas.pipeAddress = g_acm->intPipe->pipeAddress; + intParmas.pipeId = g_acm->intPipe->pipeId; + intParmas.interfaceId = g_acm->intPipe->interfaceId; + intParmas.callback = AcmCtrlIrq; + intParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; + intParmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + intParmas.dataReq.numIsoPackets = 0; + intParmas.dataReq.directon = (UsbRequestDirection)((g_acm->intPipe->pipeDirection >> USB_PIPE_DIR_OFFSET) + & DIRECTION_MASK); + intParmas.dataReq.length = g_acm->intSize; + ret = UsbFillRequest(g_acm->notifyReq, g_acm->int_devHandle, &intParmas); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfFillRequest008(void) +{ + int ret; + struct UsbRequestParams parmas; + uint16_t index = 2; + uint16_t value = 0; + struct TestControlMsgData msgData; + + parmas.interfaceId = USB_CTRL_INTERFACE_ID; + parmas.pipeAddress = 0; + parmas.pipeId = 0; + parmas.callback = AcmCtrlIrq; + parmas.requestType = USB_REQUEST_PARAMS_CTRL_TYPE; + parmas.timeout = USB_CTRL_SET_TIMEOUT; + g_acm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + g_acm->lineCoding.bCharFormat = CHARFORMAT; + g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY; + g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS; + msgData.request = USB_DDK_CDC_REQ_SET_LINE_CODING; + msgData.requestType = USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE; + msgData.value = value; + msgData.index = index; + msgData.data = &g_acm->lineCoding; + msgData.size = sizeof(struct UsbCdcLineCoding); + parmas.ctrlReq = UsbControlMsg(msgData); + ret = UsbFillRequest(g_acm->ctrlReq, g_acm->ctrl_devHandle, &parmas); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfSubmitRequestAsync001(void) +{ + int ret; + int i; + for (i = 0; i < 1; i++) { + ret = UsbSubmitRequestAsync(g_acm->readReq[i]); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfCancelRequest001(void) +{ + int ret; + int i = 0; + ret = UsbCancelRequest(g_acm->readReq[i]); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfSubmitRequestAsync002(void) +{ + int ret; + int i; + for (i = 0; i < 1; i++) { + ret = UsbSubmitRequestAsync(g_acm->wb[i].request); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfCancelRequest002(void) +{ + int ret; + int i = 0; + ret = UsbCancelRequest(g_acm->wb[i].request); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfSubmitRequestAsync003(void) +{ + int ret; + ret = UsbSubmitRequestAsync(g_acm->notifyReq); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfCancelRequest003(void) +{ + int ret; + ret = UsbCancelRequest(g_acm->notifyReq); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfSubmitRequestAsync004(void) +{ + int ret; + ret = UsbSubmitRequestAsync(g_acm->ctrlReq); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfCancelRequest004(void) +{ + int ret; + ret = UsbCancelRequest(g_acm->ctrlReq); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfClearInterfaceHalt002(void) +{ + int ret; + ret = UsbClearInterfaceHalt(g_acm->data_devHandle, g_acm->dataOutPipe->pipeAddress); + if (ret < 0) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfClearInterfaceHalt003(void) +{ + int ret; + ret = UsbClearInterfaceHalt(g_acm->int_devHandle, g_acm->intPipe->pipeAddress); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_SUCCESS; + } + HDF_LOGE("%s: success", __func__); + return HDF_FAILURE; +} + +static int32_t CheckHostSdkIfClearInterfaceHalt004(void) +{ + int ret; + ret = UsbClearInterfaceHalt(g_acm->ctrl_devHandle, g_acm->ctrPipe->pipeAddress); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_SUCCESS; + } + HDF_LOGE("%s: success", __func__); + return HDF_FAILURE; +} + +static int32_t CheckHostSdkIfRemoveInterface001(void) +{ + int ret; + UsbInterfaceStatus status = USB_INTERFACE_STATUS_REMOVE; + ret = UsbAddOrRemoveInterface(g_acm->session, g_acm->busNum, g_acm->devAddr, + g_acm->dataIface->info.interfaceIndex, status); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfAddInterface001(void) +{ + int ret; + UsbInterfaceStatus status = USB_INTERFACE_STATUS_ADD; + OsalSleep(1); + ret = UsbAddOrRemoveInterface(g_acm->session, g_acm->busNum, g_acm->devAddr, + g_acm->dataIface->info.interfaceIndex, status); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfRemoveInterface002(void) +{ + int ret; + UsbInterfaceStatus status = USB_INTERFACE_STATUS_REMOVE; + OsalSleep(1); + ret = UsbAddOrRemoveInterface(g_acm->session, g_acm->busNum, g_acm->devAddr, + g_acm->intIface->info.interfaceIndex, status); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfAddInterface002(void) +{ + int ret; + UsbInterfaceStatus status = USB_INTERFACE_STATUS_ADD; + + OsalSleep(1); + + ret = UsbAddOrRemoveInterface(g_acm->session, g_acm->busNum, g_acm->devAddr, + g_acm->intIface->info.interfaceIndex, status); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfRemoveInterface003(void) +{ + int ret; + UsbInterfaceStatus status = USB_INTERFACE_STATUS_REMOVE; + + ret = UsbAddOrRemoveInterface(g_acm->session, g_acm->busNum, g_acm->devAddr, + g_acm->ctrIface->info.interfaceIndex, status); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t CheckHostSdkIfAddInterface003(void) +{ + int ret; + UsbInterfaceStatus status = USB_INTERFACE_STATUS_ADD; + + ret = UsbAddOrRemoveInterface(g_acm->session, g_acm->busNum, g_acm->devAddr, + g_acm->ctrIface->info.interfaceIndex, status); + if (ret) { + HDF_LOGE("%s: error", __func__); + return HDF_FAILURE; + } + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +struct UsbTestFunc g_usbTestFunc[] = { + { USB_HOSTSDK_INIT_001_TEST, CheckHostSdkIfInit001}, + { Usb_HOSTSDK_EXIT_001_TEST, CheckHostSdkIfExit001}, + { USB_HOSTSDK_INIT_002_TEST, CheckHostSdkIfInit002}, + { USB_HOSTSDK_EXIT_002_TEST, CheckHostSdkIfExit002}, + { USB_HOSTSDK_INIT_003_TEST, CheckHostSdkIfInit003}, + { USB_HOSTSDK_INIT_004_TEST, CheckHostSdkIfInit004}, + { USB_HOSTSDK_INIT_005_TEST, CheckHostSdkIfInit005}, + { USB_HOSTSDK_CLAIM_INTERFACE_001_TEST, CheckHostSdkIfClaimInterface001}, + { USB_HOSTSDK_RELEASE_INTERFACE_001_TEST, CheckHostSdkIfReleaseInterface001}, + { USB_HOSTSDK_CLAIM_INTERFACE_002_TEST, CheckHostSdkIfClaimInterface002}, + { USB_HOSTSDK_RELEASE_INTERFACE_002_TEST, CheckHostSdkIfReleaseInterface002}, + { USB_HOSTSDK_CLAIM_INTERFACE_003_TEST, CheckHostSdkIfClaimInterface003}, + { USB_HOSTSDK_RELEASE_INTERFACE_003_TEST, CheckHostSdkIfReleaseInterface003}, + { USB_HOSTSDK_CLAIM_INTERFACE_004_TEST, CheckHostSdkIfClaimInterface004}, + { USB_HOSTSDK_CLAIM_INTERFACE_005_TEST, CheckHostSdkIfClaimInterface005}, + { USB_HOSTSDK_CLAIM_INTERFACE_006_TEST, CheckHostSdkIfClaimInterface006}, + { USB_HOSTSDK_OPEN_INTERFACE_001_TEST, CheckHostSdkIfOpenInterface001}, + { USB_HOSTSDK_CLOSE_INTERFACE_001_TEST, CheckHostSdkIfCloseInterface001}, + { USB_HOSTSDK_OPEN_INTERFACE_002_TEST, CheckHostSdkIfOpenInterface002}, + { USB_HOSTSDK_CLOSE_INTERFACE_002_TEST, CheckHostSdkIfCloseInterface002}, + { USB_HOSTSDK_OPEN_INTERFACE_003_TEST, CheckHostSdkIfOpenInterface003}, + { USB_HOSTSDK_CLOSE_INTERFACE_003_TEST, CheckHostSdkIfCloseInterface003}, + { USB_HOSTSDK_OPEN_INTERFACE_004_TEST, CheckHostSdkIfOpenInterface004}, + { USB_HOSTSDK_OPEN_INTERFACE_005_TEST, CheckHostSdkIfOpenInterface005}, + { USB_HOSTSDK_OPEN_INTERFACE_006_TEST, CheckHostSdkIfOpenInterface006}, + { USB_HOSTSDK_SELECT_INTERFACE_001_TEST, CheckHostSdkIfSelectInterfaceSetting001}, + { USB_HOSTSDK_SELECT_INTERFACE_002_TEST, CheckHostSdkIfSelectInterfaceSetting002}, + { USB_HOSTSDK_SELECT_INTERFACE_003_TEST, CheckHostSdkIfSelectInterfaceSetting003}, + { USB_HOSTSDK_SELECT_INTERFACE_004_TEST, CheckHostSdkIfSelectInterfaceSetting004}, + { USB_HOSTSDK_SELECT_INTERFACE_005_TEST, CheckHostSdkIfSelectInterfaceSetting005}, + { USB_HOSTSDK_SELECT_INTERFACE_006_TEST, CheckHostSdkIfSelectInterfaceSetting006}, + { USB_HOSTSDK_CLAIM_INTERFACE_007_TEST, CheckHostSdkIfClaimInterface007}, + { USB_HOSTSDK_CLAIM_INTERFACE_008_TEST, CheckHostSdkIfClaimInterface008}, + { USB_HOSTSDK_GET_PIPE_001_TEST, CheckHostSdkIfGetPipe001}, + { USB_HOSTSDK_GET_PIPE_002_TEST, CheckHostSdkIfGetPipe002}, + { USB_HOSTSDK_GET_PIPE_003_TEST, CheckHostSdkIfGetPipe003}, + { USB_HOSTSDK_GET_PIPE_004_TEST, CheckHostSdkIfGetPipe004}, + { USB_HOSTSDK_GET_PIPE_005_TEST, CheckHostSdkIfGetPipe005}, + { USB_HOSTSDK_GET_PIPE_006_TEST, CheckHostSdkIfGetPipe006}, + { USB_HOSTSDK_GET_PIPE_007_TEST, CheckHostSdkIfGetPipe007}, + { USB_HOSTSDK_GET_PIPE_008_TEST, CheckHostSdkIfGetPipe008}, + { USB_HOSTSDK_ALLOC_REQUEST_001_TEST, CheckHostSdkIfAllocRequest001}, + { USB_HOSTSDK_ALLOC_REQUEST_002_TEST, CheckHostSdkIfAllocRequest002}, + { USB_HOSTSDK_FREE_REQUEST_001_TEST, CheckHostSdkIfFreeRequest001}, + { USB_HOSTSDK_ALLOC_REQUEST_003_TEST, CheckHostSdkIfAllocRequest003}, + { USB_HOSTSDK_ALLOC_REQUEST_004_TEST, CheckHostSdkIfAllocRequest004}, + { USB_HOSTSDK_FREE_REQUEST_002_TEST, CheckHostSdkIfFreeRequest002}, + { USB_HOSTSDK_ALLOC_REQUEST_005_TEST, CheckHostSdkIfAllocRequest005}, + { USB_HOSTSDK_ALLOC_REQUEST_006_TEST, CheckHostSdkIfAllocRequest006}, + { USB_HOSTSDK_FREE_REQUEST_003_TEST, CheckHostSdkIfFreeRequest003}, + { USB_HOSTSDK_ALLOC_REQUEST_007_TEST, CheckHostSdkIfAllocRequest007}, + { USB_HOSTSDK_ALLOC_REQUEST_008_TEST, CheckHostSdkIfAllocRequest008}, + { USB_HOSTSDK_ALLOC_REQUEST_010_TEST, CheckHostSdkIfAllocRequest010}, + { USB_HOSTSDK_ALLOC_REQUEST_011_TEST, CheckHostSdkIfAllocRequest011}, + { USB_HOSTSDK_FREE_REQUEST_006_TEST, CheckHostSdkIfFreeRequest006}, + { USB_HOSTSDK_FILL_ISO_REQUEST_001_TEST, CheckHostSdkIfFillIsoRequest001}, + { USB_HOSTSDK_FILL_ISO_REQUEST_002_TEST, CheckHostSdkIfFillIsoRequest002}, + { USB_HOSTSDK_FILL_ISO_REQUEST_003_TEST, CheckHostSdkIfFillIsoRequest003}, + { USB_HOSTSDK_FILL_ISO_REQUEST_004_TEST, CheckHostSdkIfFillIsoRequest004}, + { USB_HOSTSDK_FILL_ISO_REQUEST_005_TEST, CheckHostSdkIfFillIsoRequest005}, + { USB_HOSTSDK_FILL_ISO_REQUEST_006_TEST, CheckHostSdkIfFillIsoRequest006}, + { USB_HOSTSDK_FREE_REQUEST_004_TEST, CheckHostSdkIfFreeRequest004}, + { USB_HOSTSDK_ALLOC_REQUEST_009_TEST, CheckHostSdkIfAllocRequest009}, + { USB_HOSTSDK_FILL_REQUEST_001_TEST, CheckHostSdkIfFillRequest001}, + { USB_HOSTSDK_FILL_REQUEST_002_TEST, CheckHostSdkIfFillRequest002}, + { USB_HOSTSDK_FILL_REQUEST_003_TEST, CheckHostSdkIfFillRequest003}, + { USB_HOSTSDK_FILL_REQUEST_004_TEST, CheckHostSdkIfFillRequest004}, + { USB_HOSTSDK_SUBMIT_REQUEST_SYNC_001_TEST, CheckHostSdkIfSubmitRequestSync001}, + { USB_HOSTSDK_SUBMIT_REQUEST_SYNC_002_TEST, CheckHostSdkIfSubmitRequestSync002}, + { USB_HOSTSDK_SUBMIT_REQUEST_SYNC_003_TEST, CheckHostSdkIfSubmitRequestSync003}, + { USB_HOSTSDK_SUBMIT_REQUEST_SYNC_004_TEST, CheckHostSdkIfSubmitRequestSync004}, + { USB_HOSTSDK_FILL_REQUEST_005_TEST, CheckHostSdkIfFillRequest005}, + { USB_HOSTSDK_FILL_REQUEST_006_TEST, CheckHostSdkIfFillRequest006}, + { USB_HOSTSDK_FILL_REQUEST_007_TEST, CheckHostSdkIfFillRequest007}, + { USB_HOSTSDK_FILL_REQUEST_008_TEST, CheckHostSdkIfFillRequest008}, + { USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_001_TEST, CheckHostSdkIfSubmitRequestAsync001}, + { USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_001_TEST, CheckHostSdkIfCancelRequest001}, + { USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_002_TEST, CheckHostSdkIfSubmitRequestAsync002}, + { USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_002_TEST, CheckHostSdkIfCancelRequest002}, + { USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_003_TEST, CheckHostSdkIfSubmitRequestAsync003}, + { USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_003_TEST, CheckHostSdkIfCancelRequest003}, + { USB_HOSTSDK_SUBMIT_REQUEST_ASYNC_004_TEST, CheckHostSdkIfSubmitRequestAsync004}, + { USB_HOSTSDK_SUBMIT_CANCEL_REQUEST_004_TEST, CheckHostSdkIfCancelRequest004}, + { USB_HOSTSDK_CLEAR_INTERFACE_HALT_002_TEST, CheckHostSdkIfClearInterfaceHalt002}, + { USB_HOSTSDK_CLEAR_INTERFACE_HALT_003_TEST, CheckHostSdkIfClearInterfaceHalt003}, + { USB_HOSTSDK_CLEAR_INTERFACE_HALT_004_TEST, CheckHostSdkIfClearInterfaceHalt004}, + { USB_HOSTSDK_REMOVE_INTERFACE_001_TEST, CheckHostSdkIfRemoveInterface001}, + { USB_HOSTSDK_ADD_INTERFACE_001_TEST, CheckHostSdkIfAddInterface001}, + { USB_HOSTSDK_REMOVE_INTERFACE_002_TEST, CheckHostSdkIfRemoveInterface002}, + { USB_HOSTSDK_ADD_INTERFACE_002_TEST, CheckHostSdkIfAddInterface002}, + { USB_HOSTSDK_REMOVE_INTERFACE_003_TEST, CheckHostSdkIfRemoveInterface003}, + { USB_HOSTSDK_ADD_INTERFACE_003_TEST, CheckHostSdkIfAddInterface003}, +}; + +int32_t UsbTestEntry(int32_t cmd) +{ + int32_t i; + int32_t ret = HDF_ERR_NOT_SUPPORT; + + if (g_initFlag == false) { +#ifdef LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY + struct UsbGetDevicePara paraData; + struct usb_device *usbPnpDevice = NULL; + paraData.type = USB_PNP_DEVICE_VENDOR_PRODUCT_TYPE; + paraData.vendorId = USB_DEVICE_VENDOR_ID; + paraData.productId = USB_DEVICE_PRODUCT_ID; + usbPnpDevice = UsbPnpNotifyGetUsbDevice(paraData); + if (usbPnpDevice == NULL) { + HDF_LOGE("%s:%d UsbPnpNotifyGetUsbDevice is NULL!", __func__, __LINE__); + return HDF_ERR_INVALID_PARAM; + } + g_acm->busNum = usbPnpDevice->address; + g_acm->devAddr = usbPnpDevice->port_no; + HDF_LOGE("%s: busNum %d++devAddr %d", __func__, g_acm->busNum, g_acm->devAddr); + g_initFlag = true; +#else + HDF_LOGE("%s:%d pnp notify module is not support!", __func__, __LINE__); + return HDF_ERR_NOT_SUPPORT; +#endif + } + for (i = 0; i < sizeof(g_usbTestFunc) / sizeof(g_usbTestFunc[0]); i++) { + if (cmd == g_usbTestFunc[i].type && g_usbTestFunc[i].Func != NULL) { + ret = g_usbTestFunc[i].Func(); + HDF_LOGE("%s: cmd %d ret %d", __func__, cmd, ret); + break; + } + } + return ret; +} -- Gitee