diff --git a/.gitignore b/.gitignore index d1606884fa9fc2c49467d620e7c6d2317ebfa5b1..48fd83b28816e46bab4cba422a93d96e7174fb7d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,5 +1 @@ -*.o -*.a -*.d -*.cmd tools/hc-gen/build diff --git a/OAT.xml b/OAT.xml index 3b80ed211f30e0b960ea3d5b0ad38b288076ce75..71a26d5310f6e5296aa0fcd68f3d7e05ee623297 100644 --- a/OAT.xml +++ b/OAT.xml @@ -61,6 +61,7 @@ Note:If the text contains special characters, please escape them according to th + diff --git a/core/adapter/syscall/src/hdf_syscall_adapter.c b/core/adapter/syscall/src/hdf_syscall_adapter.c index 2759120dc6fdacb63d7613ae8b2bec7ebdb8f693..88db2dc937325e4723812826254af750327f3f86 100644 --- a/core/adapter/syscall/src/hdf_syscall_adapter.c +++ b/core/adapter/syscall/src/hdf_syscall_adapter.c @@ -664,7 +664,7 @@ static int32_t HdfSyscallAdapterDispatch(struct HdfObject *object, int32_t code, wrBuf.cmdCode = code; int32_t ret = ioctl(ioService->fd, HDF_WRITE_READ, &wrBuf); if (ret < 0) { - HDF_LOGE("Failed to dispatch serv call ioctl %d", errno); + HDF_LOGE("Failed to dispatch serv call ioctl %{public}d", errno); } if (reply != NULL) { HdfSbufSetDataSize(reply, wrBuf.readConsumed); diff --git a/core/adapter/vnode/src/hdf_vnode_adapter.c b/core/adapter/vnode/src/hdf_vnode_adapter.c index dab5a350ee3c6535b231d291604c205f5a650603..90e357ec018595f51ff462fe890bf10b896003e4 100644 --- a/core/adapter/vnode/src/hdf_vnode_adapter.c +++ b/core/adapter/vnode/src/hdf_vnode_adapter.c @@ -199,8 +199,10 @@ static int HdfVNodeAdapterServCall(const struct HdfVNodeAdapterClient *client, u struct HdfSBuf *reply = NULL; int ret; - if (client->serv == NULL) { - return HDF_DEV_ERR_NO_DEVICE; + if (client->serv == NULL || client->adapter == NULL || + client->adapter->ioService.dispatcher == NULL || + client->adapter->ioService.dispatcher->Dispatch == NULL) { + return HDF_ERR_INVALID_OBJECT; } if (bwrUser == NULL) { @@ -545,8 +547,9 @@ static unsigned int HdfVNodeAdapterPoll(struct file *filep, poll_table *wait) static int HdfVNodeAdapterClose(struct OsalCdev *cdev, struct file *filep) { + struct HdfVNodeAdapterClient *client = NULL; (void)cdev; - struct HdfVNodeAdapterClient *client = (struct HdfVNodeAdapterClient *)OsalGetFilePriv(filep); + client = (struct HdfVNodeAdapterClient *)OsalGetFilePriv(filep); if (client->ioServiceClient.device != NULL && client->ioServiceClient.device->service != NULL && client->ioServiceClient.device->service->Release != NULL) { client->ioServiceClient.device->service->Release(&client->ioServiceClient); @@ -642,7 +645,7 @@ int32_t HdfDeviceSendEvent(const struct HdfDeviceObject *deviceObject, uint32_t } deviceNode = CONTAINER_OF(deviceObject, struct HdfDeviceNode, deviceObject); - if (deviceNode->deviceInfo->policy != SERVICE_POLICY_CAPACITY) { + if (deviceNode->policy != SERVICE_POLICY_CAPACITY) { return HDF_ERR_NOT_SUPPORT; } diff --git a/core/common/src/buildin_config_entry.c b/core/common/src/buildin_config_entry.c new file mode 100644 index 0000000000000000000000000000000000000000..cbf8ca2e95c86d245d7b5bda52fac5485e5573ef --- /dev/null +++ b/core/common/src/buildin_config_entry.c @@ -0,0 +1,14 @@ +/* + * 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 "hcs_tree_if.h" + +const struct DeviceResourceNode *HdfGetHcsRootNode(void) +{ + return HcsGetRootNode(); +} \ No newline at end of file diff --git a/core/common/src/devlite_object_config.c b/core/common/src/devlite_object_config.c index bea66407d5329eed3c48ff628f80b3de81747963..8be58a208403c8b712ee141eb39461dadf78217e 100644 --- a/core/common/src/devlite_object_config.c +++ b/core/common/src/devlite_object_config.c @@ -6,15 +6,16 @@ * See the LICENSE file in the root of this repository for complete details. */ -#include "hdf_object_manager.h" #include "devhost_service.h" #include "devmgr_service.h" #include "devsvc_manager.h" +#include "devsvc_manager_ext.h" #include "hdf_device.h" #include "hdf_device_node_ext.h" #include "hdf_device_token.h" #include "hdf_driver_installer.h" #include "hdf_driver_loader.h" +#include "hdf_object_manager.h" static const struct HdfObjectCreator g_liteObjectCreators[] = { [HDF_OBJECT_ID_DEVMGR_SERVICE] = @@ -24,8 +25,8 @@ static const struct HdfObjectCreator g_liteObjectCreators[] = { }, [HDF_OBJECT_ID_DEVSVC_MANAGER] = { - .Create = DevSvcManagerCreate, - .Release = DevSvcManagerRelease, + .Create = DevSvcManagerExtCreate, + .Release = DevSvcManagerExtRelease, }, [HDF_OBJECT_ID_DEVHOST_SERVICE] = { diff --git a/core/common/src/devmgr_service_start.c b/core/common/src/devmgr_service_start.c index a7d27eb9c3d596b8d1e6db7e9fa7b0bc94fd805d..b537fbc2735bfb86d874a159446ab1335a6f273d 100644 --- a/core/common/src/devmgr_service_start.c +++ b/core/common/src/devmgr_service_start.c @@ -9,41 +9,27 @@ #include "devmgr_service_start.h" #include "devhost_service_clnt.h" #include "devmgr_service.h" +#include "devsvc_manager.h" #include "devsvc_manager_clnt.h" #include "hdf_base.h" #include "hdf_device_node.h" #include "hdf_io_service.h" #include "hdf_log.h" +#include "hdf_power_manager.h" #include "hdf_sbuf.h" #define DEV_MGR_NODE_PERM 0660 static int g_isQuickLoad = DEV_MGR_SLOW_LOAD; -static void GetDeviceServiceNameByClass(DeviceClass deviceClass, struct HdfSBuf *reply) +static void GetDeviceServiceNameByClass(struct HdfSBuf *reply, DeviceClass deviceClass) { - struct HdfSListIterator itDeviceInfo; - struct HdfDeviceInfo *deviceInfo = NULL; - struct DevHostServiceClnt *hostClnt = NULL; - struct DevmgrService *devMgrSvc = (struct DevmgrService *)DevmgrServiceGetInstance(); - if (devMgrSvc == NULL || reply == NULL) { + if (reply == NULL) { return; } HdfSbufFlush(reply); - DLIST_FOR_EACH_ENTRY(hostClnt, &devMgrSvc->hosts, struct DevHostServiceClnt, node) { - HdfSListIteratorInit(&itDeviceInfo, hostClnt->deviceInfos); - while (HdfSListIteratorHasNext(&itDeviceInfo)) { - deviceInfo = (struct HdfDeviceInfo *)HdfSListIteratorNext(&itDeviceInfo); - if (deviceInfo->policy == SERVICE_POLICY_CAPACITY) { - struct HdfDeviceObject *deviceObject = DevSvcManagerClntGetDeviceObject(deviceInfo->svcName); - if (deviceObject == NULL || (deviceObject->deviceClass != deviceClass)) { - continue; - } - HdfSbufWriteString(reply, deviceInfo->svcName); - } - } - } + DevSvcManagerListService(reply, deviceClass); HdfSbufWriteString(reply, NULL); } @@ -52,7 +38,11 @@ int DeviceManagerDispatch(struct HdfObject *stub, int code, struct HdfSBuf *data int ret = HDF_FAILURE; int32_t deviceClass = 0; const char *svcName = NULL; - struct DevmgrService *devMgrSvc = (struct DevmgrService *)stub; + struct DevmgrService *devMgrSvc = (struct DevmgrService *)DevmgrServiceGetInstance(); + static struct SubscriberCallback callback = { + .deviceObject = NULL, + .OnServiceConnected = NULL, + }; if (data == NULL || devMgrSvc == NULL) { HDF_LOGE("%s: input param is invalid", __func__); return ret; @@ -65,10 +55,6 @@ int DeviceManagerDispatch(struct HdfObject *stub, int code, struct HdfSBuf *data HDF_LOGE("%s: get svc name is null", __func__); break; } - static struct SubscriberCallback callback = { - .deviceObject = NULL, - .OnServiceConnected = NULL, - }; ret = DevSvcManagerClntSubscribeService(svcName, callback); break; case DEVMGR_UNLOAD_SERVICE: @@ -84,7 +70,7 @@ int DeviceManagerDispatch(struct HdfObject *stub, int code, struct HdfSBuf *data HDF_LOGE("%s: failed to get deviceClass", __func__); break; } - GetDeviceServiceNameByClass(deviceClass, reply); + GetDeviceServiceNameByClass(reply, deviceClass); ret = HDF_SUCCESS; break; default: @@ -107,30 +93,39 @@ int DeviceManagerIsQuickLoad(void) int DeviceManagerStart(void) { + struct HdfIoService *ioService = NULL; + int ret; struct IDevmgrService *instance = DevmgrServiceGetInstance(); if (instance == NULL || instance->StartService == NULL) { HDF_LOGE("device manager start failed, service instance is null"); return HDF_FAILURE; } - struct HdfIoService *ioService = HdfIoServicePublish(DEV_MGR_NODE, DEV_MGR_NODE_PERM); + ioService = HdfIoServicePublish(DEV_MGR_NODE, DEV_MGR_NODE_PERM); if (ioService != NULL) { static struct HdfIoDispatcher dispatcher = { .Dispatch = DeviceManagerDispatch, }; ioService->dispatcher = &dispatcher; - ioService->target = &instance->base; + ioService->target = NULL; } - return instance->StartService(instance); + ret = instance->StartService(instance); + if (ret != HDF_SUCCESS) { + HDF_LOGE("failed to start hdf devmgr"); + return ret; + } + + return HdfPowerManagerInit(); } int DeviceManagerStartStep2() { + struct DevmgrService *devMgrSvc = NULL; if (DeviceManagerIsQuickLoad() == DEV_MGR_SLOW_LOAD) { HDF_LOGW("%s: device manager is not set to QuickLoad mode", __func__); return HDF_SUCCESS; } - struct DevmgrService *devMgrSvc = (struct DevmgrService *)DevmgrServiceGetInstance(); + devMgrSvc = (struct DevmgrService *)DevmgrServiceGetInstance(); return DevmgrServiceLoadLeftDriver(devMgrSvc); } diff --git a/core/common/src/hdf_attribute.c b/core/common/src/hdf_attribute.c index 3234d52d6eab7419e9157835738bc206e2fdd900..4ceb22c92b3642a668e024d447c83415b0420bc3 100644 --- a/core/common/src/hdf_attribute.c +++ b/core/common/src/hdf_attribute.c @@ -8,16 +8,9 @@ #include "hdf_attribute_manager.h" #include "devhost_service_clnt.h" -#include "devmgr_service.h" -#include "hcs_blob_if.h" -#include "hcs_parser.h" #include "hcs_tree_if.h" -#include "hdf_base.h" -#include "hdf_device_info.h" #include "hdf_host_info.h" #include "hdf_log.h" -#include "osal_mem.h" -#include "securec.h" #ifdef LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY #include "usb_pnp_manager.h" #endif @@ -32,45 +25,17 @@ #define ATTR_DEV_MATCHATTR "deviceMatchAttr" #define MANAGER_NODE_MATCH_ATTR "hdf_manager" -static struct DeviceResourceNode *g_hcsTreeRoot = NULL; - -void HdfGetBuildInConfigData(const unsigned char **data, unsigned int *size); - -static bool CreateHcsToTree(void) -{ - uint32_t length; - const unsigned char *hcsBlob = NULL; - HdfGetBuildInConfigData(&hcsBlob, &length); - if (!HcsCheckBlobFormat((const char *)hcsBlob, length)) { - return false; - } - if (!HcsDecompile((const char *)hcsBlob, HBC_HEADER_LENGTH, &g_hcsTreeRoot)) { - return false; - } - return true; -} - -const struct DeviceResourceNode *HcsGetRootNode(void) -{ - if ((g_hcsTreeRoot == NULL) && !CreateHcsToTree()) { - HDF_LOGE("%s: failed", __func__); - return NULL; - } - return g_hcsTreeRoot; -} - -const struct DeviceResourceNode *HdfGetRootNode(void) -{ - return HcsGetRootNode(); -} +#define DEFATLT_DEV_PRIORITY 100 static bool HdfHostListCompare(struct HdfSListNode *listEntryFirst, struct HdfSListNode *listEntrySecond) { + struct HdfHostInfo *attrFirst = NULL; + struct HdfHostInfo *attrSecond = NULL; if (listEntryFirst == NULL || listEntrySecond == NULL) { return false; } - struct HdfHostInfo *attrFirst = (struct HdfHostInfo *)listEntryFirst; - struct HdfHostInfo *attrSecond = (struct HdfHostInfo *)listEntrySecond; + attrFirst = (struct HdfHostInfo *)listEntryFirst; + attrSecond = (struct HdfHostInfo *)listEntrySecond; return attrFirst->priority <= attrSecond->priority; } @@ -105,14 +70,14 @@ bool HdfAttributeManagerGetHostList(struct HdfSList *hostList) return false; } - hdfManagerNode = GetHdfManagerNode(HcsGetRootNode()); + hdfManagerNode = GetHdfManagerNode(HdfGetHcsRootNode()); if (hdfManagerNode == NULL) { HDF_LOGE("%s: get hdf manager node is null", __func__); return false; } hostNode = hdfManagerNode->child; - while (hostNode != NULL) { + for (; hostNode != NULL; hostNode = hostNode->sibling) { struct HdfHostInfo *hostInfo = HdfHostInfoNewInstance(); if (hostInfo == NULL) { HdfSListFlush(hostList, HdfHostInfoDelete); @@ -121,28 +86,27 @@ bool HdfAttributeManagerGetHostList(struct HdfSList *hostList) } if (!GetHostInfo(hostNode, hostInfo)) { HdfHostInfoFreeInstance(hostInfo); - hostNode = hostNode->sibling; continue; } hostInfo->hostId = hostId; if (!HdfSListAddOrder(hostList, &hostInfo->node, HdfHostListCompare)) { HdfHostInfoFreeInstance(hostInfo); - hostNode = hostNode->sibling; continue; } hostId++; - hostNode = hostNode->sibling; } return true; } static bool HdfDeviceListCompare(struct HdfSListNode *listEntryFirst, struct HdfSListNode *listEntrySecond) { + struct HdfDeviceInfo *attrFirst = NULL; + struct HdfDeviceInfo *attrSecond = NULL; if (listEntryFirst == NULL || listEntrySecond == NULL) { return false; } - struct HdfDeviceInfo *attrFirst = (struct HdfDeviceInfo *)listEntryFirst; - struct HdfDeviceInfo *attrSecond = (struct HdfDeviceInfo *)listEntrySecond; + attrFirst = (struct HdfDeviceInfo *)listEntryFirst; + attrSecond = (struct HdfDeviceInfo *)listEntrySecond; return attrFirst->priority <= attrSecond->priority; } @@ -154,7 +118,7 @@ static const struct DeviceResourceNode *GetHostNode(const char *inHostName) if (inHostName == NULL) { return NULL; } - hdfManagerNode = GetHdfManagerNode(HcsGetRootNode()); + hdfManagerNode = GetHdfManagerNode(HdfGetHcsRootNode()); if (hdfManagerNode == NULL) { return NULL; } @@ -174,7 +138,7 @@ static const struct DeviceResourceNode *GetHostNode(const char *inHostName) static bool CheckDeviceInfo(const struct HdfDeviceInfo *deviceNodeInfo) { - if (deviceNodeInfo->policy > SERVICE_POLICY_PRIVATE) { + if (deviceNodeInfo->policy >= SERVICE_POLICY_INVALID) { HDF_LOGE("%s: policy %u is invalid", __func__, deviceNodeInfo->policy); return false; } @@ -184,7 +148,7 @@ static bool CheckDeviceInfo(const struct HdfDeviceInfo *deviceNodeInfo) return false; } - if (deviceNodeInfo->preload > DEVICE_PRELOAD_DISABLE) { + if (deviceNodeInfo->preload >= DEVICE_PRELOAD_INVALID) { HDF_LOGE("%s: preload %u is invalid", __func__, deviceNodeInfo->preload); return false; } @@ -194,179 +158,81 @@ static bool CheckDeviceInfo(const struct HdfDeviceInfo *deviceNodeInfo) static bool GetDeviceNodeInfo(const struct DeviceResourceNode *deviceNode, struct HdfDeviceInfo *deviceNodeInfo) { - uint16_t readNum = 0; - const char *readString = NULL; - if (HcsGetUint16(deviceNode, ATTR_DEV_POLICY, &readNum, 0) != HDF_SUCCESS) { - HDF_LOGE("%s: failed to get policy", __func__); - return false; - } - deviceNodeInfo->policy = readNum; + HcsGetUint16(deviceNode, ATTR_DEV_POLICY, &deviceNodeInfo->policy, 0); + HcsGetUint16(deviceNode, ATTR_DEV_PRIORITY, &deviceNodeInfo->priority, DEFATLT_DEV_PRIORITY); + HcsGetUint16(deviceNode, ATTR_DEV_PRELOAD, &deviceNodeInfo->preload, 0); + HcsGetUint16(deviceNode, ATTR_DEV_PERMISSION, &deviceNodeInfo->permission, 0); + HcsGetString(deviceNode, ATTR_DEV_MATCHATTR, &deviceNodeInfo->deviceMatchAttr, NULL); - if (HcsGetUint16(deviceNode, ATTR_DEV_PRIORITY, &readNum, 0) != HDF_SUCCESS) { - HDF_LOGE("%s: failed to get priority", __func__); - return false; - } - deviceNodeInfo->priority = readNum; - - if (HcsGetUint16(deviceNode, ATTR_DEV_PRELOAD, &readNum, 0) != HDF_SUCCESS) { - HDF_LOGE("%s: failed to get preload", __func__); - return false; - } - deviceNodeInfo->preload = readNum; - - if (HcsGetUint16(deviceNode, ATTR_DEV_PERMISSION, &readNum, 0) != HDF_SUCCESS) { - HDF_LOGE("%s: failed to get permission", __func__); - return false; - } - deviceNodeInfo->permission = readNum; - - if (HcsGetString(deviceNode, ATTR_DEV_MODULENAME, &readString, NULL) != HDF_SUCCESS) { + if (HcsGetString(deviceNode, ATTR_DEV_MODULENAME, &deviceNodeInfo->moduleName, NULL) != HDF_SUCCESS) { HDF_LOGE("%s: failed to get module name", __func__); return false; } - deviceNodeInfo->moduleName = readString; - if (HcsGetString(deviceNode, ATTR_DEV_SVCNAME, &readString, NULL) != HDF_SUCCESS) { + if (HcsGetString(deviceNode, ATTR_DEV_SVCNAME, &deviceNodeInfo->svcName, NULL) != HDF_SUCCESS) { HDF_LOGE("%s: failed to get service name", __func__); return false; } - deviceNodeInfo->svcName = readString; - if (HcsGetString(deviceNode, ATTR_DEV_MATCHATTR, &readString, NULL) != HDF_SUCCESS) { - HDF_LOGE("%s: failed to get matchattr name", __func__); - return false; - } - deviceNodeInfo->deviceMatchAttr = readString; return CheckDeviceInfo(deviceNodeInfo); } -struct HdfSList *HdfAttributeManagerGetDeviceList(uint16_t hostId, const char *hostName) +static bool GetDevcieNodeList(const struct DeviceResourceNode *device, + struct DevHostServiceClnt *hostClnt, uint16_t deviceIdx) { - uint16_t deviceIdx = 0; - const struct DeviceResourceNode *hostNode = GetHostNode(hostName); - if (hostNode == NULL) { - return NULL; - } - struct HdfSList *deviceList = (struct HdfSList *)OsalMemCalloc(sizeof(struct HdfSList)); - if (deviceList == NULL) { - return NULL; - } - const struct DeviceResourceNode *device = hostNode->child; - while (device != NULL) { - const struct DeviceResourceNode *deviceNode = device->child; - while (deviceNode != NULL) { - struct HdfDeviceInfo *deviceNodeInfo = HdfDeviceInfoNewInstance(); - if (deviceNodeInfo == NULL) { - HdfSListFlush(deviceList, HdfDeviceInfoDelete); - OsalMemFree(deviceList); - return NULL; - } - deviceNodeInfo->hostId = hostId; - if (!GetDeviceNodeInfo(deviceNode, deviceNodeInfo)) { - HdfDeviceInfoFreeInstance(deviceNodeInfo); - HDF_LOGE("%s: failed to get device", __func__); - deviceNodeInfo = NULL; - deviceNode = deviceNode->sibling; - continue; - } - if (!HdfSListAddOrder(deviceList, &deviceNodeInfo->node, HdfDeviceListCompare)) { - HDF_LOGE("%s: failed to add device %s", __func__, deviceNodeInfo->svcName); + uint8_t deviceNodeIdx = 1; + uint16_t hostId = hostClnt->hostId; + struct HdfDeviceInfo *deviceNodeInfo = NULL; + const struct DeviceResourceNode *devNodeResource = device->child; + + for (; devNodeResource != NULL; devNodeResource = devNodeResource->sibling) { + deviceNodeInfo = HdfDeviceInfoNewInstance(); + if (deviceNodeInfo == NULL) { + return false; + } + if (!GetDeviceNodeInfo(devNodeResource, deviceNodeInfo)) { + HdfDeviceInfoFreeInstance(deviceNodeInfo); + HDF_LOGE("%s: failed to parse device node info, ignore", __func__); + continue; + } + + deviceNodeInfo->deviceId = MK_DEVID(hostId, deviceIdx, deviceNodeIdx); + if (deviceNodeInfo->preload != DEVICE_PRELOAD_DISABLE) { + if (!HdfSListAddOrder(&hostClnt->unloadDevInfos, &deviceNodeInfo->node, HdfDeviceListCompare)) { + HDF_LOGE("%s: failed to add device info to list %s", __func__, deviceNodeInfo->svcName); HdfDeviceInfoFreeInstance(deviceNodeInfo); - deviceNodeInfo = NULL; - deviceNode = deviceNode->sibling; continue; } - deviceNodeInfo->deviceId = deviceIdx; - deviceNode = deviceNode->sibling; + } else { + HdfSListAdd(&hostClnt->dynamicDevInfos, &deviceNodeInfo->node); } - device = device->sibling; - deviceIdx++; - } - if (HdfSListCount(deviceList) == 0) { - OsalMemFree(deviceList); - return NULL; + + deviceNodeIdx++; } - return deviceList; + return deviceNodeIdx > 1; } -bool HdfDeviceListAdd(const char *moduleName, const char *serviceName, const void *privateData) +int HdfAttributeManagerGetDeviceList(struct DevHostServiceClnt *hostClnt) { - struct HdfSListIterator itDeviceInfo; - struct HdfDeviceInfo *deviceInfo = NULL; - struct DevHostServiceClnt *hostClnt = NULL; - struct DevmgrService *devMgrSvc = (struct DevmgrService *)DevmgrServiceGetInstance(); - if (devMgrSvc == NULL || moduleName == NULL || serviceName == NULL) { - return false; - } + uint16_t deviceIdx = 1; + const struct DeviceResourceNode *hostNode = NULL; + const struct DeviceResourceNode *device = NULL; + int ret = HDF_DEV_ERR_NO_DEVICE; - struct HdfDeviceInfo *deviceNodeInfo = HdfDeviceInfoNewInstance(); - if (deviceNodeInfo == NULL) { - return false; + if (hostClnt == NULL) { + return HDF_ERR_INVALID_PARAM; } - DLIST_FOR_EACH_ENTRY(hostClnt, &devMgrSvc->hosts, struct DevHostServiceClnt, node) { - HdfSListIteratorInit(&itDeviceInfo, hostClnt->deviceInfos); - while (HdfSListIteratorHasNext(&itDeviceInfo)) { - deviceInfo = (struct HdfDeviceInfo *)HdfSListIteratorNext(&itDeviceInfo); - if (deviceInfo->moduleName == NULL) { - continue; - } - if (strcmp(deviceInfo->moduleName, moduleName) == 0) { - deviceInfo->isDynamic = true; - deviceNodeInfo->hostId = deviceInfo->hostId; - deviceNodeInfo->deviceId = hostClnt->devCount; - deviceNodeInfo->policy = deviceInfo->policy; - deviceNodeInfo->priority = deviceInfo->priority; - deviceNodeInfo->preload = DEVICE_PRELOAD_DISABLE; - deviceNodeInfo->permission = deviceInfo->permission; - deviceNodeInfo->deviceMatchAttr = deviceInfo->deviceMatchAttr; - deviceNodeInfo->moduleName = deviceInfo->moduleName; - char *svcName = OsalMemCalloc(strlen(serviceName) + 1); - if (svcName == NULL) { - break; - } - if (strcpy_s(svcName, strlen(serviceName) + 1, serviceName) != EOK) { - HDF_LOGE("%s: failed to copy string", __func__); - OsalMemFree(svcName); - break; - } - deviceNodeInfo->svcName = svcName; -#ifdef LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY - if (!UsbPnpManagerAddPrivateData(deviceNodeInfo, privateData)) { - break; - } -#endif - HdfSListAdd(hostClnt->deviceInfos, &deviceNodeInfo->node); - hostClnt->devCount++; - return true; - } - } - } - HdfDeviceInfoFreeInstance(deviceNodeInfo); - return false; -} -void HdfDeviceListDel(const char *moduleName, const char *serviceName) -{ - struct HdfSListIterator itDeviceInfo; - struct HdfDeviceInfo *deviceInfo = NULL; - struct DevHostServiceClnt *hostClnt = NULL; - struct DevmgrService *devMgrSvc = (struct DevmgrService *)DevmgrServiceGetInstance(); - if (devMgrSvc == NULL || moduleName == NULL || serviceName == NULL) { - return; + hostNode = GetHostNode(hostClnt->hostName); + if (hostNode == NULL) { + return ret; } - DLIST_FOR_EACH_ENTRY(hostClnt, &devMgrSvc->hosts, struct DevHostServiceClnt, node) { - HdfSListIteratorInit(&itDeviceInfo, hostClnt->deviceInfos); - while (HdfSListIteratorHasNext(&itDeviceInfo)) { - deviceInfo = (struct HdfDeviceInfo *)HdfSListIteratorNext(&itDeviceInfo); - if ((strcmp(deviceInfo->moduleName, moduleName) == 0) && - (strcmp(deviceInfo->svcName, serviceName) == 0)) { - HdfSListRemove(hostClnt->deviceInfos, &deviceInfo->node); - HdfDeviceInfoFreeInstance(deviceInfo); - hostClnt->devCount--; - return; - } + for(device = hostNode->child; device != NULL; device = device->sibling, deviceIdx++) { + if (!GetDevcieNodeList(device, hostClnt, deviceIdx)) { + return ret; } } -} + return HDF_SUCCESS; +} \ No newline at end of file diff --git a/core/common/src/hdf_device_node_ext.c b/core/common/src/hdf_device_node_ext.c index a8143a44132b635657c5d68af71a6a559c725c79..030b0a83f6a8f30e0865ef8f32b2ffe8ac5be1b4 100644 --- a/core/common/src/hdf_device_node_ext.c +++ b/core/common/src/hdf_device_node_ext.c @@ -15,19 +15,18 @@ #include "hdf_sbuf.h" #include "osal_mem.h" -#define HDF_LOG_TAG device_node_ext +#define HDF_LOG_TAG devnode_ext static int DeviceNodeExtDispatch(struct HdfObject *stub, int code, struct HdfSBuf *data, struct HdfSBuf *reply) { struct IDeviceIoService *deviceMethod = NULL; - const struct HdfDeviceInfo *deviceInfo = NULL; struct HdfDeviceNode *devNode = NULL; + uint64_t ioClientPtr = 0; if (stub == NULL) { HDF_LOGE("device ext dispatch: stub is null"); return HDF_FAILURE; } - uint64_t ioClientPtr = 0; if (!HdfSbufReadUint64(reply, &ioClientPtr) || ioClientPtr == 0) { HDF_LOGE("device ext dispatch: input ioClient is null"); return HDF_FAILURE; @@ -39,12 +38,8 @@ static int DeviceNodeExtDispatch(struct HdfObject *stub, int code, struct HdfSBu HDF_LOGE("device ext dispatch: device service interface is null"); return HDF_FAILURE; } - deviceInfo = devNode->deviceInfo; - if (deviceInfo == NULL) { - HDF_LOGE("device ext dispatch: device deviceInfo is null"); - return HDF_FAILURE; - } - if (deviceInfo->policy == SERVICE_POLICY_CAPACITY) { + + if (devNode->policy == SERVICE_POLICY_CAPACITY) { if (deviceMethod->Dispatch == NULL) { HDF_LOGE("device ext dispatch: remote service dispatch method is null"); return HDF_FAILURE; @@ -54,56 +49,82 @@ static int DeviceNodeExtDispatch(struct HdfObject *stub, int code, struct HdfSBu return HDF_FAILURE; } -static int DeviceNodeExtPublishService(struct HdfDeviceNode *inst, const char *serviceName) +static int DeviceNodeExtPublishService(struct HdfDeviceNode *devNode) { - const struct HdfDeviceInfo *deviceInfo = NULL; struct HdfDeviceObject *deviceObject = NULL; - struct DeviceNodeExt *devNodeExt = (struct DeviceNodeExt *)inst; + struct DeviceNodeExt *devNodeExt = (struct DeviceNodeExt *)devNode; + int ret; + static struct HdfIoDispatcher dispatcher = { .Dispatch = DeviceNodeExtDispatch }; + if (devNodeExt == NULL) { return HDF_FAILURE; } - int ret = HdfDeviceNodePublishPublicService(inst, serviceName); - if (ret != HDF_SUCCESS) { - HDF_LOGE("failed to publish device service, ret is %d", ret); - return HDF_FAILURE; - } - deviceInfo = inst->deviceInfo; deviceObject = &devNodeExt->super.deviceObject; - if ((deviceObject->service == NULL) || (deviceInfo == NULL)) { - HDF_LOGE("Device service interface or deviceInfo is null"); + if (deviceObject->service == NULL) { + HDF_LOGE("device service interface is null"); return HDF_FAILURE; } - if (deviceInfo->policy == SERVICE_POLICY_CAPACITY) { - devNodeExt->ioService = HdfIoServicePublish(serviceName, deviceInfo->permission); + if (devNode->policy == SERVICE_POLICY_CAPACITY) { + devNodeExt->ioService = HdfIoServicePublish(devNode->servName, devNode->permission); if (devNodeExt->ioService != NULL) { - devNodeExt->ioService->target = (struct HdfObject*)(&inst->deviceObject); - static struct HdfIoDispatcher dispatcher = { - .Dispatch = DeviceNodeExtDispatch - }; + devNodeExt->ioService->target = (struct HdfObject *)(deviceObject); devNodeExt->ioService->dispatcher = &dispatcher; } else { - HDF_LOGE("Device remote service bind failed"); - HdfDeviceNodeReclaimService(serviceName); - return HDF_FAILURE; + HDF_LOGE("device remote service publish failed"); + return HDF_DEV_ERR_NO_DEVICE_SERVICE; } } + + // base(device node) publish inner service + ret = HdfDeviceNodePublishPublicService(devNode); + if (ret != HDF_SUCCESS) { + HDF_LOGE("failed to publish device service, ret is %d", ret); + HdfIoServiceRemove(devNodeExt->ioService); + devNodeExt->ioService = NULL; + return ret; + } + return HDF_SUCCESS; } +int DeviceNodeExtRemoveService(struct HdfDeviceNode *devNode) +{ + struct DeviceNodeExt *devNodeExt = CONTAINER_OF(devNode, struct DeviceNodeExt, super); + if (devNode == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (devNode->policy == SERVICE_POLICY_CAPACITY) { + HdfIoServiceRemove(devNodeExt->ioService); + devNodeExt->ioService = NULL; + } + + // remove inner service published by base + return HdfDeviceNodeRemoveService(devNode); +} + static void DeviceNodeExtConstruct(struct DeviceNodeExt *inst) { struct IDeviceNode *nodeIf = (struct IDeviceNode *)inst; if (nodeIf != NULL) { HdfDeviceNodeConstruct(&inst->super); nodeIf->PublishService = DeviceNodeExtPublishService; + nodeIf->RemoveService = DeviceNodeExtRemoveService; } } +static void DeviceNodeExtDestruct(struct DeviceNodeExt *devnode) +{ + if (DeviceNodeExtRemoveService(&devnode->super) != HDF_SUCCESS) { + HDF_LOGE("failed to remove serivce"); + } + HdfDeviceNodeDestruct(&devnode->super); +} + struct HdfObject *DeviceNodeExtCreate() { - struct DeviceNodeExt *instance = - (struct DeviceNodeExt *)OsalMemCalloc(sizeof(struct DeviceNodeExt)); + struct DeviceNodeExt *instance = (struct DeviceNodeExt *)OsalMemCalloc(sizeof(struct DeviceNodeExt)); if (instance != NULL) { DeviceNodeExtConstruct(instance); instance->ioService = NULL; @@ -113,13 +134,9 @@ struct HdfObject *DeviceNodeExtCreate() void DeviceNodeExtRelease(struct HdfObject *object) { - struct DeviceNodeExt *instance = (struct DeviceNodeExt *)object; - if (instance != NULL) { - if (instance->ioService != NULL) { - HdfIoServiceRemove(instance->ioService); - } - HdfDeviceNodeDestruct(&instance->super); - OsalMemFree(instance); + struct DeviceNodeExt *devnode = (struct DeviceNodeExt *)object; + if (devnode != NULL) { + DeviceNodeExtDestruct(devnode); + OsalMemFree(devnode); } } - diff --git a/core/common/src/load_driver_entry.c b/core/common/src/load_driver_entry.c deleted file mode 100644 index 9a42ecbdc2b7c98342481ec1d0f2758be1c5f73d..0000000000000000000000000000000000000000 --- a/core/common/src/load_driver_entry.c +++ /dev/null @@ -1,67 +0,0 @@ -/* - * 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_driver_loader.h" -#include "hdf_log.h" -#include "osal_mem.h" - -static struct HdfDriverEntry *HdfDriverEntryConstruct(int32_t *driverCount) -{ - int i; - *driverCount = (int32_t)(((uint8_t *)(HDF_DRIVER_END()) - (uint8_t *)(HDF_DRIVER_BEGIN())) / sizeof(size_t)); - if (*driverCount <= 0) { - HDF_LOGE("%s: failed to hdf get device counts", __func__); - return NULL; - } - struct HdfDriverEntry *driverEntry = OsalMemCalloc(*driverCount * sizeof(struct HdfDriverEntry)); - if (driverEntry == NULL) { - HDF_LOGE("%s: failed to alloc driver entry mem", __func__); - *driverCount = 0; - return NULL; - } - size_t *addrBegin = (size_t *)(HDF_DRIVER_BEGIN()); - for (i = 0; i < *driverCount; i++) { - driverEntry[i] = *(struct HdfDriverEntry *)(*addrBegin); - addrBegin++; - } - return driverEntry; -} - -struct HdfDriverEntry *HdfDriverLoaderGetDriverEntry(const struct HdfDeviceInfo *deviceInfo) -{ - int i; - if ((deviceInfo == NULL) || (deviceInfo->moduleName == NULL) || (deviceInfo->svcName == NULL)) { - HDF_LOGE("%s: failed to get device entry, input deviceInfo is NULL", __func__); - return NULL; - } - static struct HdfDriverEntry *driverEntry = NULL; - static int32_t driverCount = 0; - if (driverEntry == NULL) { - driverEntry = HdfDriverEntryConstruct(&driverCount); - if (driverEntry == NULL) { - HDF_LOGE("%s: failed to construct driver entry", __func__); - return NULL; - } - } - for (i = 0; i < driverCount; i++) { - if (driverEntry == NULL) { - HDF_LOGE("%s: driver entry is null", __func__); - return NULL; - } - if (driverEntry[i].moduleName == NULL) { - HDF_LOGE("%s: driver entry module name is null", __func__); - continue; - } - if (strcmp(deviceInfo->moduleName, driverEntry[i].moduleName) == 0) { - return &driverEntry[i]; - } - } - HDF_LOGE("failed to get device entry %s", deviceInfo->svcName); - return NULL; -} - diff --git a/core/host/include/devhost_service.h b/core/host/include/devhost_service.h index eb7347eef9363e207d75d864b6e786bcc291dbd4..8ddba0ce75209d2a4e96c589914bc3a14263454c 100644 --- a/core/host/include/devhost_service.h +++ b/core/host/include/devhost_service.h @@ -27,7 +27,7 @@ struct DevHostService { void DevHostServiceConstruct(struct DevHostService *service); void DevHostServiceDestruct(struct DevHostService *service); int DevHostServiceAddDevice(struct IDevHostService *inst, const struct HdfDeviceInfo *deviceInfo); -int DevHostServiceDelDevice(struct IDevHostService *inst, const struct HdfDeviceInfo *deviceInfo); +int DevHostServiceDelDevice(struct IDevHostService *inst, devid_t devId); struct IDevHostService *DevHostServiceNewInstance(uint16_t hostId, const char *hostName); void DevHostServiceFreeInstance(struct IDevHostService *service); struct HdfObject *DevHostServiceCreate(void); diff --git a/core/host/include/devmgr_service_clnt.h b/core/host/include/devmgr_service_clnt.h index 87216668fade2f27a7ea7a9bbbd92017f39cc3f3..d5aecee85e3f44d8e7b5abe6a4514dd7a1d079c9 100644 --- a/core/host/include/devmgr_service_clnt.h +++ b/core/host/include/devmgr_service_clnt.h @@ -19,7 +19,8 @@ struct DevmgrServiceClnt { struct DevmgrServiceClnt *DevmgrServiceClntGetInstance(void); void DevmgrServiceClntFreeInstance(struct DevmgrServiceClnt *inst); -int DevmgrServiceClntAttachDevice(const struct HdfDeviceInfo *deviceInfo, struct IHdfDeviceToken *deviceToken); +int DevmgrServiceClntAttachDevice(struct IHdfDeviceToken *deviceToken); +int DevmgrServiceClntDetachDevice(devid_t devid); int DevmgrServiceClntAttachDeviceHost(uint16_t hostId, struct IDevHostService *hostService); #endif /* DEVMGR_SERVICE_CLIENT_H */ diff --git a/core/host/include/devsvc_manager_clnt.h b/core/host/include/devsvc_manager_clnt.h index ec7f7bec7a6a1502e694a7d72d2ac5296b00bf90..34c748069ac7d63a78042d4800e4bb7dfe2b015b 100644 --- a/core/host/include/devsvc_manager_clnt.h +++ b/core/host/include/devsvc_manager_clnt.h @@ -17,11 +17,12 @@ struct DevSvcManagerClnt { struct DevSvcManagerClnt *DevSvcManagerClntGetInstance(void); struct HdfDeviceObject *DevSvcManagerClntGetDeviceObject(const char *svcName); -int DevSvcManagerClntAddService(const char *svcName, struct HdfDeviceObject *service); +int DevSvcManagerClntAddService(const char *svcName, uint16_t devClass, + struct HdfDeviceObject *service, const char *servinfo); +int DevSvcManagerClntUpdateService(const char *svcName, uint16_t devClass, + struct HdfDeviceObject *service, const char *servinfo); void DevSvcManagerClntRemoveService(const char *svcName); int DevSvcManagerClntSubscribeService(const char *svcName, struct SubscriberCallback callback); int DevSvcManagerClntUnsubscribeService(const char *svcName); -struct HdfDeviceObject *HdfRegisterDevice(const char *moduleName, const char *serviceName, const void *privateData); -void HdfUnregisterDevice(const char *moduleName, const char *serviceName); #endif /* DEVSVC_MANAGER_CLNT_H */ diff --git a/core/host/include/hdf_device.h b/core/host/include/hdf_device.h index 25e2a065077b5426a1c2b4519d46d20a3e62edf2..a61d784b42345eb909924555999dcf0de1bc57ba 100644 --- a/core/host/include/hdf_device.h +++ b/core/host/include/hdf_device.h @@ -9,35 +9,55 @@ #ifndef HDF_DEVICE_H #define HDF_DEVICE_H -#include "devhost_service.h" -#include "device_token_if.h" #include "hdf_device_desc.h" -#include "hdf_object.h" -#include "hdf_service_observer.h" #include "hdf_dlist.h" -#include "osal_mutex.h" +#include "hdf_object.h" + +/* + * -----------------+----------------+----------------+----------------+ + * | BYTE | BYTE | BYTE | BYTE | + * +---------------------------------+---------------------------------+ + * | host id | device id | device node id | + * -----------------+---------------------------------+----------------+ + */ +typedef uint32_t devid_t; + +#define HOSTID_BITS 8 +#define DEVICEID_BITS 16 +#define DEVNODEID_BITS 8 +#define DEVNODEID_MASK ((1 << DEVNODEID_BITS) - 1) +#define DEVICEID_MASK ((1 << DEVICEID_BITS) - 1) + +#define HOSTID(devid) (devid >> (DEVICEID_BITS + DEVNODEID_BITS)) +#define DEVICEID(devid) ((devid >> DEVNODEID_BITS) & DEVICEID_MASK) +#define DEVNODEID(devid) (devid & DEVNODEID_MASK) + +#define MK_DEVID(hostId, deviceId, devnodeId) \ + (hostId << (DEVICEID_BITS + DEVNODEID_BITS) | deviceId << DEVNODEID_BITS | devnodeId) struct HdfDeviceNode; struct IHdfDevice { struct HdfObject object; - int (*Attach)(struct IHdfDevice *, struct HdfDeviceNode *); - void (*Detach)(struct IHdfDevice *, struct HdfDeviceNode *); + int (*Attach)(struct IHdfDevice *device, struct HdfDeviceNode *deviceNode); + int (*Detach)(struct IHdfDevice *device, struct HdfDeviceNode *deviceNode); + struct HdfDeviceNode *(*GetDeviceNode)(struct IHdfDevice *device, devid_t devid); + int (*DetachWithDevid)(struct IHdfDevice *device, devid_t devid); }; struct HdfDevice { struct IHdfDevice super; struct DListHead node; struct DListHead devNodes; - uint16_t deviceId; - uint16_t hostId; + devid_t deviceId; + uint16_t devidIndex; }; +int HdfDeviceDetach(struct IHdfDevice *devInst, struct HdfDeviceNode *devNode); void HdfDeviceConstruct(struct HdfDevice *device); void HdfDeviceDestruct(struct HdfDevice *device); struct HdfObject *HdfDeviceCreate(void); void HdfDeviceRelease(struct HdfObject *object); struct HdfDevice *HdfDeviceNewInstance(void); void HdfDeviceFreeInstance(struct HdfDevice *device); -void HdfDeviceDelete(struct HdfSListNode *deviceEntry); #endif /* HDF_DEVICE_H */ diff --git a/core/host/include/hdf_device_node.h b/core/host/include/hdf_device_node.h index 475158eada8f93249a2fd0a333b4eefa10b5fe0f..c0e5a034f8a1dbe6d0a66c1af36f8185a5c4c23b 100644 --- a/core/host/include/hdf_device_node.h +++ b/core/host/include/hdf_device_node.h @@ -13,6 +13,7 @@ #include "hdf_device_info.h" #include "hdf_device_desc.h" #include "hdf_dlist.h" +#include "hdf_driver.h" #include "hdf_pm.h" struct HdfDeviceNode; @@ -20,8 +21,10 @@ struct DevHostService; struct IDeviceNode { struct HdfObject object; - int (*PublishService)(struct HdfDeviceNode *, const char *); - int (*LaunchNode)(struct HdfDeviceNode *, struct IHdfDevice *); + int (*PublishService)(struct HdfDeviceNode *devNode); + int (*RemoveService)(struct HdfDeviceNode *devNode); + int (*LaunchNode)(struct HdfDeviceNode *devNode); + void (*UnlaunchNode)(struct HdfDeviceNode *devNode); }; struct HdfDeviceNode { @@ -31,20 +34,35 @@ struct HdfDeviceNode { struct DevHostService *hostService; struct HdfDeviceObject deviceObject; struct IHdfDeviceToken *token; - struct HdfDriverEntry *driverEntry; - const struct HdfDeviceInfo *deviceInfo; + struct HdfDriver *driver; + struct HdfDevice *device; + char *servName; + const char *servInfo; + char *driverName; + devid_t devId; + uint16_t policy; + uint16_t permission; + uint8_t devStatus; + bool servStatus; +}; + +enum DevNodeStaus { + DEVNODE_NONE = 0, + DEVNODE_INITED, + DEVNODE_LAUNCHED, }; int HdfDeviceNodeAddPowerStateListener( struct HdfDeviceNode *devNode, const struct IPowerEventListener *listener); void HdfDeviceNodeRemovePowerStateListener( struct HdfDeviceNode *devNode, const struct IPowerEventListener *listener); -void HdfDeviceNodeConstruct(struct HdfDeviceNode *service); -void HdfDeviceNodeDestruct(struct HdfDeviceNode *service); -struct HdfDeviceNode *HdfDeviceNodeNewInstance(void); -void HdfDeviceNodeFreeInstance(struct HdfDeviceNode *service); +void HdfDeviceNodeConstruct(struct HdfDeviceNode *devNode); +void HdfDeviceNodeDestruct(struct HdfDeviceNode *devNode); +struct HdfDeviceNode *HdfDeviceNodeNewInstance(const struct HdfDeviceInfo *deviceInfo, struct HdfDriver *driver); +void HdfDeviceNodeFreeInstance(struct HdfDeviceNode *devNode); void HdfDeviceNodeDelete(struct HdfDeviceNode *devNode); -int HdfDeviceNodePublishPublicService(struct HdfDeviceNode *service, const char *svcName); -void HdfDeviceNodeReclaimService(const char *svcName); +int HdfDeviceNodePublishPublicService(struct HdfDeviceNode *devNode); +int HdfDeviceNodeRemoveService(struct HdfDeviceNode *devNode); +int DeviveDriverBind(struct HdfDeviceNode *devNode); #endif /* HDF_DEVICE_NODE_H */ diff --git a/core/host/include/hdf_device_object.h b/core/host/include/hdf_device_object.h index ec194e465170541640a62747c20cd6990ae9f9ec..8c52698a97bc4743817f351487979708d7d3358f 100644 --- a/core/host/include/hdf_device_object.h +++ b/core/host/include/hdf_device_object.h @@ -12,5 +12,13 @@ #include "hdf_device_desc.h" void HdfDeviceObjectConstruct(struct HdfDeviceObject *deviceObject); - +struct HdfDeviceObject *HdfDeviceObjectAlloc(struct HdfDeviceObject *parent, const char *driverName); +void HdfDeviceObjectRelease(struct HdfDeviceObject *deviceObject); +int HdfDeviceObjectRegister(struct HdfDeviceObject *deviceObject); +int HdfDeviceObjectUnRegister(struct HdfDeviceObject *deviceObject); +int HdfDeviceObjectPublishService(struct HdfDeviceObject *deviceObject, + const char *servName, uint8_t policy, uint32_t perm); +int HdfRemoveService(struct HdfDeviceObject *deviceObject); +int HdfDeviceObjectSetServInfo(struct HdfDeviceObject *dev, const char *info); +int HdfDeviceObjectUpdate(struct HdfDeviceObject *dev); #endif /* HDF_DEVICE_OBJECT_H */ diff --git a/core/host/include/hdf_driver_loader.h b/core/host/include/hdf_driver_loader.h index 56048807b6c75b8e75bb24bfa335601afdccf002..e22d29c2eea55a9678dd6fac6e3b9f4edbc93811 100644 --- a/core/host/include/hdf_driver_loader.h +++ b/core/host/include/hdf_driver_loader.h @@ -15,9 +15,8 @@ struct IDriverLoader { struct HdfObject object; - struct HdfDriverEntry *(*GetDriverEntry)(const struct HdfDeviceInfo *deviceInfo); - struct HdfDeviceNode *(*LoadNode)(struct IDriverLoader *, const struct HdfDeviceInfo *deviceInfo); - void (*UnLoadNode)(struct IDriverLoader *, const struct HdfDeviceInfo *deviceInfo); + struct HdfDriver *(*GetDriver)(const char *driverName); + void (*ReclaimDriver)(struct HdfDriver *driver); }; struct HdfDriverLoader { @@ -28,7 +27,7 @@ struct HdfObject *HdfDriverLoaderCreate(void); void HdfDriverLoaderConstruct(struct HdfDriverLoader *inst); void HdfDriverLoaderRelease(struct HdfObject *object); struct IDriverLoader *HdfDriverLoaderGetInstance(void); -struct HdfDriverEntry *HdfDriverLoaderGetDriverEntry(const struct HdfDeviceInfo *deviceInfo); +struct HdfDriver *HdfDriverLoaderGetDriver(const char *moduleName); struct HdfDeviceNode *HdfDriverLoaderLoadNode( struct IDriverLoader *loader, const struct HdfDeviceInfo *deviceInfo); void HdfDriverLoaderUnLoadNode(struct IDriverLoader *loader, const struct HdfDeviceInfo *deviceInfo); diff --git a/core/host/include/hdf_observer_record.h b/core/host/include/hdf_observer_record.h index a8bcbd93f4ff9b5028dc8b48b2fde03349c00b58..7e63ab82cf4f6d863c408f675edddafbee0dd7cf 100644 --- a/core/host/include/hdf_observer_record.h +++ b/core/host/include/hdf_observer_record.h @@ -9,6 +9,7 @@ #ifndef HDF_OBSERVER_RECORD_H #define HDF_OBSERVER_RECORD_H +#include "hdf_device.h" #include "hdf_object.h" #include "hdf_slist.h" #include "osal_mutex.h" @@ -17,18 +18,17 @@ struct HdfServiceObserverRecord { struct HdfSListNode entry; uint32_t serviceKey; uint16_t policy; - uint32_t matchId; + devid_t devId; struct OsalMutex obsRecMutex; struct HdfSList subscribers; struct HdfObject *publisher; }; -uint32_t HdfMakeHardwareId(uint16_t hostId, uint16_t deviceId); struct HdfServiceObserverRecord *HdfServiceObserverRecordObtain(uint32_t serviceKey); void HdfServiceObserverRecordRecycle(struct HdfServiceObserverRecord *record); bool HdfServiceObserverRecordCompare(struct HdfSListNode *listEntry, uint32_t serviceKey); void HdfServiceObserverRecordNotifySubscribers( - struct HdfServiceObserverRecord *record, uint32_t matchId, uint16_t policy); + struct HdfServiceObserverRecord *record, devid_t devid, uint16_t policy); void HdfServiceObserverRecordDelete(struct HdfSListNode *listEntry); #endif /* HDF_OBSERVER_RECORD_H */ diff --git a/core/host/include/hdf_pm_reg.h b/core/host/include/hdf_pm_reg.h new file mode 100755 index 0000000000000000000000000000000000000000..f065a46732ed03fc4365c405c483f380de25ab97 --- /dev/null +++ b/core/host/include/hdf_pm_reg.h @@ -0,0 +1,22 @@ +/* + * Copyright (c) 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_PM_REG_H +#define HDF_PM_REG_H + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +int DevMgrPmRegister(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* HDF_PM_REG_H */ diff --git a/core/host/include/hdf_power_manager.h b/core/host/include/hdf_power_manager.h new file mode 100755 index 0000000000000000000000000000000000000000..2ed3cdb3f6fbd885b0b0259b215174927245ffb6 --- /dev/null +++ b/core/host/include/hdf_power_manager.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 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_POWER_MANAGER_H +#define HDF_POWER_MANAGER_H + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#include "hdf_task_queue.h" +#include "power_state_token.h" + +typedef enum { + HDF_PM_REQUEST_ACQUIRE, + HDF_PM_REQUEST_RELEASE, +} HDF_PM_REQUEST_TYPE; + +struct HdfPmRequest { + struct PowerStateToken *token; + HDF_PM_REQUEST_TYPE pmType; + struct HdfTaskType task; +}; + +int32_t HdfPowerManagerInit(void); +void HdfPmTaskPut(struct PowerStateToken *powerToken, HDF_PM_REQUEST_TYPE type); +void HdfPowerManagerExit(void); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* HDF_POWER_MANAGER_H */ diff --git a/core/host/include/hdf_service_subscriber.h b/core/host/include/hdf_service_subscriber.h index 2d2528b0d5b3f51f91749b1f4729bde45f798220..29ba7477ba7a107bf0905e03f90f4e5db7003c98 100644 --- a/core/host/include/hdf_service_subscriber.h +++ b/core/host/include/hdf_service_subscriber.h @@ -9,13 +9,14 @@ #ifndef HDF_SERVICE_SUBSCRIBER_H #define HDF_SERVICE_SUBSCRIBER_H +#include "hdf_device.h" #include "hdf_device_desc.h" #include "hdf_slist.h" struct HdfServiceSubscriber { struct HdfSListNode entry; uint32_t state; - uint32_t matchId; + uint32_t devId; struct SubscriberCallback callback; }; @@ -24,7 +25,7 @@ enum { HDF_SUBSCRIBER_STATE_READY }; -struct HdfServiceSubscriber *HdfServiceSubscriberObtain(struct SubscriberCallback callback, uint32_t matchId); +struct HdfServiceSubscriber *HdfServiceSubscriberObtain(struct SubscriberCallback callback, devid_t devid); void HdfServiceSubscriberRecycle(struct HdfServiceSubscriber *subscriber); void HdfServiceSubscriberDelete(struct HdfSListNode *listEntry); diff --git a/core/host/src/devhost_service.c b/core/host/src/devhost_service.c index bd0c84135221790a15807a06461559078de79168..ff86228ba9a61c62ee8826164f5521eb6558a53b 100644 --- a/core/host/src/devhost_service.c +++ b/core/host/src/devhost_service.c @@ -10,6 +10,7 @@ #include "devmgr_service_clnt.h" #include "devsvc_manager_clnt.h" #include "hdf_base.h" +#include "hdf_driver.h" #include "hdf_driver_loader.h" #include "hdf_log.h" #include "hdf_object_manager.h" @@ -20,30 +21,29 @@ static struct HdfDevice *DevHostServiceFindDevice(struct DevHostService *hostService, uint16_t deviceId) { - struct HdfDevice *deviceNode = NULL; + struct HdfDevice *device = NULL; if (hostService == NULL) { HDF_LOGE("failed to find driver, hostService is null"); return NULL; } - DLIST_FOR_EACH_ENTRY(deviceNode, &hostService->devices, struct HdfDevice, node) { - if (deviceNode->deviceId == deviceId) { - return deviceNode; + DLIST_FOR_EACH_ENTRY(device, &hostService->devices, struct HdfDevice, node) { + if (DEVICEID(device->deviceId) == deviceId) { + return device; } } return NULL; } -static void DevHostServiceFreeDevice(struct DevHostService *hostService, uint16_t deviceId) +static void DevHostServiceFreeDevice(struct DevHostService *hostService, struct HdfDevice *device) { - struct HdfDevice *device = DevHostServiceFindDevice(hostService, deviceId); if (device != NULL) { DListRemove(&device->node); HdfDeviceFreeInstance(device); } } -static struct HdfDevice *DevHostServiceGetDevice(struct DevHostService *inst, uint16_t deviceId) +static struct HdfDevice *DevHostServiceQueryOrAddDevice(struct DevHostService *inst, uint16_t deviceId) { struct HdfDevice *device = DevHostServiceFindDevice(inst, deviceId); if (device == NULL) { @@ -52,8 +52,7 @@ static struct HdfDevice *DevHostServiceGetDevice(struct DevHostService *inst, ui HDF_LOGE("Dev host service failed to create driver instance"); return NULL; } - device->hostId = inst->hostId; - device->deviceId = deviceId; + device->deviceId = MK_DEVID(inst->hostId, deviceId, 0); DListInsertHead(&device->node, &inst->devices); } return device; @@ -64,78 +63,86 @@ int DevHostServiceAddDevice(struct IDevHostService *inst, const struct HdfDevice int ret = HDF_FAILURE; struct HdfDevice *device = NULL; struct HdfDeviceNode *devNode = NULL; + struct HdfDriver *driver = NULL; struct DevHostService *hostService = CONTAINER_OF(inst, struct DevHostService, super); struct IDriverLoader *driverLoader = HdfDriverLoaderGetInstance(); - if (inst == NULL || deviceInfo == NULL || driverLoader == NULL || driverLoader->LoadNode == NULL) { + if (inst == NULL || deviceInfo == NULL || driverLoader == NULL || driverLoader->GetDriver == NULL) { HDF_LOGE("failed to add device, input param is null"); return ret; } - device = DevHostServiceGetDevice(hostService, deviceInfo->deviceId); + device = DevHostServiceQueryOrAddDevice(hostService, DEVICEID(deviceInfo->deviceId)); if (device == NULL || device->super.Attach == NULL) { ret = HDF_DEV_ERR_NO_DEVICE; goto error; } + devNode = device->super.GetDeviceNode(&device->super, deviceInfo->deviceId); + if (devNode != NULL) { + HDF_LOGE("failed to add device %d, device already exist", deviceInfo->deviceId); + return HDF_ERR_DEVICE_BUSY; + } + driver = driverLoader->GetDriver(deviceInfo->moduleName); + if (driver == NULL) { + ret = HDF_DEV_ERR_NODATA; + goto error; + } - devNode = driverLoader->LoadNode(driverLoader, deviceInfo); + devNode = HdfDeviceNodeNewInstance(deviceInfo, driver); if (devNode == NULL) { - ret = HDF_DEV_ERR_NO_DEVICE_SERVICE; - goto error; + driverLoader->ReclaimDriver(driver); + return HDF_DEV_ERR_NO_MEMORY; } + devNode->hostService = hostService; + devNode->device = device; + devNode->driver = driver; ret = device->super.Attach(&device->super, devNode); if (ret != HDF_SUCCESS) { + HdfDeviceNodeFreeInstance(devNode); goto error; } return HDF_SUCCESS; error: - DevHostServiceFreeDevice(hostService, device->deviceId); - return ret; -} - -static struct HdfDeviceNode *DevHostServiceSeparateDeviceNode(struct DListHead *deviceNodes, - const struct HdfDeviceInfo *deviceInfo) -{ - struct HdfDeviceNode *deviceNode = NULL; - DLIST_FOR_EACH_ENTRY(deviceNode, deviceNodes, struct HdfDeviceNode, entry) { - if (strcmp(deviceNode->deviceInfo->svcName, deviceInfo->svcName) == 0 && - strcmp(deviceNode->deviceInfo->moduleName, deviceInfo->moduleName) == 0) { - DListRemove(&deviceNode->entry); - return deviceNode; - } + if (DListIsEmpty(&device->devNodes)) { + DevHostServiceFreeDevice(hostService, device); } - return NULL; + + return ret; } -int DevHostServiceDelDevice(struct IDevHostService *inst, const struct HdfDeviceInfo *deviceInfo) +int DevHostServiceDelDevice(struct IDevHostService *inst, devid_t devId) { struct HdfDevice *device = NULL; struct DevHostService *hostService = (struct DevHostService *)inst; - struct IDriverLoader *driverLoader = HdfDriverLoaderGetInstance(); - - if ((deviceInfo == NULL) || (driverLoader == NULL) || (driverLoader->UnLoadNode == NULL)) { - HDF_LOGE("failed to del device, input param is null"); - return HDF_FAILURE; - } + struct HdfDeviceNode *devNode = NULL; - device = DevHostServiceFindDevice(hostService, deviceInfo->deviceId); + device = DevHostServiceFindDevice(hostService, DEVICEID(devId)); if (device == NULL) { HDF_LOGW("failed to del device, device is not exist"); return HDF_SUCCESS; } - driverLoader->UnLoadNode(driverLoader, deviceInfo); - struct HdfDeviceNode *devNode = DevHostServiceSeparateDeviceNode(&device->devNodes, deviceInfo); - if (device->super.Detach != NULL) { - device->super.Detach(&device->super, devNode); - } else { - HdfDeviceNodeFreeInstance(devNode); + devNode = device->super.GetDeviceNode(&device->super, devId); + if (devNode == NULL) { + HDF_LOGI("failed to del device %u, not exist", devId); + return HDF_DEV_ERR_NO_DEVICE; + } + + if (device->super.Detach == NULL) { + HDF_LOGE("failed to del device %u, invalid device", devId); + return HDF_ERR_INVALID_OBJECT; } - DevSvcManagerClntRemoveService(deviceInfo->svcName); + + if (device->super.Detach(&device->super, devNode) != HDF_SUCCESS) { + HDF_LOGE("failed to detach device %u", devId); + return HDF_FAILURE; + } + HdfDeviceNodeFreeInstance(devNode); + if (DListIsEmpty(&device->devNodes)) { - DevHostServiceFreeDevice(hostService, device->deviceId); + DevHostServiceFreeDevice(hostService, device); } return HDF_SUCCESS; } @@ -162,7 +169,7 @@ static int ApplyDevicesPowerState(struct HdfDevice *device, uint32_t state) if (deviceNode->powerToken != NULL) { ret = PowerStateChange(deviceNode->powerToken, state); if (ret != HDF_SUCCESS) { - HDF_LOGE("device %s failed to resume(%d)", deviceNode->driverEntry->moduleName, state); + HDF_LOGE("device %s failed to resume(%d)", deviceNode->driver->entry->moduleName, state); } } } @@ -171,7 +178,7 @@ static int ApplyDevicesPowerState(struct HdfDevice *device, uint32_t state) if (deviceNode->powerToken != NULL) { ret = PowerStateChange(deviceNode->powerToken, state); if (ret != HDF_SUCCESS) { - HDF_LOGE("device %s failed to suspend(%d)", deviceNode->driverEntry->moduleName, state); + HDF_LOGE("device %s failed to suspend(%d)", deviceNode->driver->entry->moduleName, state); } } } @@ -223,12 +230,12 @@ void DevHostServiceConstruct(struct DevHostService *service) void DevHostServiceDestruct(struct DevHostService *service) { + struct HdfDevice *device = NULL; + struct HdfDevice *tmp = NULL; if (service == NULL) { return; } - struct HdfDevice *device = NULL; - struct HdfDevice *tmp = NULL; DLIST_FOR_EACH_ENTRY_SAFE(device, tmp, &service->devices, struct HdfDevice, node) { HdfDeviceFreeInstance(device); } diff --git a/core/host/src/devmgr_service_clnt.c b/core/host/src/devmgr_service_clnt.c index 378ec5f59755f9decf580e252ab65c62118afd2d..6788fa4485bb861bf1494e368e9fde329ab7cbbf 100644 --- a/core/host/src/devmgr_service_clnt.c +++ b/core/host/src/devmgr_service_clnt.c @@ -31,7 +31,7 @@ int DevmgrServiceClntAttachDeviceHost(uint16_t hostId, struct IDevHostService *h return devMgrSvcIf->AttachDeviceHost(devMgrSvcIf, hostId, hostService); } -int DevmgrServiceClntAttachDevice(const struct HdfDeviceInfo *deviceInfo, struct IHdfDeviceToken *deviceToken) +int DevmgrServiceClntAttachDevice(struct IHdfDeviceToken *deviceToken) { struct IDevmgrService *devMgrSvcIf = NULL; struct DevmgrServiceClnt *inst = DevmgrServiceClntGetInstance(); @@ -45,7 +45,23 @@ int DevmgrServiceClntAttachDevice(const struct HdfDeviceInfo *deviceInfo, struct HDF_LOGE("devmgr client failed to attach device, dmsOps->AttachDevice is nul"); return HDF_FAILURE; } - return devMgrSvcIf->AttachDevice(devMgrSvcIf, deviceInfo, deviceToken); + return devMgrSvcIf->AttachDevice(devMgrSvcIf, deviceToken); +} + +int DevmgrServiceClntDetachDevice(devid_t devid) +{ + struct IDevmgrService *devMgrSvcIf = NULL; + struct DevmgrServiceClnt *inst = DevmgrServiceClntGetInstance(); + if (inst == NULL || inst->devMgrSvcIf == NULL) { + HDF_LOGE("devmgr client failed to deatch device, inst is null"); + return HDF_FAILURE; + } + + devMgrSvcIf = inst->devMgrSvcIf; + if (devMgrSvcIf->DetachDevice == NULL) { + return HDF_FAILURE; + } + return devMgrSvcIf->DetachDevice(devMgrSvcIf, devid); } struct DevmgrServiceClnt *DevmgrServiceClntGetInstance() @@ -64,4 +80,3 @@ void DevmgrServiceClntFreeInstance(struct DevmgrServiceClnt *inst) inst->devMgrSvcIf = NULL; } } - diff --git a/core/host/src/devsvc_manager_clnt.c b/core/host/src/devsvc_manager_clnt.c index 479839b941d54aa39ac819bcdb3383c98ad39033..e3643a05c31f3184710024a5e1a01e5a3691ac8c 100644 --- a/core/host/src/devsvc_manager_clnt.c +++ b/core/host/src/devsvc_manager_clnt.c @@ -7,40 +7,65 @@ */ #include "devsvc_manager_clnt.h" -#include "devmgr_service.h" -#include "devsvc_manager.h" -#include "hdf_attribute_manager.h" -#include "hdf_base.h" #include "hdf_log.h" #include "hdf_object_manager.h" #define HDF_LOG_TAG devsvc_manager_clnt -int DevSvcManagerClntAddService(const char *svcName, struct HdfDeviceObject *service) +int DevSvcManagerClntAddService(const char *svcName, uint16_t devClass, + struct HdfDeviceObject *service, const char *servinfo) { struct DevSvcManagerClnt *devSvcMgrClnt = DevSvcManagerClntGetInstance(); + struct IDevSvcManager *serviceManager = NULL; if (devSvcMgrClnt == NULL) { HDF_LOGE("failed to add service, client is null"); return HDF_FAILURE; } + if (devClass >= DEVICE_CLASS_MAX) { + HDF_LOGE("failed to add service, invalid class"); + return HDF_FAILURE; + } - struct IDevSvcManager *serviceManager = devSvcMgrClnt->devSvcMgrIf; + serviceManager = devSvcMgrClnt->devSvcMgrIf; if (serviceManager == NULL || serviceManager->AddService == NULL) { HDF_LOGE("serviceManager AddService function is null"); return HDF_FAILURE; } - return serviceManager->AddService(serviceManager, svcName, service); + return serviceManager->AddService(serviceManager, svcName, devClass, service, servinfo); +} + +int DevSvcManagerClntUpdateService(const char *svcName, uint16_t devClass, + struct HdfDeviceObject *service, const char *servinfo) +{ + struct DevSvcManagerClnt *devSvcMgrClnt = DevSvcManagerClntGetInstance(); + struct IDevSvcManager *serviceManager = NULL; + if (devSvcMgrClnt == NULL) { + HDF_LOGE("failed to add service, client is null"); + return HDF_FAILURE; + } + if (devClass >= DEVICE_CLASS_MAX) { + HDF_LOGE("failed to add service, invalid class"); + return HDF_FAILURE; + } + + serviceManager = devSvcMgrClnt->devSvcMgrIf; + if (serviceManager == NULL || serviceManager->UpdateService == NULL) { + HDF_LOGE("serviceManager UpdateService function is null"); + return HDF_FAILURE; + } + return serviceManager->UpdateService(serviceManager, svcName, devClass, service, servinfo); } const struct HdfObject *DevSvcManagerClntGetService(const char *svcName) { struct DevSvcManagerClnt *devSvcMgrClnt = DevSvcManagerClntGetInstance(); + struct IDevSvcManager *serviceManager = NULL; if (devSvcMgrClnt == NULL) { HDF_LOGE("failed to get service, client is null"); return NULL; } - struct IDevSvcManager *serviceManager = devSvcMgrClnt->devSvcMgrIf; + serviceManager = devSvcMgrClnt->devSvcMgrIf; if (serviceManager == NULL || serviceManager->GetService == NULL) { HDF_LOGE("serviceManager GetService function is null"); return NULL; @@ -51,12 +76,13 @@ const struct HdfObject *DevSvcManagerClntGetService(const char *svcName) struct HdfDeviceObject *DevSvcManagerClntGetDeviceObject(const char *svcName) { struct DevSvcManagerClnt *devSvcMgrClnt = DevSvcManagerClntGetInstance(); + struct IDevSvcManager *serviceManager = NULL; if (devSvcMgrClnt == NULL) { HDF_LOGE("failed to get device object, client is null"); return NULL; } - struct IDevSvcManager *serviceManager = devSvcMgrClnt->devSvcMgrIf; + serviceManager = devSvcMgrClnt->devSvcMgrIf; if (serviceManager == NULL || serviceManager->GetObject == NULL) { HDF_LOGE("failed to get device object, method not implement"); return NULL; @@ -64,39 +90,16 @@ struct HdfDeviceObject *DevSvcManagerClntGetDeviceObject(const char *svcName) return serviceManager->GetObject(serviceManager, svcName); } -struct HdfDeviceObject *HdfRegisterDevice(const char *moduleName, const char *serviceName, const void *privateData) -{ - int ret; - if (!HdfDeviceListAdd(moduleName, serviceName, privateData)) { - HDF_LOGE("%s device info add failed!", __func__); - return NULL; - } - ret = DevmgrServiceLoadDevice(serviceName); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s load device %s failed!", __func__, serviceName); - HdfDeviceListDel(moduleName, serviceName); - return NULL; - } - return DevSvcManagerClntGetDeviceObject(serviceName); -} - -void HdfUnregisterDevice(const char *moduleName, const char *serviceName) -{ - if (DevmgrServiceUnLoadDevice(serviceName) != HDF_SUCCESS) { - HDF_LOGE("%s:failed to unload device %s !", __func__, serviceName); - } - HdfDeviceListDel(moduleName, serviceName); -} - int DevSvcManagerClntSubscribeService(const char *svcName, struct SubscriberCallback callback) { struct DevSvcManagerClnt *devSvcMgrClnt = DevSvcManagerClntGetInstance(); + struct IDevSvcManager *serviceManager = NULL; if (devSvcMgrClnt == NULL) { HDF_LOGE("failed to subscribe service, client is null"); return HDF_FAILURE; } - struct IDevSvcManager *serviceManager = devSvcMgrClnt->devSvcMgrIf; + serviceManager = devSvcMgrClnt->devSvcMgrIf; if (serviceManager == NULL || serviceManager->SubscribeService == NULL) { HDF_LOGE("failed to subscribe service, method not implement"); return HDF_FAILURE; @@ -107,12 +110,13 @@ int DevSvcManagerClntSubscribeService(const char *svcName, struct SubscriberCall int DevSvcManagerClntUnsubscribeService(const char *svcName) { struct DevSvcManagerClnt *devSvcMgrClnt = DevSvcManagerClntGetInstance(); + struct IDevSvcManager *serviceManager = NULL; if (devSvcMgrClnt == NULL) { HDF_LOGE("failed to unsubscribe service, client is null"); return HDF_FAILURE; } - struct IDevSvcManager *serviceManager = devSvcMgrClnt->devSvcMgrIf; + serviceManager = devSvcMgrClnt->devSvcMgrIf; if (serviceManager == NULL || serviceManager->UnsubscribeService == NULL) { HDF_LOGE("failed to unsubscribe service, method not implement"); return HDF_FAILURE; @@ -123,14 +127,14 @@ int DevSvcManagerClntUnsubscribeService(const char *svcName) void DevSvcManagerClntRemoveService(const char *svcName) { struct DevSvcManagerClnt *devSvcMgrClnt = DevSvcManagerClntGetInstance(); + struct IDevSvcManager *serviceManager = NULL; if (devSvcMgrClnt == NULL) { HDF_LOGE("failed to remove service, devSvcMgrClnt is null"); return; } - struct IDevSvcManager *serviceManager = devSvcMgrClnt->devSvcMgrIf; + serviceManager = devSvcMgrClnt->devSvcMgrIf; if (serviceManager == NULL || serviceManager->RemoveService == NULL) { - HDF_LOGE("failed to remove service, method not implement"); return; } serviceManager->RemoveService(serviceManager, svcName); diff --git a/core/host/src/hdf_device.c b/core/host/src/hdf_device.c index d61036007dacfdc41726ca361f5187fb5182b04a..43487d5fd4aec45d9ec3ca0fb0376ec3d6f5eaed 100644 --- a/core/host/src/hdf_device.c +++ b/core/host/src/hdf_device.c @@ -18,37 +18,120 @@ #define HDF_LOG_TAG hdf_device +static void UpdateDeivceNodeIdIndex(struct HdfDevice *device, devid_t nodeDevid) +{ + if (device->devidIndex < DEVICEID(nodeDevid)) { + device->devidIndex = DEVICEID(nodeDevid); + } +} + +static int AcquireNodeDeivceId(struct HdfDevice *device, devid_t *devid) +{ + if (device->devidIndex >= DEVICEID_MASK) { + return HDF_FAILURE; + } + device->devidIndex++; + *devid = MK_DEVID(HOSTID(device->deviceId), DEVICEID(device->deviceId), device->devidIndex); + + return HDF_SUCCESS; +} + static int HdfDeviceAttach(struct IHdfDevice *devInst, struct HdfDeviceNode *devNode) { + int ret; struct HdfDevice *device = (struct HdfDevice *)devInst; struct IDeviceNode *nodeIf = (struct IDeviceNode *)devNode; + if (device == NULL || nodeIf == NULL || nodeIf->LaunchNode == NULL) { HDF_LOGE("failed to attach device, input params invalid"); return HDF_ERR_INVALID_PARAM; } - DListInsertTail(&devNode->entry, &device->devNodes); - return nodeIf->LaunchNode(devNode, devInst); + + // for dynamic added device node, assign device id here + if (devNode->devId == 0 && AcquireNodeDeivceId(device, &devNode->devId) != HDF_SUCCESS) { + HDF_LOGE("failed to attach device, invalid device id"); + return HDF_ERR_INVALID_PARAM; + } + devNode->token->devid = devNode->devId; + ret = nodeIf->LaunchNode(devNode); + if (ret == HDF_SUCCESS) { + DListInsertTail(&devNode->entry, &device->devNodes); + UpdateDeivceNodeIdIndex(device, devNode->devId); + } + + return ret; +} + +int HdfDeviceDetach(struct IHdfDevice *devInst, struct HdfDeviceNode *devNode) +{ + struct HdfDevice *device = NULL; + if (devInst == NULL || devNode == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + device = CONTAINER_OF(devInst, struct HdfDevice, super); + if (DEVICEID(device->deviceId) != DEVICEID(devNode->devId)) { + HDF_LOGE("%s: device %x detach unknown devnode %x", __func__, device->deviceId, devNode->devId); + return HDF_DEV_ERR_NO_DEVICE; + } + + if (devNode->entry.next != NULL) { + DListRemove(&devNode->entry); + } + if (devNode->super.UnlaunchNode != NULL) { + devNode->super.UnlaunchNode(devNode); + } + + return HDF_SUCCESS; +} + +static struct HdfDeviceNode *HdfDeviceGetDeviceNode(struct IHdfDevice *device, devid_t devid) +{ + struct HdfDeviceNode *devNode = NULL; + struct HdfDevice *dev = CONTAINER_OF(device, struct HdfDevice, super); + DLIST_FOR_EACH_ENTRY(devNode, &dev->devNodes, struct HdfDeviceNode, entry) { + if (devNode->devId == devid) { + return devNode; + }; + } + return NULL; +} + +static int HdfDeviceDetachWithDevid(struct IHdfDevice *device, devid_t devid) +{ + struct HdfDevice *dev = CONTAINER_OF(device, struct HdfDevice, super); + struct HdfDeviceNode *devNode = HdfDeviceGetDeviceNode(device, devid); + if (devNode == NULL) { + HDF_LOGE("detach device node %x not in device %x", devid, dev->deviceId); + return HDF_DEV_ERR_NO_DEVICE; + } + + return HdfDeviceDetach(device, devNode); } void HdfDeviceConstruct(struct HdfDevice *device) { device->super.Attach = HdfDeviceAttach; + device->super.Detach = HdfDeviceDetach; + device->super.DetachWithDevid = HdfDeviceDetachWithDevid; + device->super.GetDeviceNode = HdfDeviceGetDeviceNode; + DListHeadInit(&device->devNodes); } void HdfDeviceDestruct(struct HdfDevice *device) { struct HdfDeviceNode *devNode = NULL; - DLIST_FOR_EACH_ENTRY(devNode, &device->devNodes, struct HdfDeviceNode, entry) { - HdfDeviceNodeDelete(devNode); + struct HdfDeviceNode *tmp = NULL; + DLIST_FOR_EACH_ENTRY_SAFE(devNode, tmp, &device->devNodes, struct HdfDeviceNode, entry) { + HdfDeviceNodeFreeInstance(devNode); } DListHeadInit(&device->devNodes); } struct HdfObject *HdfDeviceCreate() { - struct HdfDevice *device = - (struct HdfDevice *)OsalMemCalloc(sizeof(struct HdfDevice)); + struct HdfDevice *device = (struct HdfDevice *)OsalMemCalloc(sizeof(struct HdfDevice)); if (device != NULL) { HdfDeviceConstruct(device); } @@ -75,13 +158,3 @@ void HdfDeviceFreeInstance(struct HdfDevice *device) HdfObjectManagerFreeObject(&device->super.object); } } - -void HdfDeviceDelete(struct HdfSListNode *listEntry) -{ - if (listEntry != NULL) { - struct HdfDevice *device = (struct HdfDevice *)HDF_SLIST_CONTAINER_OF( - struct HdfSListNode, listEntry, struct HdfDevice, node); - HdfDeviceFreeInstance(device); - } -} - diff --git a/core/host/src/hdf_device_node.c b/core/host/src/hdf_device_node.c index 06f46b43651fa723daeaa9ecb2733d8797743249..5bb1309dfa4c0df14010c4a1b5628d025634b75e 100644 --- a/core/host/src/hdf_device_node.c +++ b/core/host/src/hdf_device_node.c @@ -10,9 +10,13 @@ #include "devhost_service.h" #include "devmgr_service_clnt.h" #include "devsvc_manager_clnt.h" +#include "hcs_tree_if.h" +#include "hdf_attribute_manager.h" #include "hdf_base.h" +#include "hdf_cstring.h" #include "hdf_device_object.h" #include "hdf_device_token.h" +#include "hdf_driver_loader.h" #include "hdf_log.h" #include "hdf_object_manager.h" #include "hdf_observer_record.h" @@ -21,79 +25,99 @@ #define HDF_LOG_TAG device_node -static int HdfDeviceNodePublishLocalService( - struct HdfDeviceNode *devNode, const struct HdfDeviceInfo *deviceInfo) +static int HdfDeviceNodePublishLocalService(struct HdfDeviceNode *devNode) { - uint32_t matchId; - if ((devNode == NULL) || (deviceInfo == NULL)) { + if (devNode == NULL) { HDF_LOGE("failed to publish local service, device is null"); return HDF_FAILURE; } - struct DevHostService *hostService = devNode->hostService; - if (hostService == NULL) { + if (devNode->hostService == NULL) { HDF_LOGE("failed to publish local service, host service is null"); return HDF_FAILURE; } - matchId = HdfMakeHardwareId(deviceInfo->hostId, deviceInfo->deviceId); - return HdfServiceObserverPublishService(&hostService->observer, deviceInfo->svcName, - matchId, deviceInfo->policy, (struct HdfObject *)devNode->deviceObject.service); + return HdfServiceObserverPublishService(&(devNode->hostService->observer), devNode->servName, + devNode->devId, devNode->policy, (struct HdfObject *)devNode->deviceObject.service); } -static int HdfDeviceNodePublishService( - struct HdfDeviceNode *devNode, const struct HdfDeviceInfo *deviceInfo, struct IHdfDevice *device) +static int HdfDeviceNodePublishService(struct HdfDeviceNode *devNode) { - (void)device; int status = HDF_SUCCESS; - if ((deviceInfo->policy == SERVICE_POLICY_NONE) || - ((deviceInfo->svcName != NULL) && (strlen(deviceInfo->svcName) == 0))) { - HDF_LOGI("policy is %d", SERVICE_POLICY_NONE); + struct IDeviceNode *nodeIf = NULL; + if (devNode->policy == SERVICE_POLICY_NONE || + (devNode->servName != NULL && strlen(devNode->servName) == 0)) { return status; } - struct IDeviceNode *nodeIf = &devNode->super; - if ((deviceInfo->policy == SERVICE_POLICY_PUBLIC) || - (deviceInfo->policy == SERVICE_POLICY_CAPACITY)) { + nodeIf = &devNode->super; + if (devNode->policy == SERVICE_POLICY_PUBLIC || devNode->policy == SERVICE_POLICY_CAPACITY) { if (nodeIf->PublishService != NULL) { - status = nodeIf->PublishService(devNode, deviceInfo->svcName); + status = nodeIf->PublishService(devNode); } } if (status == HDF_SUCCESS) { - status = HdfDeviceNodePublishLocalService(devNode, deviceInfo); + status = HdfDeviceNodePublishLocalService(devNode); } return status; } -int HdfDeviceLaunchNode(struct HdfDeviceNode *devNode, struct IHdfDevice *devInst) +int DeviveDriverBind(struct HdfDeviceNode *devNode) { - struct HdfDevice *device = (struct HdfDevice *)devInst; - if (device == NULL || devNode == NULL) { - HDF_LOGE("failed to launch service, device or service is null"); + int ret; + const struct HdfDriverEntry *driverEntry = NULL; + if (devNode == NULL) { return HDF_ERR_INVALID_PARAM; } - struct HdfDriverEntry *driverEntry = devNode->driverEntry; - const struct HdfDeviceInfo *deviceInfo = devNode->deviceInfo; - struct IHdfDeviceToken *deviceToken = NULL; + driverEntry = devNode->driver->entry; + if (devNode->policy == SERVICE_POLICY_PUBLIC || devNode->policy == SERVICE_POLICY_CAPACITY) { + if (driverEntry->Bind == NULL) { + HDF_LOGE("driver %s bind method not implement", driverEntry->moduleName); + devNode->devStatus = DEVNODE_NONE; + return HDF_ERR_INVALID_OBJECT; + } + ret = driverEntry->Bind(&devNode->deviceObject); + if (ret != HDF_SUCCESS) { + HDF_LOGE("bind driver %s failed", driverEntry->moduleName); + return HDF_DEV_ERR_DEV_INIT_FAIL; + } + } - if (deviceInfo == NULL) { - HDF_LOGE("failed to launch service, deviceInfo is null"); + return HDF_SUCCESS; +} + +int HdfDeviceLaunchNode(struct HdfDeviceNode *devNode) +{ + const struct HdfDriverEntry *driverEntry = NULL; + int ret; + if (devNode == NULL) { + HDF_LOGE("failed to launch service, device or service is null"); return HDF_ERR_INVALID_PARAM; } - if ((driverEntry == NULL) || (driverEntry->Init == NULL)) { + HDF_LOGI("launch devnode %s", devNode->servName ? devNode->servName : ""); + driverEntry = devNode->driver->entry; + if (driverEntry == NULL || driverEntry->Init == NULL) { HDF_LOGE("failed to launch service, deviceEntry invalid"); return HDF_ERR_INVALID_PARAM; } - int ret = driverEntry->Init(&devNode->deviceObject); + devNode->devStatus = DEVNODE_LAUNCHED; + + ret = DeviveDriverBind(devNode); + if (ret != HDF_SUCCESS) { + return ret; + } + + ret = driverEntry->Init(&devNode->deviceObject); if (ret != HDF_SUCCESS) { return HDF_DEV_ERR_DEV_INIT_FAIL; } - ret = HdfDeviceNodePublishService(devNode, deviceInfo, devInst); + + ret = HdfDeviceNodePublishService(devNode); if (ret != HDF_SUCCESS) { return HDF_DEV_ERR_PUBLISH_FAIL; } - deviceToken = devNode->token; - ret = DevmgrServiceClntAttachDevice(deviceInfo, deviceToken); + + ret = DevmgrServiceClntAttachDevice(devNode->token); if (ret != HDF_SUCCESS) { return HDF_DEV_ERR_ATTACHDEV_FAIL; } @@ -123,19 +147,63 @@ void HdfDeviceNodeRemovePowerStateListener( devNode->powerToken = NULL; } - -int HdfDeviceNodePublishPublicService(struct HdfDeviceNode *devNode, const char *svcName) +int HdfDeviceNodePublishPublicService(struct HdfDeviceNode *devNode) { - if ((devNode == NULL) || (devNode->deviceObject.service == NULL)) { - HDF_LOGE("failed to publish public service: devNode is NULL"); + int ret; + if (devNode == NULL || devNode->deviceObject.service == NULL) { + HDF_LOGE("failed to publish public service, devNode is NULL"); return HDF_FAILURE; } - return DevSvcManagerClntAddService(svcName, &devNode->deviceObject); + + ret = DevSvcManagerClntAddService(devNode->servName, + devNode->deviceObject.deviceClass, &devNode->deviceObject, devNode->servInfo); + if (ret == HDF_SUCCESS) { + devNode->servStatus = true; + } + + return ret; } -void HdfDeviceNodeReclaimService(const char *svcName) +int HdfDeviceNodeRemoveService(struct HdfDeviceNode *devNode) { - DevSvcManagerClntRemoveService(svcName); + if (devNode != NULL && devNode->servStatus) { + DevSvcManagerClntRemoveService(devNode->servName); + devNode->servStatus = false; + } + + return HDF_SUCCESS; +} + +static void HdfDeviceUnlaunchNode(struct HdfDeviceNode *devNode) +{ + const struct HdfDriverEntry *driverEntry = NULL; + struct IDriverLoader *driverLoader = NULL; + if (devNode == NULL || devNode->devStatus != DEVNODE_LAUNCHED) { + return; + } + + if (devNode->driver != NULL) { + driverEntry = devNode->driver->entry; + } + + if (driverEntry != NULL && driverEntry->Release != NULL) { + driverEntry->Release(&devNode->deviceObject); + } + + if (devNode->servStatus) { + devNode->super.RemoveService(devNode); + } + DevmgrServiceClntDetachDevice(devNode->devId); + + // release driver object or close driver library + driverLoader = HdfDriverLoaderGetInstance(); + if (driverLoader != NULL) { + driverLoader->ReclaimDriver(devNode->driver); + devNode->driver = NULL; + } else { + HDF_LOGE("failed to get driver loader"); + } + devNode->devStatus = DEVNODE_INITED; } void HdfDeviceNodeConstruct(struct HdfDeviceNode *devNode) @@ -146,6 +214,8 @@ void HdfDeviceNodeConstruct(struct HdfDeviceNode *devNode) devNode->token = HdfDeviceTokenNewInstance(); nodeIf->LaunchNode = HdfDeviceLaunchNode; nodeIf->PublishService = HdfDeviceNodePublishPublicService; + nodeIf->RemoveService = HdfDeviceNodeRemoveService; + nodeIf->UnlaunchNode = HdfDeviceUnlaunchNode; } } @@ -154,31 +224,58 @@ void HdfDeviceNodeDestruct(struct HdfDeviceNode *devNode) if (devNode == NULL) { return; } - HdfDeviceTokenFreeInstance(devNode->token); - devNode->token = NULL; - PowerStateTokenFreeInstance(devNode->powerToken); - devNode->powerToken = NULL; -} - -struct HdfDeviceNode *HdfDeviceNodeNewInstance() -{ - return (struct HdfDeviceNode *)HdfObjectManagerGetObject(HDF_OBJECT_ID_DEVICE_SERVICE); -} - -void HdfDeviceNodeFreeInstance(struct HdfDeviceNode *devNode) -{ - HdfObjectManagerFreeObject((struct HdfObject *) devNode); + HDF_LOGI("release devnode %s", devNode->servName); + switch (devNode->devStatus) { + case DEVNODE_LAUNCHED: // fall-through + HdfDeviceUnlaunchNode(devNode); + case DEVNODE_INITED: + HdfDeviceTokenFreeInstance(devNode->token); + devNode->token = NULL; + PowerStateTokenFreeInstance(devNode->powerToken); + devNode->powerToken = NULL; + OsalMemFree(devNode->servName); + OsalMemFree((char *)devNode->servInfo); + OsalMemFree(devNode->driverName); + devNode->servName = NULL; + devNode->servInfo = NULL; + break; + case DEVNODE_NONE: + break; + default: + break; + } } -void HdfDeviceNodeDelete(struct HdfDeviceNode *devNode) +struct HdfDeviceNode *HdfDeviceNodeNewInstance(const struct HdfDeviceInfo *deviceInfo, struct HdfDriver *driver) { + struct HdfDeviceNode *devNode = NULL; + if (deviceInfo == NULL) { + return NULL; + } + devNode = (struct HdfDeviceNode *)HdfObjectManagerGetObject(HDF_OBJECT_ID_DEVICE_SERVICE); if (devNode == NULL) { - return; + return NULL; } - if (devNode->driverEntry->Release != NULL) { - devNode->driverEntry->Release(&devNode->deviceObject); + devNode->driver = driver; + devNode->devId = deviceInfo->deviceId; + devNode->permission = deviceInfo->permission; + devNode->policy = deviceInfo->policy; + devNode->token->devid = deviceInfo->deviceId; + devNode->servName = HdfStringCopy(deviceInfo->svcName); + if (devNode->servName == NULL) { + HdfDeviceNodeFreeInstance(devNode); + return NULL; + } + devNode->deviceObject.property = HcsGetNodeByMatchAttr(HdfGetHcsRootNode(), deviceInfo->deviceMatchAttr); + if (devNode->deviceObject.property == NULL) { + HDF_LOGD("node %s property empty, match attr: %s", deviceInfo->moduleName, deviceInfo->deviceMatchAttr); } - HdfDeviceNodeFreeInstance(devNode); + devNode->devStatus = DEVNODE_INITED; + return devNode; } +void HdfDeviceNodeFreeInstance(struct HdfDeviceNode *devNode) +{ + HdfObjectManagerFreeObject((struct HdfObject *)devNode); +} diff --git a/core/host/src/hdf_device_object.c b/core/host/src/hdf_device_object.c index 832b11d8e9fb2e308f928e40d1cca6df3a5d9baa..a1f2d48533e035bc12dddd8e6bcfd9cc70587f81 100644 --- a/core/host/src/hdf_device_object.c +++ b/core/host/src/hdf_device_object.c @@ -7,86 +7,89 @@ */ #include "hdf_device_object.h" +#include "devhost_service.h" +#include "devsvc_manager_clnt.h" #include "hdf_base.h" +#include "hdf_cstring.h" #include "hdf_device_node.h" +#include "hdf_driver_loader.h" #include "hdf_log.h" +#include "hdf_object_manager.h" #include "hdf_observer_record.h" +#include "hdf_power_manager.h" #include "hdf_service_observer.h" +#include "osal_mem.h" #include "power_state_token.h" #define HDF_LOG_TAG device_object +#define SERVICE_INFO_LEN_MAX 128 + int32_t HdfDeviceSubscribeService( struct HdfDeviceObject *deviceObject, const char *serviceName, struct SubscriberCallback callback) { - uint32_t matchId; struct DevHostService *hostService = NULL; - const struct HdfDeviceInfo *deviceInfo = NULL; + struct HdfDeviceNode *devNode = NULL; if (deviceObject == NULL || serviceName == NULL) { - HDF_LOGE("failed to subscribe service, deviceObject/serviceName is null"); + HDF_LOGE("failed to subscribe service, serviceName is null"); return HDF_FAILURE; } - struct HdfDeviceNode *devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( + devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( struct HdfDeviceObject, deviceObject, struct HdfDeviceNode, deviceObject); hostService = devNode->hostService; if (hostService == NULL) { HDF_LOGE("failed to subscribe service, hostService is null"); return HDF_FAILURE; } - deviceInfo = devNode->deviceInfo; - if (deviceInfo == NULL) { - HDF_LOGE("failed to subscribe service, deviceInfo is null"); - return HDF_FAILURE; - } - matchId = HdfMakeHardwareId(deviceInfo->hostId, deviceInfo->deviceId); - return HdfServiceObserverSubscribeService(&hostService->observer, serviceName, matchId, callback); + + return HdfServiceObserverSubscribeService(&hostService->observer, serviceName, devNode->devId, callback); } const char *HdfDeviceGetServiceName(const struct HdfDeviceObject *deviceObject) { + struct HdfDeviceNode *devNode = NULL; if (deviceObject == NULL) { HDF_LOGE("failed to get service name, deviceObject is invalid"); return NULL; } - struct HdfDeviceNode *devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( + devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( struct HdfDeviceObject, deviceObject, struct HdfDeviceNode, deviceObject); - const struct HdfDeviceInfo *deviceInfo = devNode->deviceInfo; - if (deviceInfo == NULL) { - HDF_LOGE("failed to get service name, deviceInfo is null"); - return NULL; - } - return deviceInfo->svcName; + return devNode->servName; } int HdfPmRegisterPowerListener(struct HdfDeviceObject *deviceObject, const struct IPowerEventListener *listener) { + struct HdfDeviceNode *devNode = NULL; if (deviceObject == NULL) { return HDF_ERR_INVALID_PARAM; } - struct HdfDeviceNode *devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( + devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( struct HdfDeviceObject, deviceObject, struct HdfDeviceNode, deviceObject); return HdfDeviceNodeAddPowerStateListener(devNode, listener); } void HdfPmUnregisterPowerListener(struct HdfDeviceObject *deviceObject, const struct IPowerEventListener *listener) { + struct HdfDeviceNode *devNode = NULL; if (deviceObject == NULL) { return; } - struct HdfDeviceNode *devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( + devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( struct HdfDeviceObject, deviceObject, struct HdfDeviceNode, deviceObject); HdfDeviceNodeRemovePowerStateListener(devNode, listener); } void HdfPmAcquireDevice(struct HdfDeviceObject *deviceObject) { + struct HdfDeviceNode *devNode = NULL; + struct IPowerStateToken *tokenIf = NULL; if (deviceObject == NULL) { HDF_LOGE("%s: input param is invalid", __func__); return; } - struct HdfDeviceNode *devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( + devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( struct HdfDeviceObject, deviceObject, struct HdfDeviceNode, deviceObject); - struct IPowerStateToken *tokenIf = (struct IPowerStateToken *)devNode->powerToken; + tokenIf = (struct IPowerStateToken *)devNode->powerToken; if ((tokenIf != NULL) && (tokenIf->AcquireWakeLock != NULL)) { tokenIf->AcquireWakeLock(tokenIf); } @@ -94,27 +97,59 @@ void HdfPmAcquireDevice(struct HdfDeviceObject *deviceObject) void HdfPmReleaseDevice(struct HdfDeviceObject *deviceObject) { + struct HdfDeviceNode *devNode = NULL; + struct IPowerStateToken *tokenIf = NULL; if (deviceObject == NULL) { HDF_LOGE("%s: input param is invalid", __func__); return; } - struct HdfDeviceNode *devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( + devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( struct HdfDeviceObject, deviceObject, struct HdfDeviceNode, deviceObject); - struct IPowerStateToken *tokenIf = (struct IPowerStateToken *)devNode->powerToken; + tokenIf = (struct IPowerStateToken *)devNode->powerToken; if ((tokenIf != NULL) && (tokenIf->ReleaseWakeLock != NULL)) { tokenIf->ReleaseWakeLock(tokenIf); } } +void HdfPmAcquireDeviceAsync(struct HdfDeviceObject *deviceObject) +{ + struct HdfDeviceNode *devNode = NULL; + + if (deviceObject == NULL) { + HDF_LOGE("%s: input param is invalid", __func__); + return; + } + + devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( + struct HdfDeviceObject, deviceObject, struct HdfDeviceNode, deviceObject); + HdfPmTaskPut(devNode->powerToken, HDF_PM_REQUEST_ACQUIRE); +} + +void HdfPmReleaseDeviceAsync(struct HdfDeviceObject *deviceObject) +{ + struct HdfDeviceNode *devNode = NULL; + + if (deviceObject == NULL) { + HDF_LOGE("%s: input param is invalid", __func__); + return; + } + + devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( + struct HdfDeviceObject, deviceObject, struct HdfDeviceNode, deviceObject); + HdfPmTaskPut(devNode->powerToken, HDF_PM_REQUEST_RELEASE); +} + void HdfPmSetMode(struct HdfDeviceObject *deviceObject, uint32_t mode) { + struct HdfDeviceNode *devNode = NULL; + struct PowerStateToken *token = NULL; if (deviceObject == NULL || mode > HDF_POWER_MODE_MAX) { HDF_LOGE("%s: input param is invalid", __func__); return; } - struct HdfDeviceNode *devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( + devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( struct HdfDeviceObject, deviceObject, struct HdfDeviceNode, deviceObject); - struct PowerStateToken *token = devNode->powerToken; + token = devNode->powerToken; if (token != NULL) { token->mode = mode; } @@ -122,8 +157,7 @@ void HdfPmSetMode(struct HdfDeviceObject *deviceObject, uint32_t mode) bool HdfDeviceSetClass(struct HdfDeviceObject *deviceObject, DeviceClass deviceClass) { - if ((deviceObject == NULL) || (deviceClass >= DEVICE_CLASS_MAX) || - (deviceClass < DEVICE_CLASS_DEFAULT)) { + if ((deviceObject == NULL) || (deviceClass >= DEVICE_CLASS_MAX) || (deviceClass >= DEVICE_CLASS_MAX)) { return false; } deviceObject->deviceClass = deviceClass; @@ -138,3 +172,154 @@ void HdfDeviceObjectConstruct(struct HdfDeviceObject *deviceObject) deviceObject->deviceClass = DEVICE_CLASS_DEFAULT; } } + +struct HdfDeviceObject *HdfDeviceObjectAlloc(struct HdfDeviceObject *parent, const char *driverName) +{ + struct HdfDeviceNode *newNode = NULL; + struct HdfDeviceNode *parentDevNode = CONTAINER_OF(parent, struct HdfDeviceNode, deviceObject); + + if (parent == NULL) { + HDF_LOGE("failed to alloc device, parent invalid"); + return NULL; + } + + if (parentDevNode->devStatus != DEVNODE_LAUNCHED) { + HDF_LOGE("failed to alloc device, parent status invalid %u", parentDevNode->devStatus); + return NULL; + } + + newNode = (struct HdfDeviceNode *)HdfObjectManagerGetObject(HDF_OBJECT_ID_DEVICE_SERVICE); + if (newNode == NULL) { + return NULL; + } + newNode->driverName = HdfStringCopy(driverName); + if (newNode->driverName == NULL) { + HdfDeviceNodeFreeInstance(newNode); + return NULL; + } + + newNode->hostService = parentDevNode->hostService; + newNode->device = parentDevNode->device; + + return &newNode->deviceObject; +} + +void HdfDeviceObjectRelease(struct HdfDeviceObject *dev) +{ + struct HdfDeviceNode *devNode = CONTAINER_OF(dev, struct HdfDeviceNode, deviceObject); + if (dev == NULL) { + return; + } + + if (devNode->device != NULL && devNode->device->super.Detach != NULL) { + devNode->device->super.Detach(&devNode->device->super, devNode); + } + HdfDeviceNodeFreeInstance(devNode); +} + +int HdfDeviceObjectRegister(struct HdfDeviceObject *dev) +{ + int ret = HDF_FAILURE; + struct HdfDeviceNode *devNode = CONTAINER_OF(dev, struct HdfDeviceNode, deviceObject); + struct IDriverLoader *driverLoader = HdfDriverLoaderGetInstance(); + + if (dev == NULL || devNode->driverName == NULL || devNode->device == NULL || driverLoader == NULL || + driverLoader->GetDriver == NULL) { + HDF_LOGE("failed to add device, param invalid"); + return HDF_ERR_INVALID_PARAM; + } + + devNode->driver = driverLoader->GetDriver(devNode->driverName); + if (devNode->driver == NULL) { + HDF_LOGE("can not found driver %s", devNode->driverName); + return HDF_DEV_ERR_NO_DEVICE; + } + + ret = devNode->device->super.Attach(&devNode->device->super, devNode); + if (ret != HDF_SUCCESS) { + HDF_LOGE("faild to attach device %s", devNode->driverName); + return HDF_DEV_ERR_ATTACHDEV_FAIL; + } + + return ret; +} + +int HdfDeviceObjectUnRegister(struct HdfDeviceObject *dev) +{ + struct HdfDeviceNode *devNode = CONTAINER_OF(dev, struct HdfDeviceNode, deviceObject); + if (devNode == NULL || devNode->device == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + return devNode->device->super.Detach(&devNode->device->super, devNode); +} + +int HdfDeviceObjectPublishService(struct HdfDeviceObject *dev, const char *servName, uint8_t policy, uint32_t perm) +{ + int ret; + struct HdfDeviceNode *devNode = CONTAINER_OF(dev, struct HdfDeviceNode, deviceObject); + if (dev == NULL || servName == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (policy <= SERVICE_POLICY_NONE || policy >= SERVICE_POLICY_INVALID) { + return HDF_DEV_ERR_NO_DEVICE_SERVICE; + } + + if (devNode->servStatus) { + HDF_LOGE("failed to publish public service, repeat publish"); + return HDF_FAILURE; + } + + devNode->servName = HdfStringCopy(servName); + if (devNode->servName == NULL) { + return HDF_DEV_ERR_NO_MEMORY; + } + + devNode->policy = policy; + devNode->permission = perm; + + ret = DeviveDriverBind(devNode); + if (ret != HDF_SUCCESS) { + return ret; + } + + return devNode->super.PublishService(devNode); +} + +int HdfDeviceObjectRemoveService(struct HdfDeviceObject *dev) +{ + struct HdfDeviceNode *devNode = CONTAINER_OF(dev, struct HdfDeviceNode, deviceObject); + if (dev == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + return devNode->super.RemoveService(devNode); +} +int HdfDeviceObjectSetServInfo(struct HdfDeviceObject *dev, const char *info) +{ + if (dev == NULL || info == NULL || strlen(info) > SERVICE_INFO_LEN_MAX) { + return HDF_ERR_INVALID_PARAM; + } + + struct HdfDeviceNode *devNode = CONTAINER_OF(dev, struct HdfDeviceNode, deviceObject); + if (devNode->servInfo != NULL) { + OsalMemFree((char *)devNode->servInfo); + } + devNode->servInfo = HdfStringCopy(info); + if (devNode->servInfo == NULL) { + return HDF_ERR_MALLOC_FAIL; + } + return HDF_SUCCESS; +} + +int HdfDeviceObjectUpdate(struct HdfDeviceObject *dev) +{ + struct HdfDeviceNode *devNode = CONTAINER_OF(dev, struct HdfDeviceNode, deviceObject); + if (dev == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + return DevSvcManagerClntUpdateService( + devNode->servName, devNode->deviceObject.deviceClass, &devNode->deviceObject, devNode->servInfo); +} diff --git a/core/host/src/hdf_driver_loader.c b/core/host/src/hdf_driver_loader.c index 98cfbee6ced8669aa349eba5d482588d8f7d9e0e..9ce739227855393c85d2355346b36ffd034a6b63 100755 --- a/core/host/src/hdf_driver_loader.c +++ b/core/host/src/hdf_driver_loader.c @@ -7,92 +7,56 @@ */ #include "hdf_driver_loader.h" -#include "devsvc_manager_clnt.h" -#include "hcs_tree_if.h" -#include "hdf_device_desc.h" -#include "hdf_device_node.h" +#include "hdf_driver.h" #include "hdf_log.h" #include "hdf_object_manager.h" -#include "hdf_attribute_manager.h" #define HDF_LOG_TAG driver_loader -struct HdfDeviceNode *HdfDriverLoaderLoadNode( - struct IDriverLoader *loader, const struct HdfDeviceInfo *deviceInfo) +int32_t HdfDriverEntryConstruct() { + int i; struct HdfDriverEntry *driverEntry = NULL; - struct HdfDeviceNode *devNode = NULL; - if ((loader == NULL) || (loader->GetDriverEntry == NULL)) { - HDF_LOGE("failed to load node, loader is invalid"); - return NULL; + size_t *addrBegin = NULL; + int32_t count = (int32_t)(((uint8_t *)(HDF_DRIVER_END()) - (uint8_t *)(HDF_DRIVER_BEGIN())) / sizeof(size_t)); + if (count <= 0) { + HDF_LOGE("%s: no hdf driver exist", __func__); + return HDF_FAILURE; } - driverEntry = loader->GetDriverEntry(deviceInfo); - if (driverEntry == NULL) { - HDF_LOGE("failed to load node, deviceEntry is null"); - return NULL; + addrBegin = (size_t *)(HDF_DRIVER_BEGIN()); + for (i = 0; i < count; i++) { + driverEntry = (struct HdfDriverEntry *)(*addrBegin); + if (HdfRegisterDriverEntry(driverEntry) != HDF_SUCCESS) { + HDF_LOGE("failed to register driver %s, skip and try another", driverEntry ? driverEntry->moduleName : ""); + continue; + } + addrBegin++; } + return HDF_SUCCESS; +} - devNode = HdfDeviceNodeNewInstance(); - if (devNode == NULL) { - HDF_LOGE("failed to load node, device node is null"); +struct HdfDriver *HdfDriverLoaderGetDriver(const char *moduleName) +{ + if (moduleName == NULL) { + HDF_LOGE("%s: failed to get device entry, moduleName is NULL", __func__); return NULL; } - devNode->driverEntry = driverEntry; - devNode->deviceInfo = deviceInfo; - devNode->deviceObject.property = HcsGetNodeByMatchAttr(HdfGetRootNode(), deviceInfo->deviceMatchAttr); - devNode->deviceObject.priv = (void *)(deviceInfo->private); - if (devNode->deviceObject.property == NULL) { - HDF_LOGW("failed to load node, property is null, match attr is: %s", deviceInfo->deviceMatchAttr); - } - - if ((deviceInfo->policy == SERVICE_POLICY_PUBLIC) || (deviceInfo->policy == SERVICE_POLICY_CAPACITY)) { - if (driverEntry->Bind == NULL) { - HDF_LOGE("driver bind method is null"); - HdfDeviceNodeFreeInstance(devNode); - return NULL; - } - if (driverEntry->Bind(&devNode->deviceObject) != 0) { - HDF_LOGE("bind driver failed"); - HdfDeviceNodeFreeInstance(devNode); - return NULL; - } - } - return devNode; + return HdfDriverManagerGetDriver(moduleName); } -void HdfDriverLoaderUnLoadNode(struct IDriverLoader *loader, const struct HdfDeviceInfo *deviceInfo) +void HdfDriverLoaderReclaimDriver(struct HdfDriver *driver) { - struct HdfDriverEntry *driverEntry = NULL; - struct HdfDeviceObject *deviceObject = NULL; - if ((loader == NULL) || (loader->GetDriverEntry == NULL)) { - HDF_LOGE("failed to unload service, loader invalid"); - return; - } - - driverEntry = loader->GetDriverEntry(deviceInfo); - if (driverEntry == NULL) { - HDF_LOGE("failed to unload service, driverEntry is null"); - return; - } - if (driverEntry->Release == NULL) { - HDF_LOGI("device release func is null"); - return; - } - deviceObject = DevSvcManagerClntGetDeviceObject(deviceInfo->svcName); - if (deviceObject != NULL) { - driverEntry->Release(deviceObject); - } + // kernel driver do not need release + (void)driver; } void HdfDriverLoaderConstruct(struct HdfDriverLoader *inst) { if (inst != NULL) { - struct IDriverLoader *driverLoaderIf = (struct IDriverLoader *)inst; - driverLoaderIf->LoadNode = HdfDriverLoaderLoadNode; - driverLoaderIf->UnLoadNode = HdfDriverLoaderUnLoadNode; - driverLoaderIf->GetDriverEntry = HdfDriverLoaderGetDriverEntry; + inst->super.GetDriver = HdfDriverLoaderGetDriver; + inst->super.ReclaimDriver = HdfDriverLoaderReclaimDriver; } } @@ -101,6 +65,9 @@ struct HdfObject *HdfDriverLoaderCreate() static bool isDriverLoaderInit = false; static struct HdfDriverLoader driverLoader; if (!isDriverLoaderInit) { + if (HdfDriverEntryConstruct() != HDF_SUCCESS) { + return NULL; + } HdfDriverLoaderConstruct(&driverLoader); isDriverLoaderInit = true; } @@ -115,4 +82,3 @@ struct IDriverLoader *HdfDriverLoaderGetInstance() } return instance; } - diff --git a/core/host/src/hdf_observer_record.c b/core/host/src/hdf_observer_record.c index 645d7d54eea0bbd103f29464e079e7b2b15cd13a..e30e7b531c85aa573da0e50171e58e6373b3da4c 100644 --- a/core/host/src/hdf_observer_record.c +++ b/core/host/src/hdf_observer_record.c @@ -14,11 +14,6 @@ #define HDF_LOG_TAG observer_record #define HALF_INT_LEN 16 -uint32_t HdfMakeHardwareId(uint16_t hostId, uint16_t deviceId) -{ - return ((uint32_t)hostId << HALF_INT_LEN) | deviceId; -} - struct HdfServiceObserverRecord *HdfServiceObserverRecordObtain(uint32_t serviceKey) { struct HdfServiceObserverRecord *observerRecord = @@ -47,10 +42,11 @@ void HdfServiceObserverRecordRecycle(struct HdfServiceObserverRecord *observerRe bool HdfServiceObserverRecordCompare(struct HdfSListNode *listEntry, uint32_t serviceKey) { + struct HdfServiceObserverRecord *record = NULL; if (listEntry == NULL) { return false; } - struct HdfServiceObserverRecord *record = (struct HdfServiceObserverRecord *)listEntry; + record = (struct HdfServiceObserverRecord *)listEntry; if (record->serviceKey == serviceKey) { return true; } @@ -58,7 +54,7 @@ bool HdfServiceObserverRecordCompare(struct HdfSListNode *listEntry, uint32_t se } void HdfServiceObserverRecordNotifySubscribers( - struct HdfServiceObserverRecord *record, uint32_t matchId, uint16_t policy) + struct HdfServiceObserverRecord *record, uint32_t devId, uint16_t policy) { struct HdfSListIterator it; if (record == NULL) { @@ -71,7 +67,7 @@ void HdfServiceObserverRecordNotifySubscribers( while (HdfSListIteratorHasNext(&it)) { struct HdfServiceSubscriber *subscriber = (struct HdfServiceSubscriber *)HdfSListIteratorNext(&it); - if ((matchId == subscriber->matchId) || (policy != SERVICE_POLICY_PRIVATE)) { + if (devId == subscriber->devId || policy != SERVICE_POLICY_PRIVATE) { subscriber->state = HDF_SUBSCRIBER_STATE_READY; if (subscriber->callback.OnServiceConnected != NULL) { subscriber->callback.OnServiceConnected(subscriber->callback.deviceObject, record->publisher); diff --git a/core/host/src/hdf_power_manager.c b/core/host/src/hdf_power_manager.c new file mode 100755 index 0000000000000000000000000000000000000000..a7f50fd922f6d94725927c6ba882871bd707d0a2 --- /dev/null +++ b/core/host/src/hdf_power_manager.c @@ -0,0 +1,104 @@ +/* + * Copyright (c) 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_power_manager.h" +#include "hdf_log.h" +#include "hdf_pm_reg.h" +#include "osal_mem.h" +#include "power_state_token.h" + +#define HDF_LOG_TAG hdf_power_manager + +struct PmTaskQueue { + struct HdfTaskQueue *taskQueue; +}; + +static struct PmTaskQueue *HdfPmTaskQueueInstance() +{ + static struct PmTaskQueue pmTaskQueue = {NULL}; + return &pmTaskQueue; +} + +struct PmTaskQueue *HdfPmTaskQueueInit(HdfTaskFunc func) +{ + struct PmTaskQueue *pmTaskQueue = HdfPmTaskQueueInstance(); + + if (pmTaskQueue->taskQueue == NULL) { + pmTaskQueue->taskQueue = HdfTaskQueueCreate(func, "pm_queue"); + if (pmTaskQueue->taskQueue != NULL) { + HDF_LOGI("%s HdfTaskQueueCreate success", __func__); + } + } + + return pmTaskQueue; +} + +void HdfPmTaskQueueDestroy(void) +{ + struct PmTaskQueue *pmTaskQueue = HdfPmTaskQueueInstance(); + HdfTaskQueueDestroy(pmTaskQueue->taskQueue); + pmTaskQueue->taskQueue = NULL; +} + +static int32_t PmTaskFunc(struct HdfTaskType *para) +{ + struct HdfPmRequest *pmRequest = NULL; + struct IPowerStateToken *tokenIf = NULL; + + if (para == NULL) { + return HDF_FAILURE; + } + + pmRequest = CONTAINER_OF(para, struct HdfPmRequest, task); + tokenIf = (struct IPowerStateToken *)pmRequest->token; + if (pmRequest->pmType == HDF_PM_REQUEST_ACQUIRE) { + if ((tokenIf != NULL) && (tokenIf->AcquireWakeLock != NULL)) { + tokenIf->AcquireWakeLock(tokenIf); + } + } else if (pmRequest->pmType == HDF_PM_REQUEST_RELEASE) { + if ((tokenIf != NULL) && (tokenIf->ReleaseWakeLock != NULL)) { + tokenIf->ReleaseWakeLock(tokenIf); + } + } + OsalMemFree(pmRequest); + return HDF_SUCCESS; +} + +void HdfPmTaskPut(struct PowerStateToken *powerToken, HDF_PM_REQUEST_TYPE type) +{ + struct HdfPmRequest *pmRequest = NULL; + struct PmTaskQueue *pmTaskQueue = NULL; + + if (powerToken == NULL) { + return; + } + + pmTaskQueue = HdfPmTaskQueueInstance(); + pmRequest = (struct HdfPmRequest *)OsalMemCalloc(sizeof(*pmRequest)); + if (pmRequest == NULL) { + HDF_LOGI("%s OsalMemCalloc fail", __func__); + return; + } + + pmRequest->token = powerToken; + pmRequest->pmType = type; + pmRequest->task.func = PmTaskFunc; + HdfTaskEnqueue(pmTaskQueue->taskQueue, &pmRequest->task); +} + +int32_t HdfPowerManagerInit(void) +{ + DevMgrPmRegister(); + HdfPmTaskQueueInit(NULL); + return HDF_SUCCESS; +} + +void HdfPowerManagerExit(void) +{ + HdfPmTaskQueueDestroy(); +} \ No newline at end of file diff --git a/core/host/src/hdf_service_observer.c b/core/host/src/hdf_service_observer.c index 29aa1555caac16ca9725e77800012546b8c969c7..ed79a96498f733f42641fb52e2cc95cfd34a9d06 100644 --- a/core/host/src/hdf_service_observer.c +++ b/core/host/src/hdf_service_observer.c @@ -36,7 +36,7 @@ void HdfServiceObserverDestruct(struct HdfServiceObserver *observer) } int HdfServiceObserverSubscribeService(struct HdfServiceObserver *observer, - const char *svcName, uint32_t matchId, struct SubscriberCallback callback) + const char *svcName, devid_t devid, struct SubscriberCallback callback) { struct HdfServiceObserverRecord *serviceRecord = NULL; struct HdfServiceSubscriber *subscriber = NULL; @@ -53,7 +53,7 @@ int HdfServiceObserverSubscribeService(struct HdfServiceObserver *observer, HDF_LOGE("failed to subscribe service, serviceRecord is null"); return HDF_FAILURE; } - subscriber = HdfServiceSubscriberObtain(callback, matchId); + subscriber = HdfServiceSubscriberObtain(callback, devid); if (subscriber == NULL) { HDF_LOGE("failed to subscribe service, subscriber is null"); HdfServiceObserverRecordRecycle(serviceRecord); @@ -63,7 +63,7 @@ int HdfServiceObserverSubscribeService(struct HdfServiceObserver *observer, HdfSListAdd(&observer->services, &serviceRecord->entry); OsalMutexUnlock(&observer->observerMutex); } else { - subscriber = HdfServiceSubscriberObtain(callback, matchId); + subscriber = HdfServiceSubscriberObtain(callback, devid); if (subscriber == NULL) { HDF_LOGE("failed to subscribe service, subscriber obtain null"); return HDF_FAILURE; @@ -72,7 +72,7 @@ int HdfServiceObserverSubscribeService(struct HdfServiceObserver *observer, if ((serviceRecord->publisher != NULL) && (subscriber->callback.OnServiceConnected != NULL) && ((serviceRecord->policy != SERVICE_POLICY_PRIVATE) || - (serviceRecord->matchId == matchId))) { + (serviceRecord->devId == devid))) { subscriber->state = HDF_SUBSCRIBER_STATE_READY; subscriber->callback.OnServiceConnected(subscriber->callback.deviceObject, serviceRecord->publisher); } @@ -83,7 +83,7 @@ int HdfServiceObserverSubscribeService(struct HdfServiceObserver *observer, } int HdfServiceObserverPublishService(struct HdfServiceObserver *observer, - const char *svcName, uint32_t matchId, uint16_t policy, struct HdfObject *service) + const char *svcName, uint32_t devId, uint16_t policy, struct HdfObject *service) { struct HdfServiceObserverRecord *serviceRecord = NULL; uint32_t serviceKey = HdfStringMakeHashKey(svcName, 0); @@ -100,14 +100,14 @@ int HdfServiceObserverPublishService(struct HdfServiceObserver *observer, return HDF_FAILURE; } serviceRecord->publisher = service; - serviceRecord->matchId = matchId; + serviceRecord->devId = devId; serviceRecord->policy = policy; OsalMutexLock(&observer->observerMutex); HdfSListAdd(&observer->services, &serviceRecord->entry); OsalMutexUnlock(&observer->observerMutex); } else { serviceRecord->publisher = service; - HdfServiceObserverRecordNotifySubscribers(serviceRecord, matchId, policy); + HdfServiceObserverRecordNotifySubscribers(serviceRecord, devId, policy); } return HDF_SUCCESS; } diff --git a/core/host/src/hdf_service_subscriber.c b/core/host/src/hdf_service_subscriber.c index efcec2f4fc170a09b03684cf88285d6213c06ef4..6aa3ffd2a9a0731cea6079993778ed95f18338b4 100644 --- a/core/host/src/hdf_service_subscriber.c +++ b/core/host/src/hdf_service_subscriber.c @@ -7,15 +7,16 @@ */ #include "hdf_service_subscriber.h" +#include "hdf_device.h" #include "osal_mem.h" -struct HdfServiceSubscriber *HdfServiceSubscriberObtain(struct SubscriberCallback callback, uint32_t matchId) +struct HdfServiceSubscriber *HdfServiceSubscriberObtain(struct SubscriberCallback callback, devid_t devid) { struct HdfServiceSubscriber *serviceSubscriber = (struct HdfServiceSubscriber *)OsalMemCalloc(sizeof(struct HdfServiceSubscriber)); if (serviceSubscriber != NULL) { serviceSubscriber->state = HDF_SUBSCRIBER_STATE_PENDING; - serviceSubscriber->matchId = matchId; + serviceSubscriber->devId = devid; serviceSubscriber->callback = callback; } return serviceSubscriber; diff --git a/core/host/src/power_state_token.c b/core/host/src/power_state_token.c index f32c21354c7e1ab6939ede7757181575aaaaf319..f4abe072683aa86f776894c5f35acecc9edbaf12 100644 --- a/core/host/src/power_state_token.c +++ b/core/host/src/power_state_token.c @@ -15,10 +15,11 @@ static void PowerStateTokenOnFirstAcquire(struct HdfSRef *sref) { + struct PowerStateToken *stateToken = NULL; if (sref == NULL) { return; } - struct PowerStateToken *stateToken = (struct PowerStateToken *)HDF_SLIST_CONTAINER_OF( + stateToken = (struct PowerStateToken *)HDF_SLIST_CONTAINER_OF( struct HdfSRef, sref, struct PowerStateToken, wakeRef); if (stateToken->psmState == PSM_STATE_ACTIVE) { @@ -36,17 +37,19 @@ static void PowerStateTokenOnFirstAcquire(struct HdfSRef *sref) static void PowerStateTokenOnLastRelease(struct HdfSRef *sref) { + struct PowerStateToken *stateToken = NULL; + const struct IPowerEventListener *listener = NULL; if (sref == NULL) { return; } - struct PowerStateToken *stateToken = (struct PowerStateToken *)HDF_SLIST_CONTAINER_OF( + stateToken = (struct PowerStateToken *)HDF_SLIST_CONTAINER_OF( struct HdfSRef, sref, struct PowerStateToken, wakeRef); if (stateToken->psmState != PSM_STATE_ACTIVE && stateToken->psmState != PSM_STATE_IDLE) { return; } - const struct IPowerEventListener *listener = stateToken->listener; + listener = stateToken->listener; if ((listener != NULL) && (listener->Suspend != NULL)) { listener->Suspend(stateToken->deviceObject); } diff --git a/core/manager/include/devhost_service_clnt.h b/core/manager/include/devhost_service_clnt.h index cbc34d64a598a72e3d30023370749f95b87ca803..44d664ba332333cc9c57c8975e3bc2b0ea2db216 100644 --- a/core/manager/include/devhost_service_clnt.h +++ b/core/manager/include/devhost_service_clnt.h @@ -16,7 +16,8 @@ struct DevHostServiceClnt { struct DListHead node; struct HdfSList devices; - struct HdfSList *deviceInfos; + struct HdfSList unloadDevInfos; + struct HdfSList dynamicDevInfos; Map *deviceHashMap; struct IDevHostService *hostService; uint16_t devCount; diff --git a/core/manager/include/devmgr_service.h b/core/manager/include/devmgr_service.h index 56f0e02cc63870819c9b75f9d5c68b7fda9e8727..d45bac619b822f5b22a031424530dbe0f4b0730d 100644 --- a/core/manager/include/devmgr_service.h +++ b/core/manager/include/devmgr_service.h @@ -24,8 +24,6 @@ bool DevmgrServiceConstruct(struct DevmgrService *inst); struct HdfObject *DevmgrServiceCreate(void); void DevmgrServiceRelease(struct HdfObject *object); struct IDevmgrService *DevmgrServiceGetInstance(void); -int DevmgrServiceLoadDevice(const char *svcName); -int DevmgrServiceUnLoadDevice(const char *svcName); int32_t DevmgrServiceLoadLeftDriver(struct DevmgrService *devMgrSvc); #endif /* DEVICE_MANAGER_SERVICE_H */ diff --git a/core/manager/include/devsvc_listener_holder.h b/core/manager/include/devsvc_listener_holder.h new file mode 100644 index 0000000000000000000000000000000000000000..b39f20895188acb9f5a5d13117a5e46ad57c6bfd --- /dev/null +++ b/core/manager/include/devsvc_listener_holder.h @@ -0,0 +1,28 @@ +/* + * Copyright (c) 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 DEVICE_SERVICE_LISTENER_HOLDER_H +#define DEVICE_SERVICE_LISTENER_HOLDER_H + +#include "hdf_service_status.h" +#include "hdf_dlist.h" + +struct ServStatListenerHolder { + uint16_t listenClass; + struct DListHead node; + uint64_t index; + void (*NotifyStatus)(struct ServStatListenerHolder *holder, struct ServiceStatus *status); +}; + +void ServStatListenerHolderinit(void); + +struct ServStatListenerHolder *ServStatListenerHolderCreate(uintptr_t listener, uint16_t listenClass); +void ServStatListenerHolderRelease(struct ServStatListenerHolder *holder); +struct ServStatListenerHolder *ServStatListenerHolderGet(uint64_t index); + +#endif /* DEVICE_SERVICE_LISTENER_HOLDER_H */ diff --git a/core/manager/include/devsvc_manager.h b/core/manager/include/devsvc_manager.h index b73731bccef9917257cad7d80d8ece11132e18ef..a1bf6d0cd6a40ecd2388964dc0aabd315216ca18 100644 --- a/core/manager/include/devsvc_manager.h +++ b/core/manager/include/devsvc_manager.h @@ -11,23 +11,29 @@ #include "devsvc_manager_if.h" #include "hdf_service_observer.h" -#include "hdf_slist.h" +#include "hdf_dlist.h" #include "osal_mutex.h" struct DevSvcManager { struct IDevSvcManager super; - struct HdfSList services; + struct DListHead services; struct HdfServiceObserver observer; + struct DListHead svcstatListeners; struct OsalMutex mutex; }; struct HdfObject *DevSvcManagerCreate(void); bool DevSvcManagerConstruct(struct DevSvcManager *inst); -void DevSvcManagerRelease(struct HdfObject *object); +void DevSvcManagerRelease(struct IDevSvcManager *inst); struct IDevSvcManager *DevSvcManagerGetInstance(void); -int DevSvcManagerAddService(struct IDevSvcManager *manager, const char *svcName, struct HdfDeviceObject *service); + +int DevSvcManagerStartService(void); + +int DevSvcManagerAddService(struct IDevSvcManager *manager, const char *svcName, + uint16_t devClass, struct HdfDeviceObject *service, const char *servInfo); struct HdfObject *DevSvcManagerGetService(struct IDevSvcManager *manager, const char *svcName); void DevSvcManagerRemoveService(struct IDevSvcManager *manager, const char *svcName); +void DevSvcManagerListService(struct HdfSBuf *serviecNameSet, DeviceClass deviceClass); int DevSvcManagerClntSubscribeService(const char *svcName, struct SubscriberCallback callback); int DevSvcManagerClntUnsubscribeService(const char *svcName); diff --git a/core/manager/include/devsvc_manager_ext.h b/core/manager/include/devsvc_manager_ext.h new file mode 100644 index 0000000000000000000000000000000000000000..262b9e50494dc7542b2cfcb28285d8de8f241345 --- /dev/null +++ b/core/manager/include/devsvc_manager_ext.h @@ -0,0 +1,15 @@ +/* + * Copyright (c) 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 DEVICE_SERVICE_MANAGER_EXT_H +#define DEVICE_SERVICE_MANAGER_EXT_H + +struct HdfObject *DevSvcManagerExtCreate(void); +void DevSvcManagerExtRelease(struct HdfObject *object); + +#endif // DEVICE_SERVICE_MANAGER_EXT_H \ No newline at end of file diff --git a/core/manager/src/devhost_service_clnt.c b/core/manager/src/devhost_service_clnt.c index 43b4f1ca901cdcdfa56b3a1e10f6c554954cd04a..cebd88d4a970687dbe2c6c92c8e7eacc3497416a 100644 --- a/core/manager/src/devhost_service_clnt.c +++ b/core/manager/src/devhost_service_clnt.c @@ -32,20 +32,26 @@ int DevHostServiceClntInstallDriver(struct DevHostServiceClnt *hostClnt) HDF_LOGE("devHostSvcIf or devHostSvcIf->AddDevice is null"); return HDF_FAILURE; } - HdfSListIteratorInit(&it, hostClnt->deviceInfos); + HdfSListIteratorInit(&it, &hostClnt->unloadDevInfos); while (HdfSListIteratorHasNext(&it)) { deviceInfo = (struct HdfDeviceInfo *)HdfSListIteratorNext(&it); if ((deviceInfo == NULL) || (deviceInfo->preload == DEVICE_PRELOAD_DISABLE)) { continue; } - if ((DeviceManagerIsQuickLoad() == DEV_MGR_QUICK_LOAD) && - (deviceInfo->preload == DEVICE_PRELOAD_ENABLE_STEP2)) { + /* + * If quick start feature enable, the device which 'preload' attribute set as + * DEVICE_PRELOAD_ENABLE_STEP2 will be loaded later + */ + if (DeviceManagerIsQuickLoad() == DEV_MGR_QUICK_LOAD && + deviceInfo->preload == DEVICE_PRELOAD_ENABLE_STEP2) { continue; } ret = devHostSvcIf->AddDevice(devHostSvcIf, deviceInfo); if (ret != HDF_SUCCESS) { HDF_LOGE("failed to install driver %s, ret = %d", deviceInfo->svcName, ret); + continue; } + HdfSListIteratorRemove(&it); } return HDF_SUCCESS; } @@ -69,6 +75,7 @@ struct DevHostServiceClnt *DevHostServiceClntNewInstance(uint16_t hostId, const hostClnt->hostId = hostId; hostClnt->hostName = hostName; hostClnt->devCount = 0; + hostClnt->hostPid = -1; DevHostServiceClntConstruct(hostClnt); } return hostClnt; @@ -78,7 +85,8 @@ void DevHostServiceClntFreeInstance(struct DevHostServiceClnt *hostClnt) { if (hostClnt != NULL) { HdfSListFlush(&hostClnt->devices, DeviceTokenClntDelete); - HdfSListFlush(hostClnt->deviceInfos, HdfDeviceInfoDelete); + HdfSListFlush(&hostClnt->unloadDevInfos, HdfDeviceInfoDelete); + HdfSListFlush(&hostClnt->dynamicDevInfos, HdfDeviceInfoDelete); OsalMemFree(hostClnt->deviceHashMap); OsalMemFree(hostClnt); } diff --git a/core/manager/src/devmgr_service.c b/core/manager/src/devmgr_service.c index 36886a9319183985a40a2f640c55153e880872bb..b8b6897a85bf816115ef6079e685d0bdd8dd8193 100644 --- a/core/manager/src/devmgr_service.c +++ b/core/manager/src/devmgr_service.c @@ -9,59 +9,123 @@ #include "devmgr_service.h" #include "devhost_service_clnt.h" #include "device_token_clnt.h" +#include "devsvc_manager.h" #include "hdf_attribute_manager.h" #include "hdf_base.h" #include "hdf_driver_installer.h" #include "hdf_host_info.h" #include "hdf_log.h" #include "hdf_object_manager.h" +#include "osal_time.h" #define HDF_LOG_TAG devmgr_service -static int DevmgrServiceActiveDevice(struct DevHostServiceClnt *hostClnt, - struct HdfDeviceInfo *deviceInfo, bool isLoad) +static bool DevmgrServiceDynamicDevInfoFound(const char *svcName, struct DevHostServiceClnt **targetHostClnt, + struct HdfDeviceInfo **targetDeviceInfo) { - struct IDevHostService *devHostSvcIf = (struct IDevHostService *)hostClnt->hostService; - if (devHostSvcIf == NULL) { - return HDF_FAILURE; + struct HdfSListIterator itDeviceInfo; + struct HdfDeviceInfo *deviceInfo = NULL; + struct DevHostServiceClnt *hostClnt = NULL; + struct DevmgrService *devMgrSvc = (struct DevmgrService *)DevmgrServiceGetInstance(); + if (devMgrSvc == NULL) { + return false; } - if (isLoad && (deviceInfo->preload != DEVICE_PRELOAD_ENABLE)) { - int ret = devHostSvcIf->AddDevice(devHostSvcIf, deviceInfo); - if (ret == HDF_SUCCESS) { - deviceInfo->preload = DEVICE_PRELOAD_ENABLE; + DLIST_FOR_EACH_ENTRY(hostClnt, &devMgrSvc->hosts, struct DevHostServiceClnt, node) { + HdfSListIteratorInit(&itDeviceInfo, &hostClnt->dynamicDevInfos); + while (HdfSListIteratorHasNext(&itDeviceInfo)) { + deviceInfo = (struct HdfDeviceInfo *)HdfSListIteratorNext(&itDeviceInfo); + if (strcmp(deviceInfo->svcName, svcName) == 0) { + *targetDeviceInfo = deviceInfo; + *targetHostClnt = hostClnt; + return true; + } } - return ret; - } else if (!isLoad && (deviceInfo->preload != DEVICE_PRELOAD_DISABLE)) { - devHostSvcIf->DelDevice(devHostSvcIf, deviceInfo); - deviceInfo->preload = DEVICE_PRELOAD_DISABLE; + } + + return false; +} + +#define WAIT_HOST_SLEEP_TIME 1 // ms +#define WAIT_HOST_SLEEP_CNT 100 +static int DevmgrServiceStartHostProcess(struct DevHostServiceClnt *hostClnt, bool sync) +{ + int waitCount = WAIT_HOST_SLEEP_CNT; + struct IDriverInstaller *installer = DriverInstallerGetInstance(); + if (installer == NULL || installer->StartDeviceHost == NULL) { + HDF_LOGE("invalid installer"); + return HDF_FAILURE; + } + + hostClnt->hostPid = installer->StartDeviceHost(hostClnt->hostId, hostClnt->hostName); + if (hostClnt->hostPid == HDF_FAILURE) { + HDF_LOGW("failed to start device host(%s, %u)", hostClnt->hostName, hostClnt->hostId); + return HDF_FAILURE; + } + if (!sync) { return HDF_SUCCESS; - } else { + } + + while (hostClnt->hostService == NULL && waitCount-- > 0) { + OsalMSleep(WAIT_HOST_SLEEP_TIME); + } + + if (waitCount <= 0) { + HDF_LOGE("wait host(%s, %d) attach timeout", hostClnt->hostName, hostClnt->hostId); + return HDF_ERR_TIMEOUT; + } + + return HDF_SUCCESS; +} + +static int DevmgrServiceLoadDevice(struct IDevmgrService *devMgrSvc, const char *serviceName) +{ + struct HdfDeviceInfo *deviceInfo = NULL; + struct DevHostServiceClnt *hostClnt = NULL; + (void)devMgrSvc; + + if (serviceName == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (!DevmgrServiceDynamicDevInfoFound(serviceName, &hostClnt, &deviceInfo)) { + HDF_LOGE("device %s not in configed device list", serviceName); + return HDF_DEV_ERR_NO_DEVICE; + } + + if (deviceInfo->preload != DEVICE_PRELOAD_DISABLE) { + HDF_LOGE("device %s not an dynamic load device", serviceName); + return HDF_DEV_ERR_NORANGE; + } + + if (hostClnt->hostPid < 0 && DevmgrServiceStartHostProcess(hostClnt, true) != HDF_SUCCESS) { + HDF_LOGW("failed to start device host(%s, %u)", hostClnt->hostName, hostClnt->hostId); return HDF_FAILURE; } + + return hostClnt->hostService->AddDevice(hostClnt->hostService, deviceInfo); } -static int DevmgrServiceFindAndActiveDevice(const char *svcName, bool isLoad) +static int DevmgrServiceUnloadDevice(struct IDevmgrService *devMgrSvc, const char *serviceName) { - struct HdfSListIterator itDeviceInfo; struct HdfDeviceInfo *deviceInfo = NULL; struct DevHostServiceClnt *hostClnt = NULL; - struct DevmgrService *devMgrSvc = (struct DevmgrService *)DevmgrServiceGetInstance(); - if (devMgrSvc == NULL || svcName == NULL) { + (void)devMgrSvc; + + if (serviceName == NULL) { return HDF_ERR_INVALID_PARAM; } - DLIST_FOR_EACH_ENTRY(hostClnt, &devMgrSvc->hosts, struct DevHostServiceClnt, node) { - HdfSListIteratorInit(&itDeviceInfo, hostClnt->deviceInfos); - while (HdfSListIteratorHasNext(&itDeviceInfo)) { - deviceInfo = (struct HdfDeviceInfo *)HdfSListIteratorNext(&itDeviceInfo); - if (strcmp(deviceInfo->svcName, svcName) == 0) { - return DevmgrServiceActiveDevice(hostClnt, deviceInfo, isLoad); - } - } + if (!DevmgrServiceDynamicDevInfoFound(serviceName, &hostClnt, &deviceInfo) || + deviceInfo->preload != DEVICE_PRELOAD_DISABLE) { + HDF_LOGE("device %s not in configed dynamic device list", serviceName); + return HDF_DEV_ERR_NO_DEVICE; } - return HDF_FAILURE; + if (hostClnt->hostService == NULL) { + return HDF_FAILURE; + } + return hostClnt->hostService->DelDevice(hostClnt->hostService, deviceInfo->deviceId); } int32_t DevmgrServiceLoadLeftDriver(struct DevmgrService *devMgrSvc) @@ -75,30 +139,22 @@ int32_t DevmgrServiceLoadLeftDriver(struct DevmgrService *devMgrSvc) } DLIST_FOR_EACH_ENTRY(hostClnt, &devMgrSvc->hosts, struct DevHostServiceClnt, node) { - HdfSListIteratorInit(&itDeviceInfo, hostClnt->deviceInfos); + HdfSListIteratorInit(&itDeviceInfo, &hostClnt->unloadDevInfos); while (HdfSListIteratorHasNext(&itDeviceInfo)) { deviceInfo = (struct HdfDeviceInfo *)HdfSListIteratorNext(&itDeviceInfo); if (deviceInfo->preload == DEVICE_PRELOAD_ENABLE_STEP2) { - ret = DevmgrServiceActiveDevice(hostClnt, deviceInfo, true); + ret = hostClnt->hostService->AddDevice(hostClnt->hostService, deviceInfo); if (ret != HDF_SUCCESS) { HDF_LOGE("%s:failed to load driver %s", __func__, deviceInfo->moduleName); + continue; } + HdfSListIteratorRemove(&itDeviceInfo); } } } return HDF_SUCCESS; } -int DevmgrServiceLoadDevice(const char *svcName) -{ - return DevmgrServiceFindAndActiveDevice(svcName, true); -} - -int DevmgrServiceUnLoadDevice(const char *svcName) -{ - return DevmgrServiceFindAndActiveDevice(svcName, false); -} - static struct DevHostServiceClnt *DevmgrServiceFindDeviceHost(struct IDevmgrService *inst, uint16_t hostId) { struct DevHostServiceClnt *hostClnt = NULL; @@ -113,53 +169,57 @@ static struct DevHostServiceClnt *DevmgrServiceFindDeviceHost(struct IDevmgrServ return hostClnt; } } - HDF_LOGE("failed to find host, host id is %u", hostId); + HDF_LOGE("cannot find host %u", hostId); return NULL; } -static void DevmgrServiceUpdateStatus(struct DevHostServiceClnt *hostClnt, uint16_t deviceId, uint16_t status) +static int DevmgrServiceAttachDevice(struct IDevmgrService *inst, struct IHdfDeviceToken *token) { - struct HdfSListIterator it; - struct HdfDeviceInfo *deviceInfo = NULL; - - HdfSListIteratorInit(&it, hostClnt->deviceInfos); - while (HdfSListIteratorHasNext(&it)) { - deviceInfo = (struct HdfDeviceInfo *)HdfSListIteratorNext(&it); - if (deviceInfo->deviceId == deviceId) { - deviceInfo->status = status; - HDF_LOGD("%s host:%s %u device:%s %u status:%u", __func__, hostClnt->hostName, - hostClnt->hostId, deviceInfo->svcName, deviceId, deviceInfo->status); - return; - } - } - HDF_LOGE("%s: not find device %u in host %u", __func__, deviceId, hostClnt->hostId); - return; -} + struct DevHostServiceClnt *hostClnt = NULL; + struct DeviceTokenClnt *tokenClnt = NULL; -static int DevmgrServiceAttachDevice( - struct IDevmgrService *inst, const struct HdfDeviceInfo *deviceInfo, struct IHdfDeviceToken *token) -{ - if (deviceInfo == NULL) { - HDF_LOGE("failed to attach device, deviceInfo is null"); - return HDF_FAILURE; - } - struct DevHostServiceClnt *hostClnt = DevmgrServiceFindDeviceHost(inst, deviceInfo->hostId); + hostClnt = DevmgrServiceFindDeviceHost(inst, HOSTID(token->devid)); if (hostClnt == NULL) { HDF_LOGE("failed to attach device, hostClnt is null"); return HDF_FAILURE; } - struct DeviceTokenClnt *tokenClnt = DeviceTokenClntNewInstance(token); + tokenClnt = DeviceTokenClntNewInstance(token); if (tokenClnt == NULL) { HDF_LOGE("failed to attach device, tokenClnt is null"); return HDF_FAILURE; } - tokenClnt->deviceInfo = deviceInfo; - DevmgrServiceUpdateStatus(hostClnt, deviceInfo->deviceId, HDF_SERVICE_USABLE); HdfSListAdd(&hostClnt->devices, &tokenClnt->node); return HDF_SUCCESS; } +static bool HdfSListHostSearchDeviceTokenComparer(struct HdfSListNode *tokenNode, uint32_t devid) +{ + struct DeviceTokenClnt *tokenClnt = CONTAINER_OF(tokenNode, struct DeviceTokenClnt, node); + return tokenClnt->tokenIf->devid == devid; +} + +static int DevmgrServiceDetachDevice(struct IDevmgrService *inst, devid_t devid) +{ + struct DevHostServiceClnt *hostClnt = NULL; + struct DeviceTokenClnt *tokenClnt = NULL; + struct HdfSListNode *tokenClntNode = NULL; + + hostClnt = DevmgrServiceFindDeviceHost(inst, HOSTID(devid)); + if (hostClnt == NULL) { + HDF_LOGE("failed to attach device, hostClnt is null"); + return HDF_FAILURE; + } + tokenClntNode = HdfSListSearch(&hostClnt->devices, devid, HdfSListHostSearchDeviceTokenComparer); + if (tokenClntNode == NULL) { + HDF_LOGE("devmgr detach device %x not found", devid); + return HDF_DEV_ERR_NO_DEVICE; + } + tokenClnt = CONTAINER_OF(tokenClntNode, struct DeviceTokenClnt, node); + HdfSListRemove(&hostClnt->devices, &tokenClnt->node); + return HDF_SUCCESS; +} + static int DevmgrServiceAttachDeviceHost( struct IDevmgrService *inst, uint16_t hostId, struct IDevHostService *hostService) { @@ -174,27 +234,45 @@ static int DevmgrServiceAttachDeviceHost( } hostClnt->hostService = hostService; - hostClnt->deviceInfos = HdfAttributeManagerGetDeviceList(hostClnt->hostId, hostClnt->hostName); - if (hostClnt->deviceInfos == NULL) { - HDF_LOGW("failed to get device list "); + return DevHostServiceClntInstallDriver(hostClnt); +} + +static int DevmgrServiceStartDeviceHost(struct DevmgrService *devmgr, struct HdfHostInfo *hostAttr) +{ + struct DevHostServiceClnt *hostClnt = DevHostServiceClntNewInstance(hostAttr->hostId, hostAttr->hostName); + if (hostClnt == NULL) { + HDF_LOGW("failed to create new device host client"); + return HDF_FAILURE; + } + + if (HdfAttributeManagerGetDeviceList(hostClnt) != HDF_SUCCESS) { + HDF_LOGW("failed to get device list for host %s", hostClnt->hostName); + return HDF_FAILURE; + } + + DListInsertTail(&hostClnt->node, &devmgr->hosts); + + // not start the host which only have dynamic deivces + if (HdfSListIsEmpty(&hostClnt->unloadDevInfos)) { return HDF_SUCCESS; } - hostClnt->devCount = HdfSListCount(hostClnt->deviceInfos); - return DevHostServiceClntInstallDriver(hostClnt); + + if (DevmgrServiceStartHostProcess(hostClnt, false) != HDF_SUCCESS) { + HDF_LOGW("failed to start device host, host id is %u", hostAttr->hostId); + DListRemove(&hostClnt->node); + DevHostServiceClntFreeInstance(hostClnt); + return HDF_FAILURE; + } + return HDF_SUCCESS; } static int DevmgrServiceStartDeviceHosts(struct DevmgrService *inst) { + uint32_t ret; struct HdfSList hostList; struct HdfSListIterator it; struct HdfHostInfo *hostAttr = NULL; - struct DevHostServiceClnt *hostClnt = NULL; - struct IDriverInstaller *installer = NULL; - installer = DriverInstallerGetInstance(); - if (installer == NULL || installer->StartDeviceHost == NULL) { - HDF_LOGE("installer or installer->StartDeviceHost is null"); - return HDF_FAILURE; - } + HdfSListInit(&hostList); if (!HdfAttributeManagerGetHostList(&hostList)) { HDF_LOGW("%s: host list is null", __func__); @@ -203,17 +281,10 @@ static int DevmgrServiceStartDeviceHosts(struct DevmgrService *inst) HdfSListIteratorInit(&it, &hostList); while (HdfSListIteratorHasNext(&it)) { hostAttr = (struct HdfHostInfo *)HdfSListIteratorNext(&it); - hostClnt = DevHostServiceClntNewInstance(hostAttr->hostId, hostAttr->hostName); - if (hostClnt == NULL) { - HDF_LOGW("failed to create new device host client"); - continue; - } - DListInsertTail(&hostClnt->node, &inst->hosts); - hostClnt->hostPid = installer->StartDeviceHost(hostAttr->hostId, hostAttr->hostName); - if (hostClnt->hostPid == HDF_FAILURE) { - HDF_LOGW("failed to start device host, host id is %u", hostAttr->hostId); - DListRemove(&hostClnt->node); - DevHostServiceClntFreeInstance(hostClnt); + ret = DevmgrServiceStartDeviceHost(inst, hostAttr); + if (ret != HDF_SUCCESS) { + HDF_LOGW("%s failed to start device host, host id is %u, host name is '%s'", + __func__, hostAttr->hostId, hostAttr->hostName); } } HdfSListFlush(&hostList, HdfHostInfoDelete); @@ -222,11 +293,16 @@ static int DevmgrServiceStartDeviceHosts(struct DevmgrService *inst) int DevmgrServiceStartService(struct IDevmgrService *inst) { + int ret; struct DevmgrService *dmService = (struct DevmgrService *)inst; if (dmService == NULL) { HDF_LOGE("failed to start device manager service, dmService is null"); return HDF_FAILURE; } + + ret = DevSvcManagerStartService(); + HDF_LOGI("start svcmgr result %d", ret); + return DevmgrServiceStartDeviceHosts(dmService); } @@ -271,13 +347,17 @@ int DevmgrServicePowerStateChange(struct IDevmgrService *devmgrService, enum Hdf bool DevmgrServiceConstruct(struct DevmgrService *inst) { + struct IDevmgrService *devMgrSvcIf = NULL; if (OsalMutexInit(&inst->devMgrMutex) != HDF_SUCCESS) { HDF_LOGE("%s:failed to mutex init ", __func__); return false; } - struct IDevmgrService *devMgrSvcIf = (struct IDevmgrService *)inst; + devMgrSvcIf = (struct IDevmgrService *)inst; if (devMgrSvcIf != NULL) { devMgrSvcIf->AttachDevice = DevmgrServiceAttachDevice; + devMgrSvcIf->DetachDevice = DevmgrServiceDetachDevice; + devMgrSvcIf->LoadDevice = DevmgrServiceLoadDevice; + devMgrSvcIf->UnloadDevice = DevmgrServiceUnloadDevice; devMgrSvcIf->AttachDeviceHost = DevmgrServiceAttachDeviceHost; devMgrSvcIf->StartService = DevmgrServiceStartService; devMgrSvcIf->PowerStateChange = DevmgrServicePowerStateChange; @@ -313,14 +393,14 @@ struct IDevmgrService *DevmgrServiceGetInstance() void DevmgrServiceRelease(struct HdfObject *object) { struct DevmgrService *devmgrService = (struct DevmgrService *)object; + struct DevHostServiceClnt *hostClnt = NULL; + struct DevHostServiceClnt *hostClntTmp = NULL; if (devmgrService == NULL) { return; } - struct DevHostServiceClnt *hostClnt = NULL; - struct DevHostServiceClnt *hostClntTmp = NULL; DLIST_FOR_EACH_ENTRY_SAFE(hostClnt, hostClntTmp, &devmgrService->hosts, struct DevHostServiceClnt, node) { DListRemove(&hostClnt->node); - DevHostServiceClntDelete(hostClnt); + DevHostServiceClntDelete(hostClnt); } OsalMutexDestroy(&devmgrService->devMgrMutex); diff --git a/core/manager/src/devsvc_manager.c b/core/manager/src/devsvc_manager.c index 1c7b765acab51ca905a08b1cd7bec17fba2c1fb8..2c3380389a1257641a3788652e48b3e99c573b94 100644 --- a/core/manager/src/devsvc_manager.c +++ b/core/manager/src/devsvc_manager.c @@ -13,12 +13,13 @@ #include "hdf_log.h" #include "hdf_object_manager.h" #include "hdf_service_record.h" +#include "hdf_device_node.h" +#include "osal_mem.h" #define HDF_LOG_TAG devsvc_manager static struct DevSvcRecord *DevSvcManagerSearchService(struct IDevSvcManager *inst, uint32_t serviceKey) { - struct HdfSListIterator it; struct DevSvcRecord *record = NULL; struct DevSvcRecord *searchResult = NULL; struct DevSvcManager *devSvcManager = (struct DevSvcManager *)inst; @@ -28,10 +29,8 @@ static struct DevSvcRecord *DevSvcManagerSearchService(struct IDevSvcManager *in } OsalMutexLock(&devSvcManager->mutex); - HdfSListIteratorInit(&it, &devSvcManager->services); - while (HdfSListIteratorHasNext(&it)) { - record = (struct DevSvcRecord *)HdfSListIteratorNext(&it); - if ((record != NULL) && (record->key == serviceKey)) { + DLIST_FOR_EACH_ENTRY(record, &devSvcManager->services, struct DevSvcRecord, entry) { + if (record->key == serviceKey) { searchResult = record; break; } @@ -39,38 +38,104 @@ static struct DevSvcRecord *DevSvcManagerSearchService(struct IDevSvcManager *in OsalMutexUnlock(&devSvcManager->mutex); return searchResult; } +static void NotifyServiceStatusLocked(struct DevSvcManager *devSvcManager, + struct DevSvcRecord *record, uint32_t status) +{ + struct ServStatListenerHolder *listenerHolder = NULL; + struct ServiceStatus svcstat = { + .deviceClass = record->devClass, + .serviceName = record->servName, + .status = status, + .info = record->servInfo, + }; + + DLIST_FOR_EACH_ENTRY(listenerHolder, &devSvcManager->svcstatListeners, struct ServStatListenerHolder, node) { + if ((listenerHolder->listenClass & record->devClass) && listenerHolder->NotifyStatus != NULL) { + listenerHolder->NotifyStatus(listenerHolder, &svcstat); + } + } +} -int DevSvcManagerAddService(struct IDevSvcManager *inst, const char *svcName, struct HdfDeviceObject *service) +int DevSvcManagerAddService(struct IDevSvcManager *inst, const char *servName, + uint16_t devClass, struct HdfDeviceObject *service, const char *servInfo) { struct DevSvcManager *devSvcManager = (struct DevSvcManager *)inst; - if ((devSvcManager == NULL) || (service == NULL) || (svcName == NULL)) { + struct DevSvcRecord *record = NULL; + if (devSvcManager == NULL || service == NULL || servName == NULL) { HDF_LOGE("failed to add service, input param is null"); return HDF_FAILURE; } - struct DevSvcRecord *record = DevSvcRecordNewInstance(); + record = DevSvcRecordNewInstance(); if (record == NULL) { HDF_LOGE("failed to add service , record is null"); return HDF_FAILURE; } - record->key = HdfStringMakeHashKey(svcName, 0); + record->key = HdfStringMakeHashKey(servName, 0); record->value = service; + record->devClass = devClass; + record->servName = HdfStringCopy(servName); + record->servInfo = HdfStringCopy(servInfo); + if (record->servName == NULL) { + DevSvcRecordFreeInstance(record); + return HDF_ERR_MALLOC_FAIL; + } OsalMutexLock(&devSvcManager->mutex); - HdfSListAdd(&devSvcManager->services, &record->entry); + DListInsertTail(&record->entry, &devSvcManager->services); + NotifyServiceStatusLocked(devSvcManager, record, SERVIE_STATUS_START); OsalMutexUnlock(&devSvcManager->mutex); return HDF_SUCCESS; } +int DevSvcManagerUpdateService(struct IDevSvcManager *inst, const char *servName, + uint16_t devClass, struct HdfDeviceObject *service, const char *servInfo) +{ + struct DevSvcManager *devSvcManager = (struct DevSvcManager *)inst; + struct DevSvcRecord *record = NULL; + char *servNameStr = NULL; + char *servInfoStr = NULL; + if (devSvcManager == NULL || service == NULL || servName == NULL) { + HDF_LOGE("failed to add service, input param is null"); + return HDF_FAILURE; + } + + record = DevSvcManagerSearchService(inst, HdfStringMakeHashKey(servName, 0)); + if (record == NULL) { + return HDF_DEV_ERR_NO_DEVICE; + } + + servNameStr = HdfStringCopy(servName); + if (servNameStr == NULL) { + return HDF_ERR_MALLOC_FAIL; + } + + servInfoStr = HdfStringCopy(servInfo); + if (servInfoStr == NULL) { + OsalMemFree(servNameStr); + return HDF_ERR_MALLOC_FAIL; + } + OsalMemFree((char *)record->servName); + OsalMemFree((char *)record->servInfo); + + record->value = service; + record->devClass = devClass; + record->servName = servNameStr; + record->servInfo = servInfoStr; + + NotifyServiceStatusLocked(devSvcManager, record, SERVIE_STATUS_CHANGE); + return HDF_SUCCESS; +} + int DevSvcManagerSubscribeService(struct IDevSvcManager *inst, const char *svcName, struct SubscriberCallback callBack) { - int ret = HDF_FAILURE; - struct DevSvcManager *devSvcMgr = (struct DevSvcManager *)inst; - if (svcName == NULL || devSvcMgr == NULL) { - return ret; + struct DevmgrService *devMgrSvc = (struct DevmgrService *)DevmgrServiceGetInstance(); + struct HdfObject *deviceService = NULL; + if (inst == NULL || svcName == NULL || devMgrSvc == NULL) { + return HDF_FAILURE; } - struct HdfObject *deviceService = DevSvcManagerGetService(inst, svcName); + deviceService = DevSvcManagerGetService(inst, svcName); if (deviceService != NULL) { if (callBack.OnServiceConnected != NULL) { callBack.OnServiceConnected(callBack.deviceObject, deviceService); @@ -78,39 +143,64 @@ int DevSvcManagerSubscribeService(struct IDevSvcManager *inst, const char *svcNa return HDF_SUCCESS; } - return DevmgrServiceLoadDevice(svcName); + return devMgrSvc->super.LoadDevice(&devMgrSvc->super, svcName); } void DevSvcManagerRemoveService(struct IDevSvcManager *inst, const char *svcName) { struct DevSvcManager *devSvcManager = (struct DevSvcManager *)inst; + struct DevSvcRecord *serviceRecord = NULL; uint32_t serviceKey = HdfStringMakeHashKey(svcName, 0); + if (svcName == NULL || devSvcManager == NULL) { return; } - struct DevSvcRecord *serviceRecord = DevSvcManagerSearchService(inst, serviceKey); - if (serviceRecord != NULL) { - OsalMutexLock(&devSvcManager->mutex); - HdfSListRemove(&devSvcManager->services, &serviceRecord->entry); - OsalMutexUnlock(&devSvcManager->mutex); + serviceRecord = DevSvcManagerSearchService(inst, serviceKey); + if (serviceRecord == NULL) { + return; } + OsalMutexLock(&devSvcManager->mutex); + NotifyServiceStatusLocked(devSvcManager, serviceRecord, SERVIE_STATUS_STOP); + DListRemove(&serviceRecord->entry); + OsalMutexUnlock(&devSvcManager->mutex); + DevSvcRecordFreeInstance(serviceRecord); } struct HdfDeviceObject *DevSvcManagerGetObject(struct IDevSvcManager *inst, const char *svcName) { uint32_t serviceKey = HdfStringMakeHashKey(svcName, 0); + struct DevSvcRecord *serviceRecord = NULL; if (svcName == NULL) { HDF_LOGE("Get service failed, svcName is null"); return NULL; } - struct DevSvcRecord *serviceRecord = DevSvcManagerSearchService(inst, serviceKey); + serviceRecord = DevSvcManagerSearchService(inst, serviceKey); if (serviceRecord != NULL) { return serviceRecord->value; } return NULL; } +// only use for kernel space +void DevSvcManagerListService(struct HdfSBuf *serviecNameSet, DeviceClass deviceClass) +{ + struct DevSvcRecord *record = NULL; + struct DevSvcManager *devSvcManager = (struct DevSvcManager *)DevSvcManagerGetInstance(); + if (devSvcManager == NULL) { + HDF_LOGE("failed to list service, devSvcManager is null"); + return; + } + + OsalMutexLock(&devSvcManager->mutex); + DLIST_FOR_EACH_ENTRY(record, &devSvcManager->services, struct DevSvcRecord, entry) { + if (record->devClass == deviceClass) { + HdfSbufWriteString(serviecNameSet, record->servName); + } + } + OsalMutexUnlock(&devSvcManager->mutex); +} + struct HdfObject *DevSvcManagerGetService(struct IDevSvcManager *inst, const char *svcName) { struct HdfDeviceObject *deviceObject = DevSvcManagerGetObject(inst, svcName); @@ -120,27 +210,80 @@ struct HdfObject *DevSvcManagerGetService(struct IDevSvcManager *inst, const cha return (struct HdfObject *)deviceObject->service; } +int DevSvcManagerRegsterServListener(struct IDevSvcManager *inst, + struct ServStatListenerHolder *listenerHolder) +{ + struct DevSvcManager *devSvcManager = (struct DevSvcManager *)inst; + if (devSvcManager == NULL || listenerHolder == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + OsalMutexLock(&devSvcManager->mutex); + DListInsertTail(&listenerHolder->node, &devSvcManager->svcstatListeners); + OsalMutexUnlock(&devSvcManager->mutex); + + return HDF_SUCCESS; +} + +void DevSvcManagerUnregsterServListener(struct IDevSvcManager *inst, + struct ServStatListenerHolder *listenerHolder) +{ + struct DevSvcManager *devSvcManager = (struct DevSvcManager *)inst; + if (devSvcManager == NULL || listenerHolder == NULL) { + return; + } + + OsalMutexLock(&devSvcManager->mutex); + DListRemove(&listenerHolder->node); + OsalMutexUnlock(&devSvcManager->mutex); +} + bool DevSvcManagerConstruct(struct DevSvcManager *inst) { + struct IDevSvcManager *devSvcMgrIf = NULL; if (inst == NULL) { HDF_LOGE("%s: inst is null!", __func__); return false; } - struct IDevSvcManager *devSvcMgrIf = &inst->super; + devSvcMgrIf = &inst->super; devSvcMgrIf->AddService = DevSvcManagerAddService; + devSvcMgrIf->UpdateService = DevSvcManagerUpdateService; devSvcMgrIf->SubscribeService = DevSvcManagerSubscribeService; devSvcMgrIf->UnsubscribeService = NULL; devSvcMgrIf->RemoveService = DevSvcManagerRemoveService; devSvcMgrIf->GetService = DevSvcManagerGetService; devSvcMgrIf->GetObject = DevSvcManagerGetObject; - HdfSListInit(&inst->services); + devSvcMgrIf->RegsterServListener = DevSvcManagerRegsterServListener; + devSvcMgrIf->UnregsterServListener = DevSvcManagerUnregsterServListener; if (OsalMutexInit(&inst->mutex) != HDF_SUCCESS) { HDF_LOGE("failed to create device service manager mutex"); return false; } + DListHeadInit(&inst->services); + DListHeadInit(&inst->svcstatListeners); return true; } +int DevSvcManagerStartService(void) +{ + int ret; + struct IDevSvcManager *svcmgr = DevSvcManagerGetInstance(); + + if (svcmgr == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + if (svcmgr->StartService == NULL) { + return HDF_SUCCESS; + } + + ret = svcmgr->StartService(svcmgr); + if (ret != HDF_SUCCESS) { + HDF_LOGE("failed to start service manager"); + } + + return ret; +} + struct HdfObject *DevSvcManagerCreate() { static bool isDevSvcManagerInit = false; @@ -154,13 +297,17 @@ struct HdfObject *DevSvcManagerCreate() return (struct HdfObject *)&devSvcManagerInstance; } -void DevSvcManagerRelease(struct HdfObject *object) +void DevSvcManagerRelease(struct IDevSvcManager *inst) { - struct DevSvcManager *devSvcManager = (struct DevSvcManager *)object; - if (object == NULL) { + struct DevSvcManager *devSvcManager = CONTAINER_OF(inst, struct DevSvcManager, super); + if (inst == NULL) { return; } - HdfSListFlush(&devSvcManager->services, DevSvcRecordDelete); + struct DevSvcRecord *record = NULL; + struct DevSvcRecord *tmp = NULL; + DLIST_FOR_EACH_ENTRY_SAFE(record, tmp, &devSvcManager->services, struct DevSvcRecord, entry) { + DevSvcRecordFreeInstance(record); + } OsalMutexDestroy(&devSvcManager->mutex); } diff --git a/core/manager/src/devsvc_manager_ext.c b/core/manager/src/devsvc_manager_ext.c new file mode 100644 index 0000000000000000000000000000000000000000..d38b2eea668c0cc07bb85f368c03bb06aae92712 --- /dev/null +++ b/core/manager/src/devsvc_manager_ext.c @@ -0,0 +1,209 @@ +/* + * Copyright (c) 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 "devsvc_listener_holder.h" +#include "devsvc_manager.h" +#include "hdf_base.h" +#include "hdf_device_node.h" +#include "hdf_io_service.h" +#include "hdf_log.h" +#include "hdf_object_manager.h" +#include "osal_mem.h" +#include "svcmgr_ioservice.h" +#include "osal_mutex.h" + +#define HDF_LOG_TAG devsvc_mger +#define SVC_MGR_NODE_PERM 0660 + +struct DevSvcManagerExt { + struct DevSvcManager super; + struct IDeviceIoService ioService; + struct HdfIoService *serv; + struct OsalMutex mutex; + bool started; +}; + +int32_t DeviceSvcMgrOpen(struct HdfDeviceIoClient *client) +{ + (void)client; + return HDF_SUCCESS; +} + +static int32_t DevSvcManagerExtRegisterListener(struct HdfDeviceIoClient *client, struct HdfSBuf *data) +{ + struct ServStatListenerHolder *holder = NULL; + uint16_t devClass = DEVICE_CLASS_MAX; + struct DevSvcManagerExt *svcmgrInst = NULL; + if (client->device == NULL || client->device->priv == NULL) { + return HDF_ERR_INVALID_PARAM; + } + svcmgrInst = (struct DevSvcManagerExt *)DevSvcManagerGetInstance(); + + if (!HdfSbufReadUint16(data, &devClass)) { + return HDF_ERR_INVALID_PARAM; + } + + holder = ServStatListenerHolderGet((uintptr_t)client); + if (holder != NULL) { + HDF_LOGE("%s:register listener exist, update and return", __func__); + holder->listenClass = devClass; + return HDF_SUCCESS; + } + + holder = ServStatListenerHolderCreate((uintptr_t)client, devClass); + if (holder == NULL) { + return HDF_ERR_MALLOC_FAIL; + } + + return svcmgrInst->super.super.RegsterServListener(&svcmgrInst->super.super, holder); +} + +static int32_t DevSvcManagerExtUnRegisterListener(struct HdfDeviceIoClient *client) +{ + struct ServStatListenerHolder *holder = NULL; + struct DevSvcManagerExt *svcmgrInst = NULL; + + if (client->device == NULL || client->device->priv == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + svcmgrInst = (struct DevSvcManagerExt *)client->device->priv; + OsalMutexLock(&svcmgrInst->mutex); + holder = ServStatListenerHolderGet((uintptr_t)client); + if (holder == NULL) { + OsalMutexUnlock(&svcmgrInst->mutex); + return HDF_DEV_ERR_NO_DEVICE_SERVICE; + } + if (holder->node.next != NULL) { + svcmgrInst->super.super.UnregsterServListener(&svcmgrInst->super.super, holder); + } + ServStatListenerHolderRelease(holder); + OsalMutexUnlock(&svcmgrInst->mutex); + + return HDF_SUCCESS; +} + +int32_t DeviceSvcMgrDispatch(struct HdfObject *service, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + uint64_t ioClientPtr = 0; + struct HdfDeviceIoClient *client = NULL; + if (service == NULL || data == NULL || reply == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (!HdfSbufReadUint64(reply, &ioClientPtr) || ioClientPtr == 0) { + HDF_LOGE("device svc dispatch: ioClient is null"); + return HDF_FAILURE; + } + HdfSbufFlush(reply); + client = (struct HdfDeviceIoClient *)(uintptr_t)ioClientPtr; + switch (cmdId) { + case SVCMGR_REGISTER_LISTENER: + return DevSvcManagerExtRegisterListener(client, data); + case SVCMGR_UNREGISTER_LISTENER: + return DevSvcManagerExtUnRegisterListener(client); + default: + break; + } + + return HDF_ERR_NOT_SUPPORT; +} + +void DeviceSvcMgrRelease(struct HdfDeviceIoClient *client) +{ + if (client == NULL) { + return; + } + DevSvcManagerExtUnRegisterListener(client); +} + +int DevSvcManagerExtStart(struct IDevSvcManager *svcmgr) +{ + struct DevSvcManagerExt *inst = (struct DevSvcManagerExt *)svcmgr; + static struct HdfDeviceObject svcmgrDevObj = { 0 }; + static struct IDeviceIoService svcmgrIoService = { + .Open = DeviceSvcMgrOpen, + .Dispatch = NULL, + .Release = DeviceSvcMgrRelease, + }; + if (inst == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (inst->started) { + return HDF_SUCCESS; + } + + svcmgrDevObj.service = &svcmgrIoService; + svcmgrDevObj.property = NULL; + svcmgrDevObj.deviceClass = DEVICE_CLASS_DEFAULT; + svcmgrDevObj.priv = (void *)svcmgr; + + inst->serv = HdfIoServicePublish(DEV_SVCMGR_NODE, SVC_MGR_NODE_PERM); + if (inst->serv == NULL) { + HDF_LOGE("failed to pushlish svcmgr ioservice"); + } else { + static struct HdfIoDispatcher dispatcher = { + .Dispatch = DeviceSvcMgrDispatch, + }; + inst->serv->dispatcher = &dispatcher; + inst->serv->target = (struct HdfObject *)&svcmgrDevObj; + } + + ServStatListenerHolderinit(); + inst->started = true; + return HDF_SUCCESS; +} + +static bool DevSvcManagerExtConstruct(struct DevSvcManagerExt *inst) +{ + if (inst == NULL) { + return false; + } + if (!DevSvcManagerConstruct(&inst->super)) { + HDF_LOGE("failed to construct device service manager"); + return false; + } + if (OsalMutexInit(&inst->mutex) != HDF_SUCCESS) { + HDF_LOGE("failed to create devsvcmgrext mutex"); + return false; + } + inst->super.super.StartService = DevSvcManagerExtStart; + + return true; +} + +struct HdfObject *DevSvcManagerExtCreate(void) +{ + static struct DevSvcManagerExt *instance; + if (instance != NULL) { + return (struct HdfObject *)instance; + } + + instance = OsalMemCalloc(sizeof(struct DevSvcManagerExt)); + if (!DevSvcManagerExtConstruct(instance)) { + OsalMemFree(instance); + instance = NULL; + } + + return (struct HdfObject *)instance; +} + +void DevSvcManagerExtRelease(struct IDevSvcManager *inst) +{ + struct DevSvcManagerExt *instance = (struct DevSvcManagerExt *)inst; + if (instance == NULL) { + return; + } + if (instance->serv != NULL) { + HdfIoServiceRemove(instance->serv); + instance->serv = NULL; + } + DevSvcManagerRelease(inst); + instance->started = false; +} diff --git a/core/manager/src/driver_manager.c b/core/manager/src/driver_manager.c new file mode 100644 index 0000000000000000000000000000000000000000..548095598b3c239047b1896c644438a99ff45bff --- /dev/null +++ b/core/manager/src/driver_manager.c @@ -0,0 +1,122 @@ +/* + * 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_dlist.h" +#include "hdf_driver.h" +#include "hdf_log.h" +#include "osal_mem.h" + +static struct DListHead *HdfDriverHead() +{ + static struct DListHead driverHead = { 0 }; + if (driverHead.next == NULL) { + DListHeadInit(&driverHead); + } + + return &driverHead; +} + +int32_t HdfRegisterDriverEntry(const struct HdfDriverEntry *entry) +{ + struct HdfDriver *newDriver = NULL; + + if (entry == NULL || entry->moduleName == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + newDriver = OsalMemCalloc(sizeof(struct HdfDriver)); + if (newDriver == NULL) { + return HDF_DEV_ERR_NO_MEMORY; + } + + newDriver->entry = entry; + + DListInsertTail(&newDriver->node, HdfDriverHead()); + + return HDF_SUCCESS; +} + +int32_t HdfUnregisterDriverEntry(const struct HdfDriverEntry *entry) +{ + struct DListHead *driverHead = NULL; + struct HdfDriver *driver = NULL; + struct HdfDriver *tmp = NULL; + + if (entry == NULL || entry->moduleName == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + driverHead = HdfDriverHead(); + DLIST_FOR_EACH_ENTRY_SAFE(driver, tmp, driverHead, struct HdfDriver, node) + { + if (driver->entry == entry) { + DListRemove(&driver->node); + OsalMemFree(driver); + break; + } + } + + return HDF_SUCCESS; +} + +int32_t HdfRegisterDriver(struct HdfDriver *driver) +{ + if (driver == NULL || driver->entry == NULL || driver->entry->moduleName == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + DListInsertTail(&driver->node, HdfDriverHead()); + return HDF_SUCCESS; +} + +int32_t HdfUnregisterDriver(struct HdfDriver *driver) +{ + struct DListHead *driverHead = NULL; + struct HdfDriver *it = NULL; + struct HdfDriver *tmp = NULL; + + if (driver == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + driverHead = HdfDriverHead(); + DLIST_FOR_EACH_ENTRY_SAFE(it, tmp, driverHead, struct HdfDriver, node) + { + if (it == driver) { + DListRemove(&it->node); + break; + } + } + + return HDF_SUCCESS; +} + +struct HdfDriver *HdfDriverManagerGetDriver(const char *driverName) +{ + struct DListHead *driverHead = NULL; + struct HdfDriver *driver = NULL; + + if (driverName == NULL) { + return NULL; + } + + driverHead = HdfDriverHead(); + DLIST_FOR_EACH_ENTRY(driver, driverHead, struct HdfDriver, node) { + if (driver->entry != NULL && driver->entry->moduleName != NULL && + !strcmp(driver->entry->moduleName, driverName)) { + return driver; + } + } + HDF_LOGE("%s:driver %s not found", __func__, driverName); + return NULL; +} + +struct DListHead *HdfDriverManagerGetDriverList() +{ + return HdfDriverHead(); +} diff --git a/core/manager/src/hdf_driver_installer.c b/core/manager/src/hdf_driver_installer.c index 4071b2eec717d74b263b07bf5c4088b1544ad2e1..b972ce74397f8726ca688463f4e17b5a24665b9e 100644 --- a/core/manager/src/hdf_driver_installer.c +++ b/core/manager/src/hdf_driver_installer.c @@ -8,7 +8,6 @@ #include "hdf_driver_installer.h" #include "devhost_service.h" -#include "hdf_base.h" #include "hdf_log.h" #include "hdf_object_manager.h" @@ -17,11 +16,12 @@ static int DriverInstallerStartDeviceHost(uint32_t devHostId, const char *devHostName) { struct IDevHostService *hostServiceIf = DevHostServiceNewInstance(devHostId, devHostName); + int ret; if ((hostServiceIf == NULL) || (hostServiceIf->StartService == NULL)) { HDF_LOGE("hostServiceIf or hostServiceIf->StartService is null"); return HDF_FAILURE; } - int ret = hostServiceIf->StartService(hostServiceIf); + ret = hostServiceIf->StartService(hostServiceIf); if (ret != HDF_SUCCESS) { HDF_LOGE("failed to start host service, ret: %d", ret); DevHostServiceFreeInstance(hostServiceIf); diff --git a/core/manager/src/servstat_listener_holder.c b/core/manager/src/servstat_listener_holder.c new file mode 100644 index 0000000000000000000000000000000000000000..25f305c39aa0f94ab732752bc10652861b37b26b --- /dev/null +++ b/core/manager/src/servstat_listener_holder.c @@ -0,0 +1,127 @@ +/* + * Copyright (c) 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 "devsvc_listener_holder.h" +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "hdf_log.h" +#include "osal_mutex.h" +#include "osal_mem.h" + +struct KServStatListenerHolder { + struct DListHead node; + struct ServStatListenerHolder holder; + struct HdfDeviceIoClient *listenerClient; +}; + +struct SvcStatListenerHolderList { + struct OsalMutex mutex; + struct DListHead list; +}; + +static struct SvcStatListenerHolderList g_holoderList; + +static void KServStatListenerHolderListInit() +{ + OsalMutexInit(&g_holoderList.mutex); + DListHeadInit(&g_holoderList.list); +} + +void ServStatListenerHolderinit(void) +{ + KServStatListenerHolderListInit(); +} + +void KServStatListenerHolderNotifyStatus(struct ServStatListenerHolder *holder, + struct ServiceStatus *status) +{ + if (holder == NULL || status == NULL) { + return; + } + struct KServStatListenerHolder *holderInst = CONTAINER_OF(holder, struct KServStatListenerHolder, holder); + if (holderInst->listenerClient == NULL) { + HDF_LOGE("failed to notify service status, invalid holder"); + return; + } + + struct HdfSBuf *data = HdfSBufObtainDefaultSize(); + if (data == NULL) { + HDF_LOGE("failed to notify service status, oom"); + return; + } + + if (ServiceStatusMarshalling(status, data) != HDF_SUCCESS) { + HDF_LOGE("failed to marshalling service status"); + HdfSBufRecycle(data); + return; + } + + if (HdfDeviceSendEventToClient(holderInst->listenerClient, 0, data) != HDF_SUCCESS) { + HDF_LOGE("failed to notify service status, send error"); + } + + HdfSBufRecycle(data); +} + +struct ServStatListenerHolder *ServStatListenerHolderCreate(uintptr_t listener, uint16_t listenClass) +{ + struct HdfDeviceIoClient *client = (struct HdfDeviceIoClient *)listener; + struct KServStatListenerHolder *holder = NULL; + + if (listener == 0) { + return NULL; + } + + holder = OsalMemCalloc(sizeof(struct KServStatListenerHolder)); + if (holder == NULL) { + return NULL; + } + holder->listenerClient = client; + holder->holder.index = listener; + holder->holder.listenClass = listenClass; + holder->holder.NotifyStatus = KServStatListenerHolderNotifyStatus; + + OsalMutexLock(&g_holoderList.mutex); + DListInsertTail(&holder->node, &g_holoderList.list); + OsalMutexUnlock(&g_holoderList.mutex); + return &holder->holder; +} + +struct ServStatListenerHolder *ServStatListenerHolderGet(uint64_t index) +{ + struct KServStatListenerHolder *it = NULL; + struct KServStatListenerHolder *holder = NULL; + + OsalMutexLock(&g_holoderList.mutex); + DLIST_FOR_EACH_ENTRY(it, &g_holoderList.list, struct KServStatListenerHolder, node) { + if (it->holder.index == index) { + holder = it; + break; + } + } + OsalMutexUnlock(&g_holoderList.mutex); + return holder != NULL ? &holder->holder : NULL; +} + +void ServStatListenerHolderRelease(struct ServStatListenerHolder *holder) +{ + struct KServStatListenerHolder *holderInst = NULL; + if (holder == NULL) { + return; + } + + holderInst = CONTAINER_OF(holder, struct KServStatListenerHolder, holder); + OsalMutexLock(&g_holoderList.mutex); + if (holderInst->node.next != NULL) { + DListRemove(&holderInst->node); + } + OsalMutexUnlock(&g_holoderList.mutex); + + holderInst->listenerClient = NULL; + OsalMemFree(holderInst); +} + diff --git a/core/manager/test/unittest/common/hdf_ioservice_test.cpp b/core/manager/test/unittest/common/hdf_ioservice_test.cpp index 6dd938c08b888b982eae736c6eb797695dd39029..e0dfa25c4ebf94034ab50eccde4ac5d5a2472d4f 100644 --- a/core/manager/test/unittest/common/hdf_ioservice_test.cpp +++ b/core/manager/test/unittest/common/hdf_ioservice_test.cpp @@ -6,20 +6,23 @@ * See the LICENSE file in the root of this repository for complete details. */ +#include "hdf_io_service.h" +#include "hdf_log.h" +#include "hdf_power_state.h" +#include "hdf_uhdf_test.h" +#include "osal_time.h" +#include "sample_driver_test.h" #include #include #include #include -#include +#include +#include #include +#include +#include +#include #include -#include -#include "hdf_uhdf_test.h" -#include "hdf_io_service.h" -#include "osal_time.h" -#include "sample_driver_test.h" -#include "hdf_log.h" -#include "hdf_power_state.h" using namespace testing::ext; @@ -34,14 +37,15 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); - static int OnDevEventReceived(struct HdfDevEventlistener *listener, struct HdfIoService *service, uint32_t id, - struct HdfSBuf *data); + static int OnDevEventReceived( + struct HdfDevEventlistener *listener, struct HdfIoService *service, uint32_t id, struct HdfSBuf *data); static struct Eventlistener listener0; static struct Eventlistener listener1; const char *testSvcName = SAMPLE_SERVICE; const int eventWaitTimeUs = (150 * 1000); static int eventCount; + const int servstatWaitTime = 15; // ms }; int IoServiceTest::eventCount = 0; @@ -58,7 +62,9 @@ void IoServiceTest::SetUpTestCase() listener1.listener.priv = (void *)"listener1"; } -void IoServiceTest::TearDownTestCase() {} +void IoServiceTest::TearDownTestCase() +{ +} void IoServiceTest::SetUp() { @@ -67,15 +73,17 @@ void IoServiceTest::SetUp() eventCount = 0; } -void IoServiceTest::TearDown() {} +void IoServiceTest::TearDown() +{ +} -int IoServiceTest::OnDevEventReceived(struct HdfDevEventlistener *listener, struct HdfIoService *service, uint32_t id, - struct HdfSBuf *data) +int IoServiceTest::OnDevEventReceived( + struct HdfDevEventlistener *listener, struct HdfIoService *service, uint32_t id, struct HdfSBuf *data) { OsalTimespec time; OsalGetTime(&time); - HDF_LOGE("%s: received event[%d] from %s at %" PRIu64 ".%" PRIu64 "", (char *)listener->priv, eventCount++, (char *)service->priv, - time.sec, time.usec); + HDF_LOGE("%s: received event[%d] from %s at %" PRIu64 ".%" PRIu64 "", (char *)listener->priv, eventCount++, + (char *)service->priv, time.sec, time.usec); const char *string = HdfSbufReadString(data); if (string == nullptr) { @@ -88,7 +96,7 @@ int IoServiceTest::OnDevEventReceived(struct HdfDevEventlistener *listener, stru return 0; } -static int SendEvent(struct HdfIoService *serv, const char *eventData) +static int SendEvent(struct HdfIoService *serv, const char *eventData, bool broadcast) { OsalTimespec time; OsalGetTime(&time); @@ -107,6 +115,7 @@ static int SendEvent(struct HdfIoService *serv, const char *eventData) return HDF_DEV_ERR_NO_MEMORY; } + uint32_t cmdId = broadcast ? SAMPLE_DRIVER_SENDEVENT_BROADCAST_DEVICE : SAMPLE_DRIVER_SENDEVENT_SINGLE_DEVICE; do { if (!HdfSbufWriteString(data, eventData)) { HDF_LOGE("fail to write sbuf"); @@ -114,7 +123,7 @@ static int SendEvent(struct HdfIoService *serv, const char *eventData) break; } - ret = serv->dispatcher->Dispatch(&serv->object, SAMPLE_DRIVER_SENDEVENT_SINGLE_DEVICE, data, reply); + ret = serv->dispatcher->Dispatch(&serv->object, cmdId, data, reply); if (ret != HDF_SUCCESS) { HDF_LOGE("fail to send service call"); break; @@ -170,7 +179,7 @@ HWTEST_F(IoServiceTest, HdfIoService002, TestSize.Level0) ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -189,7 +198,7 @@ HWTEST_F(IoServiceTest, HdfIoService002, TestSize.Level0) ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -224,7 +233,7 @@ HWTEST_F(IoServiceTest, HdfIoService003, TestSize.Level0) ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -242,7 +251,7 @@ HWTEST_F(IoServiceTest, HdfIoService003, TestSize.Level0) ret = HdfDeviceRegisterEventListener(serv, &listener1.listener); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -268,7 +277,7 @@ HWTEST_F(IoServiceTest, HdfIoService004, TestSize.Level0) int ret = HdfDeviceRegisterEventListener(serv1, &listener0.listener); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv1, testSvcName); + ret = SendEvent(serv1, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -300,7 +309,7 @@ HWTEST_F(IoServiceTest, HdfIoService005, TestSize.Level0) ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -311,7 +320,7 @@ HWTEST_F(IoServiceTest, HdfIoService005, TestSize.Level0) ret = HdfIoServiceGroupAddService(group, serv); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -319,7 +328,6 @@ HWTEST_F(IoServiceTest, HdfIoService005, TestSize.Level0) HdfIoServiceGroupRecycle(group); } - /* * * @tc.name: HdfIoService006 * @tc.desc: service group add remove listener test @@ -348,13 +356,13 @@ HWTEST_F(IoServiceTest, HdfIoService006, TestSize.Level0) ret = HdfIoServiceGroupAddService(group, serv1); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); ASSERT_EQ(1, listener0.eventCount); - ret = SendEvent(serv1, testSvcName); + ret = SendEvent(serv1, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -362,13 +370,13 @@ HWTEST_F(IoServiceTest, HdfIoService006, TestSize.Level0) HdfIoServiceGroupRemoveService(group, serv); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); ASSERT_EQ(2, listener0.eventCount); - ret = SendEvent(serv1, testSvcName); + ret = SendEvent(serv1, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -377,7 +385,7 @@ HWTEST_F(IoServiceTest, HdfIoService006, TestSize.Level0) ret = HdfIoServiceGroupAddService(group, serv); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -388,7 +396,6 @@ HWTEST_F(IoServiceTest, HdfIoService006, TestSize.Level0) HdfIoServiceRecycle(serv1); } - /* * * @tc.name: HdfIoService007 * @tc.desc: duplicate remove group listener @@ -410,7 +417,7 @@ HWTEST_F(IoServiceTest, HdfIoService007, TestSize.Level0) ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -447,7 +454,7 @@ HWTEST_F(IoServiceTest, HdfIoService008, TestSize.Level0) ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -487,7 +494,7 @@ HWTEST_F(IoServiceTest, HdfIoService009, TestSize.Level0) ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -524,7 +531,7 @@ HWTEST_F(IoServiceTest, HdfIoService010, TestSize.Level0) ret = HdfIoServiceGroupRegisterListener(group, &listener0.listener); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -555,7 +562,7 @@ HWTEST_F(IoServiceTest, HdfIoService011, TestSize.Level0) int ret = HdfDeviceRegisterEventListener(serv, &listener0.listener); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -584,7 +591,7 @@ HWTEST_F(IoServiceTest, HdfIoService012, TestSize.Level0) int ret = HdfDeviceRegisterEventListener(serv, &listener0.listener); ASSERT_EQ(ret, HDF_SUCCESS); - ret = SendEvent(serv, testSvcName); + ret = SendEvent(serv, testSvcName, false); ASSERT_EQ(ret, HDF_SUCCESS); usleep(eventWaitTimeUs); @@ -633,3 +640,269 @@ HWTEST_F(IoServiceTest, HdfIoService013, TestSize.Level0) HdfIoServiceRecycle(serv); HdfSBufRecycle(data); } + +/* * + * @tc.name: HdfIoService014 + * @tc.desc: multiple clients listen to a service + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(IoServiceTest, HdfIoService014, TestSize.Level0) +{ + struct HdfIoServiceGroup *group = HdfIoServiceGroupObtain(); + ASSERT_NE(group, nullptr); + + struct HdfIoService *serv = HdfIoServiceBind(testSvcName); + ASSERT_NE(serv, nullptr); + serv->priv = (void *)"serv"; + + struct HdfIoService *serv1 = HdfIoServiceBind(testSvcName); + ASSERT_NE(serv1, nullptr); + serv1->priv = (void *)"serv1"; + + int ret = HdfDeviceRegisterEventListener(serv, &listener0.listener); + ASSERT_EQ(ret, HDF_SUCCESS); + + ret = HdfDeviceRegisterEventListener(serv1, &listener1.listener); + ASSERT_EQ(ret, HDF_SUCCESS); + + ret = SendEvent(serv, testSvcName, true); + ASSERT_EQ(ret, HDF_SUCCESS); + + usleep(eventWaitTimeUs); + ASSERT_EQ(1, listener0.eventCount); + ASSERT_EQ(1, listener1.eventCount); + + ret = HdfDeviceUnregisterEventListener(serv, &listener0.listener); + ASSERT_EQ(ret, HDF_SUCCESS); + + ret = HdfDeviceUnregisterEventListener(serv, &listener0.listener); + EXPECT_NE(ret, HDF_SUCCESS); + + ret = HdfDeviceUnregisterEventListener(serv1, &listener1.listener); + ASSERT_EQ(ret, HDF_SUCCESS); + + HdfIoServiceRecycle(serv); + HdfIoServiceRecycle(serv1); +} + +struct IoServiceStatusData { + IoServiceStatusData() + : devClass(0) + , servStatus(0) + , callbacked(false) + { + } + ~IoServiceStatusData() = default; + std::string servName; + std::string servInfo; + uint16_t devClass; + uint16_t servStatus; + bool callbacked; +}; + +static void TestOnServiceStatusReceived(struct ServiceStatusListener *listener, struct ServiceStatus *servstat) +{ + struct IoServiceStatusData *issd = (struct IoServiceStatusData *)listener->priv; + if (issd == NULL) { + return; + } + issd->servName = servstat->serviceName; + issd->servInfo = servstat->info != NULL ? servstat->info : ""; + issd->devClass = servstat->deviceClass; + issd->servStatus = servstat->status; + issd->callbacked = true; + + HDF_LOGI("service status listener callback: %{public}s, %{public}s, %{public}d", servstat->serviceName, + issd->servName.data(), issd->servStatus); +} + +/* * + * @tc.name: HdfIoService015 + * @tc.desc: ioservice status listener test + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(IoServiceTest, HdfIoService015, TestSize.Level0) +{ + struct ISvcMgrIoservice *servmgr = SvcMgrIoserviceGet(); + ASSERT_NE(servmgr, nullptr); + + struct HdfIoService *serv = HdfIoServiceBind(testSvcName); + ASSERT_NE(serv, nullptr); + serv->priv = (void *)"serv"; + + struct IoServiceStatusData issd; + struct ServiceStatusListener *listener = IoServiceStatusListenerNewInstance(); + listener->callback = TestOnServiceStatusReceived; + listener->priv = (void *)&issd; + + int status = servmgr->RegisterServiceStatusListener(servmgr, listener, DEVICE_CLASS_DEFAULT); + ASSERT_EQ(status, HDF_SUCCESS); + + struct HdfIoService *testService = HdfIoServiceBind(SAMPLE_SERVICE); + ASSERT_TRUE(testService != NULL); + struct HdfSBuf *data = HdfSBufObtainDefaultSize(); + ASSERT_TRUE(data != NULL); + const char *newServName = "sample_service1"; + ASSERT_TRUE(HdfSbufWriteString(data, "sample_driver")); + ASSERT_TRUE(HdfSbufWriteString(data, newServName)); + + int ret = testService->dispatcher->Dispatch(&testService->object, SAMPLE_DRIVER_REGISTER_DEVICE, data, NULL); + ASSERT_EQ(ret, HDF_SUCCESS); + + int count = servstatWaitTime; + while (!issd.callbacked && count > 0) { + OsalMSleep(1); + count--; + } + ASSERT_TRUE(issd.callbacked); + ASSERT_EQ(issd.servName, newServName); + ASSERT_EQ(issd.devClass, DEVICE_CLASS_DEFAULT); + ASSERT_EQ(issd.servInfo, std::string(SAMPLE_SERVICE)); + ASSERT_EQ(issd.servStatus, SERVIE_STATUS_START); + + issd.callbacked = false; + ret = testService->dispatcher->Dispatch(&testService->object, SAMPLE_DRIVER_UNREGISTER_DEVICE, data, NULL); + ASSERT_TRUE(ret == HDF_SUCCESS); + + count = servstatWaitTime; + while (!issd.callbacked && count > 0) { + OsalMSleep(1); + count--; + } + ASSERT_TRUE(issd.callbacked); + ASSERT_EQ(issd.servName, newServName); + ASSERT_EQ(issd.devClass, DEVICE_CLASS_DEFAULT); + ASSERT_EQ(issd.servInfo, std::string(SAMPLE_SERVICE)); + ASSERT_EQ(issd.servStatus, SERVIE_STATUS_STOP); + + status = servmgr->UnregisterServiceStatusListener(servmgr, listener); + ASSERT_EQ(status, HDF_SUCCESS); + + IoServiceStatusListenerFree(listener); + HdfIoServiceRecycle(testService); + SvcMgrIoserviceRelease(servmgr); + HdfSBufRecycle(data); +} + +/* * + * @tc.name: HdfIoService016 + * @tc.desc: ioservice status listener update info test + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(IoServiceTest, HdfIoService016, TestSize.Level0) +{ + struct ISvcMgrIoservice *servmgr = SvcMgrIoserviceGet(); + ASSERT_NE(servmgr, nullptr); + + struct HdfIoService *serv = HdfIoServiceBind(testSvcName); + ASSERT_NE(serv, nullptr); + serv->priv = (void *)"serv"; + + struct IoServiceStatusData issd; + struct ServiceStatusListener *listener = IoServiceStatusListenerNewInstance(); + listener->callback = TestOnServiceStatusReceived; + listener->priv = (void *)&issd; + + HDF_LOGI("YDEBUG:%{public}s:%{public}d", __func__, __LINE__); + int status = servmgr->RegisterServiceStatusListener(servmgr, listener, DEVICE_CLASS_DEFAULT); + ASSERT_EQ(status, HDF_SUCCESS); + + HDF_LOGI("YDEBUG:%{public}s:%{public}d", __func__, __LINE__); + struct HdfIoService *testService = HdfIoServiceBind(SAMPLE_SERVICE); + ASSERT_TRUE(testService != NULL); + HdfSBuf *data = HdfSBufObtainDefaultSize(); + ASSERT_TRUE(data != NULL); + + HDF_LOGI("YDEBUG:%{public}s:%{public}d", __func__, __LINE__); + std::string servinfo = "foo"; + ASSERT_TRUE(HdfSbufWriteString(data, servinfo.data())); + int ret = testService->dispatcher->Dispatch(&testService->object, SAMPLE_DRIVER_UPDATE_SERVICE_INFO, data, NULL); + ASSERT_EQ(ret, HDF_SUCCESS); + + HDF_LOGI("YDEBUG:%{public}s:%{public}d", __func__, __LINE__); + int count = servstatWaitTime; + while (!issd.callbacked && count > 0) { + OsalMSleep(1); + count--; + } + HDF_LOGI("YDEBUG:%{public}s:%{public}d", __func__, __LINE__); + ASSERT_TRUE(issd.callbacked); + ASSERT_EQ(issd.servName, SAMPLE_SERVICE); + ASSERT_EQ(issd.devClass, DEVICE_CLASS_DEFAULT); + ASSERT_EQ(issd.servInfo, servinfo); + ASSERT_EQ(issd.servStatus, SERVIE_STATUS_CHANGE); + + status = servmgr->UnregisterServiceStatusListener(servmgr, listener); + ASSERT_EQ(status, HDF_SUCCESS); + + IoServiceStatusListenerFree(listener); + HdfIoServiceRecycle(testService); + SvcMgrIoserviceRelease(servmgr); + HdfSBufRecycle(data); +} + +/* * + * @tc.name: HdfIoService017 + * @tc.desc: ioservice status listener unregister test + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(IoServiceTest, HdfIoService017, TestSize.Level0) +{ + struct ISvcMgrIoservice *servmgr = SvcMgrIoserviceGet(); + ASSERT_NE(servmgr, nullptr); + + struct HdfIoService *serv = HdfIoServiceBind(testSvcName); + ASSERT_NE(serv, nullptr); + serv->priv = (void *)"serv"; + + struct IoServiceStatusData issd; + struct ServiceStatusListener *listener = IoServiceStatusListenerNewInstance(); + listener->callback = TestOnServiceStatusReceived; + listener->priv = (void *)&issd; + + HDF_LOGI("%{public}s:%{public}d", __func__, __LINE__); + int status = servmgr->RegisterServiceStatusListener(servmgr, listener, DEVICE_CLASS_DEFAULT); + ASSERT_EQ(status, HDF_SUCCESS); + + struct HdfIoService *testService = HdfIoServiceBind(SAMPLE_SERVICE); + ASSERT_TRUE(testService != NULL); + HdfSBuf *data = HdfSBufObtainDefaultSize(); + ASSERT_TRUE(data != NULL); + const char *newServName = "sample_service1"; + ASSERT_TRUE(HdfSbufWriteString(data, "sample_driver")); + ASSERT_TRUE(HdfSbufWriteString(data, newServName)); + int ret = testService->dispatcher->Dispatch(&testService->object, SAMPLE_DRIVER_REGISTER_DEVICE, data, NULL); + ASSERT_EQ(ret, HDF_SUCCESS); + + int count = 10; + while (!issd.callbacked && count > 0) { + OsalMSleep(1); + count--; + } + ASSERT_TRUE(issd.callbacked); + ASSERT_EQ(issd.servName, newServName); + ASSERT_EQ(issd.devClass, DEVICE_CLASS_DEFAULT); + ASSERT_EQ(issd.servInfo, std::string(SAMPLE_SERVICE)); + ASSERT_EQ(issd.servStatus, SERVIE_STATUS_START); + + status = servmgr->UnregisterServiceStatusListener(servmgr, listener); + ASSERT_EQ(status, HDF_SUCCESS); + + issd.callbacked = false; + ret = testService->dispatcher->Dispatch(&testService->object, SAMPLE_DRIVER_UNREGISTER_DEVICE, data, NULL); + ASSERT_EQ(status, HDF_SUCCESS); + + OsalMSleep(10); + + ASSERT_FALSE(issd.callbacked); + status = servmgr->UnregisterServiceStatusListener(servmgr, listener); + ASSERT_NE(status, HDF_SUCCESS); + IoServiceStatusListenerFree(listener); + HdfIoServiceRecycle(testService); + SvcMgrIoserviceRelease(servmgr); + HdfSBufRecycle(data); +} diff --git a/core/manager/test/unittest/common/hdf_lite_manager_test.cpp b/core/manager/test/unittest/common/hdf_lite_manager_test.cpp index 264a2fd74c1098f7ee271a20fa28bf35d8d16918..b6d2e1cad44a98a9d575d5105d96c8f387730cb4 100644 --- a/core/manager/test/unittest/common/hdf_lite_manager_test.cpp +++ b/core/manager/test/unittest/common/hdf_lite_manager_test.cpp @@ -96,7 +96,7 @@ HWTEST_F(HdfManagerTest, HdfRegisterDevice001, TestSize.Level0) EXPECT_TRUE((timeAfter - timeBefore) < 100); struct HdfIoService *ioService1 = HdfIoServiceBind("sample_service1"); - EXPECT_TRUE(ioService1 != NULL); + ASSERT_TRUE(ioService1 != NULL); HdfIoServiceRecycle(ioService1); ret = ioService->dispatcher->Dispatch(&ioService->object, SAMPLE_DRIVER_UNREGISTER_DEVICE, data, NULL); @@ -117,21 +117,26 @@ HWTEST_F(HdfManagerTest, HdfRegisterDevice001, TestSize.Level0) */ HWTEST_F(HdfManagerTest, HdfGetServiceNameByDeviceClass001, TestSize.Level0) { - struct HdfSBuf *data = HdfSBufObtain(1000); + struct HdfSBuf *data = HdfSBufObtain(2000); ASSERT_TRUE(data != NULL); - int32_t ret = HdfGetServiceNameByDeviceClass(DEVICE_CLASS_DEFAULT, data); - EXPECT_TRUE(ret == HDF_SUCCESS); + bool flag = false; - const char *svcName = NULL; - while(true) { - svcName = HdfSbufReadString(data); - if (svcName == NULL) { - break; - } - if (strcmp(svcName, "sample_service") == 0) { - flag = true; - break; + for (size_t i = DEVICE_CLASS_DEFAULT; i < DEVICE_CLASS_MAX; i++) { + int32_t ret = HdfGetServiceNameByDeviceClass((DeviceClass)i, data); + std::cout << "clasee " << i << " device list:" << std::endl; + EXPECT_TRUE(ret == HDF_SUCCESS); + const char *svcName = NULL; + while(true) { + svcName = HdfSbufReadString(data); + if (svcName == NULL) { + break; + } + std::cout << svcName << std::endl; + if (strcmp(svcName, "sample_service") == 0) { + flag = true; + } } + HdfSbufFlush(data); } HdfSBufRecycle(data); EXPECT_TRUE(flag); diff --git a/core/manager/test/unittest/common/hdf_pm_test.cpp b/core/manager/test/unittest/common/hdf_pm_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..2dc86ac8281a424a824b756f08fb26f440c0771d --- /dev/null +++ b/core/manager/test/unittest/common/hdf_pm_test.cpp @@ -0,0 +1,324 @@ +/* + * Copyright (c) 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 +#include +#include +#include +#include +#include +#include +#include "hdf_io_service.h" +#include "hdf_pm_driver_test.h" + +using namespace testing::ext; + +class HdfPmTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); + static struct HdfIoService *ioService; +}; + +struct HdfIoService *HdfPmTest::ioService = NULL; + +void HdfPmTest::SetUpTestCase() +{ + ioService = HdfIoServiceBind("pm_test_service"); + ASSERT_TRUE(ioService != NULL); + ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_BEGEN, NULL, NULL); +} + +void HdfPmTest::TearDownTestCase() +{ + ASSERT_TRUE(ioService != NULL); + ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_END, NULL, NULL); + HdfIoServiceRecycle(ioService); +} + +void HdfPmTest::SetUp() +{ +} + +void HdfPmTest::TearDown() +{ +} + +/** + * @tc.name: HdfPmTestOneDriverOnce + * @tc.desc: test one driver + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestOneDriverOnce, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_ONE_DRIVER_ONCE, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestOneDriverTwice + * @tc.desc: test one driver + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestOneDriverTwice, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_ONE_DRIVER_TWICE, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestOneDriverTen + * @tc.desc: test one driver + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestOneDriverTen, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_ONE_DRIVER_TEN, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestOneDriverHundred + * @tc.desc: test one driver + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestOneDriverHundred, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_ONE_DRIVER_HUNDRED, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestOneDriverThousand + * @tc.desc: test one driver + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestOneDriverThousand, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_ONE_DRIVER_THOUSAND, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestTwoDriverOnce + * @tc.desc: test two drivers + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestTwoDriverOnce, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_TWO_DRIVER_ONCE, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestTwoDriverTwice + * @tc.desc: test two drivers + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestTwoDriverTwice, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_TWO_DRIVER_TWICE, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestTwoDriverTen + * @tc.desc: test two drivers + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestTwoDriverTen, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_TWO_DRIVER_TEN, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestTwoDriverHundred + * @tc.desc: test two drivers + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestTwoDriverHundred, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_TWO_DRIVER_HUNDRED, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestTwoDriverThousand + * @tc.desc: test two drivers + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestTwoDriverThousand, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_TWO_DRIVER_THOUSAND, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestThreeDriverOnce + * @tc.desc: test three drivers + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestThreeDriverOnce, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_THREE_DRIVER_ONCE, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestThreeDriverTwice + * @tc.desc: test three drivers + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestThreeDriverTwice, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_THREE_DRIVER_TWICE, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestThreeDriverTen + * @tc.desc: test three drivers + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestThreeDriverTen, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_THREE_DRIVER_TEN, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestThreeDriverHundred + * @tc.desc: test three drivers + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestThreeDriverHundred, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_THREE_DRIVER_HUNDRED, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestThreeDriverThousand + * @tc.desc: test three drivers + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestThreeDriverThousand, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_THREE_DRIVER_THOUSAND, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestThreeDriverSeqHundred + * @tc.desc: test three drivers + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestThreeDriverSeqHundred, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_THREE_DRIVER_SEQ_HUNDRED, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} + +/** + * @tc.name: HdfPmTestThreeDriverHundredWithSync + * @tc.desc: test three drivers + * @tc.type: FUNC + * @tc.require: SR000GGTQF + */ +HWTEST_F(HdfPmTest, HdfPmTestThreeDriverHundredWithSync, TestSize.Level3) +{ + int32_t ret = HDF_FAILURE; + + ASSERT_TRUE(ioService != NULL); + + ret = ioService->dispatcher->Dispatch(&ioService->object, HDF_PM_TEST_THREE_DRIVER_HUNDRED_WITH_SYNC, NULL, NULL); + EXPECT_TRUE(ret == HDF_SUCCESS); +} diff --git a/core/shared/include/devhost_service_if.h b/core/shared/include/devhost_service_if.h index a1c22691577c2f837d5629204cda3a4816ca88eb..2a4513e9400cfa8969d3ced9c267cfefa6807d2a 100644 --- a/core/shared/include/devhost_service_if.h +++ b/core/shared/include/devhost_service_if.h @@ -9,13 +9,14 @@ #ifndef DEVHOST_SERVICE_IF_H #define DEVHOST_SERVICE_IF_H +#include "hdf_device.h" #include "hdf_device_info.h" #include "hdf_object.h" struct IDevHostService { struct HdfObject object; int (*AddDevice)(struct IDevHostService *hostService, const struct HdfDeviceInfo *devInfo); - int (*DelDevice)(struct IDevHostService *hostService, const struct HdfDeviceInfo *devInfo); + int (*DelDevice)(struct IDevHostService *hostService, devid_t devId); int (*StartService)(struct IDevHostService *hostService); int (*PmNotify)(struct IDevHostService *service, uint32_t powerState); }; diff --git a/core/shared/include/device_token_if.h b/core/shared/include/device_token_if.h index c086152ce1ad63ba3f64041fb00e34052d79b016..586f66e9f3e4db94606fff36e3432dfa6244019a 100644 --- a/core/shared/include/device_token_if.h +++ b/core/shared/include/device_token_if.h @@ -10,9 +10,11 @@ #define DEVICE_TOKEN_IF_H #include "hdf_object.h" +#include "hdf_device.h" struct IHdfDeviceToken { struct HdfObject object; + devid_t devid; }; #endif /* DEVICE_TOKEN_IF_H */ diff --git a/core/shared/include/devmgr_service_if.h b/core/shared/include/devmgr_service_if.h index 55df8e42633eae5438899ab97c318320c6f26978..ee3eb66112262fa4b3677a82251af79e057cf2f0 100644 --- a/core/shared/include/devmgr_service_if.h +++ b/core/shared/include/devmgr_service_if.h @@ -19,7 +19,10 @@ struct IDevmgrService { struct HdfObject base; struct HdfDeviceObject object; int (*AttachDeviceHost)(struct IDevmgrService *, uint16_t, struct IDevHostService *); - int (*AttachDevice)(struct IDevmgrService *, const struct HdfDeviceInfo *, struct IHdfDeviceToken *); + int (*AttachDevice)(struct IDevmgrService *, struct IHdfDeviceToken *); + int (*DetachDevice)(struct IDevmgrService *, devid_t); + int (*LoadDevice)(struct IDevmgrService *, const char *); + int (*UnloadDevice)(struct IDevmgrService *, const char *); int (*StartService)(struct IDevmgrService *); int (*PowerStateChange)(struct IDevmgrService *, enum HdfPowerState pEvent); }; diff --git a/core/shared/include/devsvc_manager_if.h b/core/shared/include/devsvc_manager_if.h index 394f4b507d547ce6b736e4536276b7cfc5496934..805dd43db63e770ffca76f885c6054e0c077d20c 100644 --- a/core/shared/include/devsvc_manager_if.h +++ b/core/shared/include/devsvc_manager_if.h @@ -9,17 +9,22 @@ #ifndef DEVSVC_MANAGER_IF_H #define DEVSVC_MANAGER_IF_H +#include "devsvc_listener_holder.h" #include "hdf_device_desc.h" #include "hdf_object.h" struct IDevSvcManager { struct HdfObject object; - int (*AddService)(struct IDevSvcManager *, const char *, struct HdfDeviceObject *); + int (*StartService)(struct IDevSvcManager *); + int (*AddService)(struct IDevSvcManager *, const char *, uint16_t, struct HdfDeviceObject *, const char *); + int (*UpdateService)(struct IDevSvcManager *, const char *, uint16_t, struct HdfDeviceObject *, const char *); int (*SubscribeService)(struct IDevSvcManager *, const char *, struct SubscriberCallback); int (*UnsubscribeService)(struct IDevSvcManager *, const char *); struct HdfObject *(*GetService)(struct IDevSvcManager *, const char *); struct HdfDeviceObject *(*GetObject)(struct IDevSvcManager *, const char *); void (*RemoveService)(struct IDevSvcManager *, const char *); + int (*RegsterServListener)(struct IDevSvcManager *, struct ServStatListenerHolder *); + void (*UnregsterServListener)(struct IDevSvcManager *, struct ServStatListenerHolder *); }; #endif /* DEVSVC_MANAGER_IF_H */ diff --git a/core/shared/include/hdf_attribute_manager.h b/core/shared/include/hdf_attribute_manager.h index 8138a5dbfcd54564f88a28779afb7f766f2b7673..33dab105a68befe49702895ea4c42c71e7ae3e62 100644 --- a/core/shared/include/hdf_attribute_manager.h +++ b/core/shared/include/hdf_attribute_manager.h @@ -10,11 +10,10 @@ #define HDF_ATTRIBUTE_MANAGER_H #include "hdf_slist.h" +#include "devhost_service_clnt.h" -const struct DeviceResourceNode *HdfGetRootNode(void); +const struct DeviceResourceNode *HdfGetHcsRootNode(void); bool HdfAttributeManagerGetHostList(struct HdfSList *hostList); -struct HdfSList *HdfAttributeManagerGetDeviceList(uint16_t hostId, const char *hostName); -bool HdfDeviceListAdd(const char *moduleName, const char *serviceName, const void *privateData); -void HdfDeviceListDel(const char *moduleName, const char *serviceName); +int HdfAttributeManagerGetDeviceList(struct DevHostServiceClnt *hostClnt); #endif /* HDF_ATTRIBUTE_MANAGER_H */ diff --git a/core/shared/include/hdf_device_info.h b/core/shared/include/hdf_device_info.h old mode 100755 new mode 100644 index 8852e83062d400b9835400ae40c29be172ed14be..9880181a3328f03c52e54af72b72632d8beafe6b --- a/core/shared/include/hdf_device_info.h +++ b/core/shared/include/hdf_device_info.h @@ -27,8 +27,7 @@ struct HdfDeviceInfo { bool isDynamic; uint16_t status; uint16_t deviceType; - uint16_t hostId; - uint16_t deviceId; + uint32_t deviceId; uint16_t policy; uint16_t priority; uint16_t preload; @@ -36,7 +35,6 @@ struct HdfDeviceInfo { const char *moduleName; const char *svcName; const char *deviceMatchAttr; - const void *private; }; struct HdfPrivateInfo { diff --git a/core/shared/include/hdf_driver.h b/core/shared/include/hdf_driver.h new file mode 100644 index 0000000000000000000000000000000000000000..1190e995ae33694bd4baa3f8348eda2f3ff64ced --- /dev/null +++ b/core/shared/include/hdf_driver.h @@ -0,0 +1,30 @@ +/* + * 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_DRIVER_H +#define HDF_DRIVER_H + +#include "hdf_device_desc.h" +#include "hdf_dlist.h" + +struct HdfDriver { + const struct HdfDriverEntry *entry; + uint16_t type; + uint16_t bus; + struct DListHead node; + void *priv; +}; + +int32_t HdfRegisterDriverEntry(const struct HdfDriverEntry *entry); +int32_t HdfUnregisterDriverEntry(const struct HdfDriverEntry *entry); +int32_t HdfRegisterDriver(struct HdfDriver *driver); +int32_t HdfUnregisterDriver(struct HdfDriver *driver); +struct HdfDriver *HdfDriverManagerGetDriver(const char *driverName); +struct DListHead *HdfDriverManagerGetDriverList(void); + +#endif // HDF_DRIVER_H \ No newline at end of file diff --git a/core/shared/include/hdf_service_record.h b/core/shared/include/hdf_service_record.h index 0e8651dc3f5cc51e5fb8630518afa8c68be22980..d3e5ec5aa94f9438485c7d5c5b29051ee6c1112d 100644 --- a/core/shared/include/hdf_service_record.h +++ b/core/shared/include/hdf_service_record.h @@ -10,17 +10,19 @@ #define DEVSVC_RECORD_H #include "hdf_object.h" -#include "hdf_slist.h" +#include "hdf_dlist.h" struct DevSvcRecord { - struct HdfSListNode entry; + struct DListHead entry; uint32_t key; struct HdfDeviceObject *value; + const char *servName; + const char *servInfo; + uint16_t devClass; }; struct DevSvcRecord *DevSvcRecordNewInstance(void); void DevSvcRecordFreeInstance(struct DevSvcRecord *inst); -void DevSvcRecordDelete(struct HdfSListNode *listEntry); #endif /* DEVSVC_RECORD_H */ diff --git a/core/shared/include/hdf_service_status.h b/core/shared/include/hdf_service_status.h new file mode 100644 index 0000000000000000000000000000000000000000..734c45b3295f5e4e135866ed225f998a77e0008d --- /dev/null +++ b/core/shared/include/hdf_service_status.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 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_SERVICE_STATUS_H +#define HDF_SERVICE_STATUS_H + +#include "hdf_types.h" + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +struct HdfSBuf; +struct ServiceStatusListener; + +enum ServiceStatusType { + SERVIE_STATUS_START, + SERVIE_STATUS_CHANGE, + SERVIE_STATUS_STOP, + SERVIE_STATUS_MAX, +}; + +enum ServiceStatusListenerCmd { + SERVIE_STATUS_LISTENER_NOTIFY, + SERVIE_STATUS_LISTENER_MAX, +}; + +struct ServiceStatus { + const char* serviceName; + uint16_t deviceClass; /* ref to DeviceClass */ + uint16_t status; /* ref to ServiceStatusType */ + const char *info; +}; + +typedef void (*OnServiceStatusReceived)(struct ServiceStatusListener *, struct ServiceStatus *); + +struct ServiceStatusListener { + OnServiceStatusReceived callback; + void *priv; +}; + +int ServiceStatusMarshalling(struct ServiceStatus *status, struct HdfSBuf *buf); +int ServiceStatusUnMarshalling(struct ServiceStatus *status, struct HdfSBuf *buf); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* HDF_SERVICE_STATUS_H */ \ No newline at end of file diff --git a/core/shared/include/hdf_usb_pnp_manage.h b/core/shared/include/hdf_usb_pnp_manage.h old mode 100644 new mode 100755 index e22f7cb1d1978c4f64918920f5d038875df298d2..6a28645102e0667a6d817e0e65a91c1e2468fa76 --- a/core/shared/include/hdf_usb_pnp_manage.h +++ b/core/shared/include/hdf_usb_pnp_manage.h @@ -26,6 +26,9 @@ enum UsbPnpNotifyServiceCmd { #endif USB_PNP_DRIVER_REGISTER_DEVICE, USB_PNP_DRIVER_UNREGISTER_DEVICE, + USB_PNP_DRIVER_GETDEVICES = 20, + USB_PNP_DRIVER_GADGET_ADD = 30, + USB_PNP_DRIVER_GADGET_REMOVE, }; enum UsbPnpNotifyRemoveType { @@ -78,7 +81,7 @@ struct UsbPnpNotifyDeviceInfo { }; struct UsbPnpNotifyMatchInfoTable { - uint32_t usbDevAddr; + uintptr_t usbDevAddr; int32_t devNum; int32_t busNum; diff --git a/core/shared/include/ioservstat_listener.h b/core/shared/include/ioservstat_listener.h new file mode 100644 index 0000000000000000000000000000000000000000..b7b9a8caf9430fdef84a227ce604a48091b3c8cd --- /dev/null +++ b/core/shared/include/ioservstat_listener.h @@ -0,0 +1,34 @@ +/* + * Copyright (c) 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_IOSERVICE_STATUS_LISTENER_H +#define HDF_IOSERVICE_STATUS_LISTENER_H + +#include "hdf_dlist.h" +#include "hdf_io_service_if.h" +#include "hdf_service_status.h" + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +struct IoServiceStatusListener { + struct ServiceStatusListener svcstatListener; + struct HdfDevEventlistener ioservListener; + struct DListHead node; + uint16_t deviceClass; +}; + +struct ServiceStatusListener *IoServiceStatusListenerNewInstance(void); +void IoServiceStatusListenerFree(struct ServiceStatusListener *listener); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif // HDF_IOSERVICE_STATUS_LISTENER_H diff --git a/core/shared/include/power_state_token_if.h b/core/shared/include/power_state_token_if.h index 0e054c01ae1515669e6b829421d6e45363e09800..c1af0b70ed5b38066a95dea16034753bf2e694cb 100644 --- a/core/shared/include/power_state_token_if.h +++ b/core/shared/include/power_state_token_if.h @@ -9,6 +9,10 @@ #ifndef POWER_STATE_TOKEN_IF_H #define POWER_STATE_TOKEN_IF_H +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + typedef enum { PSM_STATE_IDLE, /* Idle state */ PSM_STATE_ACTIVE, /* Activated state */ @@ -20,4 +24,8 @@ struct IPowerStateToken { void (*ReleaseWakeLock)(struct IPowerStateToken *); }; +#ifdef __cplusplus +} +#endif /* __cplusplus */ + #endif /* POWER_STATE_TOKEN_IF_H */ \ No newline at end of file diff --git a/core/shared/include/svcmgr_ioservice.h b/core/shared/include/svcmgr_ioservice.h new file mode 100644 index 0000000000000000000000000000000000000000..6886189c5356a69c04e8a2e791e95cda7606c98c --- /dev/null +++ b/core/shared/include/svcmgr_ioservice.h @@ -0,0 +1,40 @@ +/* + * Copyright (c) 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 DEVSVC_SVCMGR_IOSERVICE_H +#define DEVSVC_SVCMGR_IOSERVICE_H + +#include "hdf_base.h" +#include "hdf_service_status.h" + +#ifdef __cplusplus +extern "C" { +#endif /* __cplusplus */ + +#define DEV_SVCMGR_NODE "devsvc_mgr" + +enum SvcMgrIoCmd { + SVCMGR_REGISTER_LISTENER , + SVCMGR_UNREGISTER_LISTENER, +}; + +struct ISvcMgrIoservice { + int32_t (*RegisterServiceStatusListener)(struct ISvcMgrIoservice *self, + struct ServiceStatusListener *listener, uint16_t deviceClass); + int32_t (*UnregisterServiceStatusListener)(struct ISvcMgrIoservice *self, + struct ServiceStatusListener *listener); +}; + +struct ISvcMgrIoservice *SvcMgrIoserviceGet(void); +void SvcMgrIoserviceRelease(struct ISvcMgrIoservice *svcmgr); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif // DEVSVC_SVCMGR_IOSERVICE_H \ No newline at end of file diff --git a/core/shared/src/hdf_device_info.c b/core/shared/src/hdf_device_info.c old mode 100755 new mode 100644 index 1fc5ac93d3b05acd3206decacc3135904f7cf900..a691edcf8a32e0c7cfe4c90b8c3738da638fb8f4 --- a/core/shared/src/hdf_device_info.c +++ b/core/shared/src/hdf_device_info.c @@ -18,7 +18,6 @@ void HdfDeviceInfoConstruct(struct HdfDeviceInfo *deviceInfo) return; } deviceInfo->isDynamic = false; - deviceInfo->hostId = 0; deviceInfo->status = HDF_SERVICE_UNUSABLE; deviceInfo->deviceType = HDF_DEV_LOCAL_SERVICE; deviceInfo->deviceId = 0; @@ -29,7 +28,6 @@ void HdfDeviceInfoConstruct(struct HdfDeviceInfo *deviceInfo) deviceInfo->svcName = NULL; deviceInfo->moduleName = NULL; deviceInfo->deviceMatchAttr = NULL; - deviceInfo->private = NULL; } struct HdfDeviceInfo *HdfDeviceInfoNewInstance() @@ -40,19 +38,13 @@ struct HdfDeviceInfo *HdfDeviceInfoNewInstance() HdfDeviceInfoConstruct(deviceInfo); return deviceInfo; } - HDF_LOGE("Create device deviceInfo failed"); + HDF_LOGE("failed to create deviceInfo, oom"); return NULL; } void HdfDeviceInfoFreeInstance(struct HdfDeviceInfo *deviceInfo) { if (deviceInfo != NULL) { - if (deviceInfo->isDynamic && deviceInfo->svcName != NULL) { - OsalMemFree((void *)deviceInfo->svcName); - } - if (deviceInfo->private != NULL) { - OsalMemFree((void *)deviceInfo->private); - } OsalMemFree(deviceInfo); } } diff --git a/core/shared/src/hdf_service_record.c b/core/shared/src/hdf_service_record.c index ebc9c38966eaee8a40a6495ceb6ad79b938851fd..138648b27e9c2d49c999db9b1f4d7c59de863bab 100644 --- a/core/shared/src/hdf_service_record.c +++ b/core/shared/src/hdf_service_record.c @@ -17,13 +17,9 @@ struct DevSvcRecord *DevSvcRecordNewInstance(void) void DevSvcRecordFreeInstance(struct DevSvcRecord *inst) { if (inst != NULL) { + OsalMemFree((char *)inst->servName); + OsalMemFree((char *)inst->servInfo); OsalMemFree(inst); } } -void DevSvcRecordDelete(struct HdfSListNode *listEntry) -{ - if (listEntry != NULL) { - OsalMemFree(listEntry); - } -} diff --git a/core/shared/src/ioserstat_listener.c b/core/shared/src/ioserstat_listener.c new file mode 100644 index 0000000000000000000000000000000000000000..b592c200dc45ecfd9ece2527d422893e1a7bdb30 --- /dev/null +++ b/core/shared/src/ioserstat_listener.c @@ -0,0 +1,54 @@ +/* + * Copyright (c) 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 "ioservstat_listener.h" +#include "osal_mem.h" + +static int OnIoServiceEventReceive( + struct HdfDevEventlistener *listener, struct HdfIoService *service, uint32_t id, struct HdfSBuf *data) +{ + if (listener == NULL || service == NULL || data == NULL) { + return HDF_ERR_INVALID_PARAM; + } + (void)id; + struct ServiceStatus status = { 0 }; + if (ServiceStatusUnMarshalling(&status, data) != HDF_SUCCESS) { + return HDF_ERR_INVALID_PARAM; + } + + struct IoServiceStatusListener *statusListener = listener->priv; + if (statusListener->svcstatListener.callback != NULL && + (statusListener->deviceClass & status.deviceClass)) { + statusListener->svcstatListener.callback(&statusListener->svcstatListener, &status); + } + + return HDF_SUCCESS; +} + +struct ServiceStatusListener *IoServiceStatusListenerNewInstance(void) +{ + struct IoServiceStatusListener *listener = OsalMemCalloc(sizeof(struct IoServiceStatusListener)); + if (listener == NULL) { + return NULL; + } + + listener->ioservListener.onReceive = OnIoServiceEventReceive; + listener->ioservListener.priv = (void *)listener; + + return &listener->svcstatListener; +} + +void IoServiceStatusListenerFree(struct ServiceStatusListener *listener) +{ + if (listener == NULL) { + return; + } + struct IoServiceStatusListener *ioservListener + = CONTAINER_OF(listener, struct IoServiceStatusListener, svcstatListener); + OsalMemFree(ioservListener); +} \ No newline at end of file diff --git a/core/shared/src/service_status.c b/core/shared/src/service_status.c new file mode 100644 index 0000000000000000000000000000000000000000..5e6ef8abf39b43ad83d4cb99197a57cb41e09a6c --- /dev/null +++ b/core/shared/src/service_status.c @@ -0,0 +1,48 @@ +/* + * Copyright (c) 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_log.h" +#include "hdf_sbuf.h" +#include "hdf_service_status.h" + +int ServiceStatusMarshalling(struct ServiceStatus *status, struct HdfSBuf *buf) +{ + if (status == NULL || buf == NULL || status->serviceName == NULL) { + return HDF_ERR_INVALID_PARAM; + } + if (!HdfSbufWriteString(buf, status->serviceName) + || !HdfSbufWriteUint16(buf, status->deviceClass) + || !HdfSbufWriteUint16(buf, status->status) + || !HdfSbufWriteString(buf, status->info != NULL ? status->info : "")) { + HDF_LOGI("failed to marshalling service status"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int ServiceStatusUnMarshalling(struct ServiceStatus *status, struct HdfSBuf *buf) +{ + + if (status == NULL || buf == NULL) { + return HDF_ERR_INVALID_PARAM; + } + status->serviceName = HdfSbufReadString(buf); + if (status->serviceName == NULL) { + HDF_LOGI("failed to unmarshalling service status, service name is null"); + return HDF_FAILURE; + } + + if (!HdfSbufReadUint16(buf, &status->deviceClass) || !HdfSbufReadUint16(buf, &status->status)) { + HDF_LOGI("failed to unmarshalling service status, deviceClass or status invalid"); + return HDF_FAILURE; + } + + status->info = HdfSbufReadString(buf); + return HDF_SUCCESS; +} diff --git a/core/shared/src/svcmgr_ioservice.c b/core/shared/src/svcmgr_ioservice.c new file mode 100644 index 0000000000000000000000000000000000000000..363dc1bc0e67209260f02cc94e9fc794698edb23 --- /dev/null +++ b/core/shared/src/svcmgr_ioservice.c @@ -0,0 +1,130 @@ +/* + * Copyright (c) 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 "svcmgr_ioservice.h" +#include "hdf_base.h" +#include "hdf_dlist.h" +#include "hdf_io_service_if.h" +#include "hdf_log.h" +#include "hdf_sbuf.h" +#include "ioservstat_listener.h" +#include "osal_mem.h" + +struct SvcMgrIoservice { + struct ISvcMgrIoservice svcmgr; + struct HdfIoService *iosvc; + struct DListHead listeners; +}; + +static int32_t SetListenClass(struct SvcMgrIoservice *svcmgrInst, uint16_t devClass) +{ + struct HdfSBuf *data = HdfSBufObtainDefaultSize(); + if (data == NULL) { + return HDF_ERR_MALLOC_FAIL; + } + + (void)HdfSbufWriteUint16(data, devClass); + if (svcmgrInst->iosvc == NULL || svcmgrInst->iosvc->dispatcher == NULL + || svcmgrInst->iosvc->dispatcher->Dispatch == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + return svcmgrInst->iosvc->dispatcher->Dispatch( + (struct HdfObject *)svcmgrInst->iosvc, SVCMGR_REGISTER_LISTENER, data, NULL); +} + +static int32_t UnSetListenClass(struct SvcMgrIoservice *svcmgrInst, uint16_t devClass) +{ + struct HdfSBuf *data = HdfSBufObtainDefaultSize(); + if (data == NULL) { + return HDF_ERR_MALLOC_FAIL; + } + + (void)HdfSbufWriteUint16(data, devClass); + if (svcmgrInst->iosvc == NULL || svcmgrInst->iosvc->dispatcher == NULL + || svcmgrInst->iosvc->dispatcher->Dispatch == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + return svcmgrInst->iosvc->dispatcher->Dispatch( + (struct HdfObject *)svcmgrInst->iosvc, SVCMGR_UNREGISTER_LISTENER, data, NULL); +} + +int32_t SvcMgrIoserviceRegSvcStatListener( + struct ISvcMgrIoservice *self, struct ServiceStatusListener *listener, uint16_t deviceClass) +{ + if (self == NULL || listener == NULL || deviceClass >= DEVICE_CLASS_MAX) { + return HDF_ERR_INVALID_PARAM; + } + + struct SvcMgrIoservice *svcmgrInst = CONTAINER_OF(self, struct SvcMgrIoservice, svcmgr); + struct IoServiceStatusListener *listenerInst + = CONTAINER_OF(listener, struct IoServiceStatusListener, svcstatListener); + + listenerInst->deviceClass = deviceClass; + int ret = SetListenClass(svcmgrInst, deviceClass); + if (ret != HDF_SUCCESS) { + HDF_LOGE("failed to set listen class"); + return ret; + } + + return HdfDeviceRegisterEventListener(svcmgrInst->iosvc, &listenerInst->ioservListener); +} + +int32_t SvcMgrIoserviceUnRegSvcStatListener(struct ISvcMgrIoservice *self, struct ServiceStatusListener *listener) +{ + if (self == NULL || listener == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + struct SvcMgrIoservice *svcmgrInst = CONTAINER_OF(self, struct SvcMgrIoservice, svcmgr); + struct IoServiceStatusListener *listenerInst + = CONTAINER_OF(listener, struct IoServiceStatusListener, svcstatListener); + + int ret = HdfDeviceUnregisterEventListener(svcmgrInst->iosvc, &listenerInst->ioservListener); + if (ret != HDF_SUCCESS) { + return ret; + } + + if (HdfIoserviceGetListenerCount(svcmgrInst->iosvc) == 0) { + ret = UnSetListenClass(svcmgrInst, listenerInst->deviceClass); + } + + return ret; +} + +static void SvcMgrIoserviceConstruct(struct ISvcMgrIoservice *svcmgrInst) +{ + svcmgrInst->RegisterServiceStatusListener = SvcMgrIoserviceRegSvcStatListener; + svcmgrInst->UnregisterServiceStatusListener = SvcMgrIoserviceUnRegSvcStatListener; +} + +struct ISvcMgrIoservice *SvcMgrIoserviceGet(void) +{ + struct SvcMgrIoservice *svcmgrInst = OsalMemCalloc(sizeof(struct SvcMgrIoservice)); + if (svcmgrInst == NULL) { + return NULL; + } + + svcmgrInst->iosvc = HdfIoServiceBind(DEV_SVCMGR_NODE); + if (svcmgrInst->iosvc == NULL) { + HDF_LOGE("ioserivce %s not exist", DEV_SVCMGR_NODE); + OsalMemFree(svcmgrInst); + return NULL; + } + SvcMgrIoserviceConstruct(&svcmgrInst->svcmgr); + return &svcmgrInst->svcmgr; +} + +void SvcMgrIoserviceRelease(struct ISvcMgrIoservice *svcmgr) +{ + if (svcmgr == NULL) { + return; + } + struct SvcMgrIoservice *svcmgrInst = CONTAINER_OF(svcmgr, struct SvcMgrIoservice, svcmgr); + HdfIoServiceRecycle(svcmgrInst->iosvc); + OsalMemFree(svcmgrInst); +} \ No newline at end of file diff --git a/include/audio/audio_accessory_if.h b/include/audio/audio_accessory_if.h index a86532d2d329b26642f974bd2dbb2b48d2df6a4a..6f7ebaf388dc4a49fd86f5914b629d7abb6f6130 100755 --- a/include/audio/audio_accessory_if.h +++ b/include/audio/audio_accessory_if.h @@ -18,39 +18,85 @@ extern "C" { #endif #endif /* __cplusplus */ +/** + * @brief Defines Accessory Codec device name and data. + * + * @since 1.0 + * @version 1.0 + */ struct AccessoryDevice { - const char *devAccessoryName; - struct AccessoryData *devData; - struct HdfDeviceObject *device; - struct DListHead list; - struct OsalMutex mutex; -}; - -struct AudioAccessoryOps { - const char *devAccessoryName; - struct AccessoryData *devData; - struct HdfDeviceObject *device; - struct DListHead list; + const char *devAccessoryName; /**< Accesssory device name */ + struct AccessoryData *devData; /**< Accesssory private data */ + struct HdfDeviceObject *device; /**< HDF device */ + struct DListHead list; /**< Accesssory list */ + struct OsalMutex mutex; /**< Accesssory mutex */ }; -/* Accessory host is defined in accessory driver */ +/** + * @brief Defines Accessory host in audio driver. + * + * @since 1.0 + * @version 1.0 + */ struct AccessoryHost { - struct IDeviceIoService service; // accessory service - struct HdfDeviceObject *device; // accessory deovce - void *priv; // accessory private data + struct IDeviceIoService service; /**< Services provided by Accesssory */ + struct HdfDeviceObject *device; /**< HDF device */ + void *priv; /**< Accesssory private data interface */ }; +/** + * @brief Defines Accesssory private data. + * + * @since 1.0 + * @version 1.0 + */ struct AccessoryData { - const char *drvAccessoryName; - /* Accessory driver callbacks */ - int32_t (*Init)(struct AudioCard *, const struct AccessoryDevice *device); - int32_t (*Read)(const struct AccessoryDevice *, uint32_t, uint32_t *); - int32_t (*Write)(const struct AccessoryDevice *, uint32_t, uint32_t); - int32_t (*AiaoRead)(const struct AccessoryDevice *, uint32_t, uint32_t *); - int32_t (*AiaoWrite)(const struct AccessoryDevice *, uint32_t, uint32_t); - - const struct AudioKcontrol *controls; - int numControls; + const char *drvAccessoryName; /**< Accesssory driver name */ + + /** + * @brief Defines Accesssory device init. + * + * @param audioCard Indicates a audio card device. + * @param accesssory Indicates a Accesssory device. + * + * @return Returns 0 if Accesssory device init success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Init)(struct AudioCard *audioCard, const struct AccessoryDevice *accesssory); + + /** + * @brief Defines Accesssory device reg read. + * + * @param accesssory Indicates a accesssory device. + * @param reg Indicates read reg address. + * @param value Indicates read reg value. + * + * @return Returns 0 if accesssory device read reg success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Read)(const struct AccessoryDevice *accesssory, uint32_t reg, uint32_t *value); + + /** + * @brief Defines accesssory device reg write. + * + * @param accesssory Indicates a accesssory device. + * @param reg Indicates write reg address. + * @param value Indicates write reg value. + * + * @return Returns 0 if accesssory device write reg success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Write)(const struct AccessoryDevice *accesssory, uint32_t reg, uint32_t value); + + const struct AudioKcontrol *controls; /**< Accesssory control structure array pointer */ + int numControls; /**< Accesssory controls the number of structure array elements */ + struct AudioRegCfgData* regConfig; /**< Accesssory registers configured in HCS */ }; #ifdef __cplusplus diff --git a/include/audio/audio_codec_if.h b/include/audio/audio_codec_if.h index d0636abb4f266dd0f358612267a51dcc5a85ac79..5ebe453bdf63fa329d05982de1fd0c410d25e4e8 100755 --- a/include/audio/audio_codec_if.h +++ b/include/audio/audio_codec_if.h @@ -18,70 +18,91 @@ extern "C" { #endif #endif /* __cplusplus */ -#define AUDIODRV_CTL_ELEM_IFACE_DAC 0 /* virtual dac device */ -#define AUDIODRV_CTL_ELEM_IFACE_ADC 1 /* virtual adc device */ -#define AUDIODRV_CTL_ELEM_IFACE_GAIN 2 /* virtual adc device */ -#define AUDIODRV_CTL_ELEM_IFACE_MIXER 3 /* virtual mixer device */ -#define AUDIODRV_CTL_ELEM_IFACE_ACODEC 4 /* Acodec device */ -#define AUDIODRV_CTL_ELEM_IFACE_PGA 5 /* PGA device */ -#define AUDIODRV_CTL_ELEM_IFACE_AIAO 6 /* AIAO device */ - -struct VirtualAddress { - unsigned long acodecVir; - unsigned long aiaoVir; -}; - +/** + * @brief Defines Codec device name and data. + * + * @since 1.0 + * @version 1.0 + */ struct CodecDevice { - const char *devCodecName; - struct CodecData *devData; - struct HdfDeviceObject *device; - struct DListHead list; - struct OsalMutex mutex; + const char *devCodecName; /**< Codec device name */ + struct CodecData *devData; /**< Codec module private data */ + struct HdfDeviceObject *device; /**< HDF device */ + struct DListHead list; /**< Codec list */ + struct OsalMutex mutex; /**< Codec mutex */ }; -/* codec related definitions */ +/** + * @brief Defines Codec private data. + * + * @since 1.0 + * @version 1.0 + */ struct CodecData { - const char *drvCodecName; - /* Codec driver callbacks */ - int32_t (*Init)(struct AudioCard *, struct CodecDevice *); - int32_t (*Read)(const struct CodecDevice *, uint32_t, uint32_t *); - int32_t (*Write)(const struct CodecDevice *, uint32_t, uint32_t); - int32_t (*AiaoRead)(const struct CodecDevice *, uint32_t, uint32_t *); - int32_t (*AiaoWrite)(const struct CodecDevice *, uint32_t, uint32_t); - const struct AudioKcontrol *controls; - int numControls; - const struct AudioSapmComponent *sapmComponents; - int numSapmComponent; - const struct AudioSapmRoute *sapmRoutes; - int numSapmRoutes; -}; + const char *drvCodecName; /**< Codec driver name */ -/* Codec host is defined in codec driver */ -struct CodecHost { - struct IDeviceIoService service; - struct HdfDeviceObject *device; - unsigned long priv; - unsigned long aiaoPriv; -}; + /** + * @brief Defines Codec device init. + * + * @param audioCard Indicates a audio card device. + * @param codec Indicates a codec device. + * + * @return Returns 0 if codec device init success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Init)(struct AudioCard *audioCard, const struct CodecDevice *codec); + + /** + * @brief Defines Codec device reg read. + * + * @param virtualAddress Indicates base reg IoRemap address. + * @param reg Indicates reg offset. + * @param value Indicates read reg value. + * + * @return Returns 0 if codec device read reg success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Read)(unsigned long virtualAddress, uint32_t reg, uint32_t *value); + + /** + * @brief Defines Codec device reg write. + * + * @param virtualAddress Indicates base reg IoRemap address. + * @param reg Indicates reg offset. + * @param value Indicates write reg value. + * + * @return Returns 0 if codec device write reg success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Write)(unsigned long virtualAddress, uint32_t reg, uint32_t value); -enum AudioRegParams { - PLAYBACK_VOLUME = 0, - CAPTURE_VOLUME, - PLAYBACK_MUTE, - CAPTURE_MUTE, - LEFT_GAIN, - RIGHT_GAIN, - EXTERNAL_CODEC_ENABLE, - INTERNALLY_CODEC_ENABLE, - RENDER_CHANNEL_MODE, - CAPTRUE_CHANNEL_MODE, + struct AudioKcontrol *controls; /**< Codec control structure array pointer */ + int numControls; /**< Number of array elements of Codec controls */ + struct AudioSapmComponent *sapmComponents; /**< Codec power management component array pointer */ + int numSapmComponent; /**< Number of array elements of codec power management component */ + const struct AudioSapmRoute *sapmRoutes; /**< Codec power management route array pointer */ + int numSapmRoutes; /**< Number of power management route array elements */ + unsigned long virtualAddress; /**< Codec base reg IoRemap address */ + struct AudioRegCfgData *regConfig; /**< Codec registers configured in HCS */ + struct AudioRegCfgGroupNode **regCfgGroup; /**< Codec register group configured in HCS */ }; -enum SapmRegParams { - LPGA_MIC = 0, - RPGA_MIC, - DACL2DACR, - DACR2DACL, +/** + * @brief Defines Codec host in audio driver. + * + * @since 1.0 + * @version 1.0 + */ +struct CodecHost { + struct IDeviceIoService service; /**< Services provided by codec */ + struct HdfDeviceObject *device; /**< HDF device */ + void *priv; /**< Codec private data interface */ }; #ifdef __cplusplus diff --git a/include/audio/audio_dai_if.h b/include/audio/audio_dai_if.h index f6e756edf903ea7a95e21f1da0d58a64f11f7561..eae35f2e6fa8454490c4dc232591442982af2aa5 100755 --- a/include/audio/audio_dai_if.h +++ b/include/audio/audio_dai_if.h @@ -9,39 +9,148 @@ #ifndef AUDIO_DAI_IF_H #define AUDIO_DAI_IF_H +#include "audio_host.h" +#include "audio_parse.h" +#include "audio_control.h" + #ifdef __cplusplus #if __cplusplus extern "C" { #endif #endif /* __cplusplus */ +/** + * @brief Defines Dai device name and data. + * + * @since 1.0 + * @version 1.0 + */ struct DaiDevice { - const char *devDaiName; - struct DaiData *devData; - struct HdfDeviceObject *device; - struct DListHead list; + const char *devDaiName; /**< Dai device name */ + struct DaiData *devData; /**< Dai module private data */ + struct HdfDeviceObject *device; /**< HDF device */ + struct DListHead list; /**< Dai list */ }; +/** + * @brief Defines Dai operation function set. + * + * @since 1.0 + * @version 1.0 + */ struct AudioDaiOps { - int32_t (*Startup)(const struct AudioCard *, const struct DaiDevice *); - int32_t (*HwParams)(const struct AudioCard *, const struct AudioPcmHwParams *, const struct DaiDevice *); - int32_t (*Trigger)(const struct AudioCard *, int, const struct DaiDevice *); + /** + * @brief Defines Dai device start up function. + * + * @param audioCard Indicates a audio card device. + * @param dai Indicates a dai device. + * + * @return Returns 0 if dai device start up success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Startup)(const struct AudioCard *audioCard, const struct DaiDevice *dai); + + /** + * @brief Defines Dai device hardware param set function. + * + * @param audioCard Indicates a audio card device. + * @param param Indicates pcm param set. + * + * @return Returns 0 if dai pcm param set success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*HwParams)(const struct AudioCard *audioCard, const struct AudioPcmHwParams *param); + + /** + * @brief Defines Dai device trigger function. + * + * @param audioCard Indicates a audio card device. + * @param cmd Indicates a Command id. + * @param dai Indicates a dai device. + * + * @return Returns 0 if dai device trigger success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Trigger)(const struct AudioCard *audioCard, int cmd, const struct DaiDevice *dai); }; +/** + * @brief Defines dai private data. + * + * @since 1.0 + * @version 1.0 + */ struct DaiData { - const char *drvDaiName; - /* DAI driver callbacks */ - int32_t (*DaiInit)(const struct AudioCard *, const struct DaiDevice *); - /* ops */ - const struct AudioDaiOps *ops; + const char *drvDaiName; /**< dai driver name */ + + /** + * @brief Defines Dai device init. + * + * @param audioCard Indicates a audio card device. + * @param dai Indicates a dai device. + * + * @return Returns 0 if dai device init success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*DaiInit)(struct AudioCard *audioCard, const struct DaiDevice *dai); + + /** + * @brief Defines Dai device reg read. + * + * @param virtualAddress Indicates base reg IoRemap address. + * @param reg Indicates reg offset. + * @param value Indicates read reg value. + * + * @return Returns 0 if dai device read reg success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Read)(unsigned long virtualAddress, uint32_t reg, uint32_t *value); + + /** + * @brief Defines Dai device reg write. + * + * @param virtualAddress Indicates base reg IoRemap address. + * @param reg Indicates reg offset. + * @param value Indicates write reg value. + * + * @return Returns 0 if dai device write reg success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Write)(unsigned long virtualAddress, uint32_t reg, uint32_t value); + + const struct AudioDaiOps *ops; /**< dai set of operation functions */ + struct PcmInfo pcmInfo; /**< dai pcm info */ + struct AudioKcontrol *controls; /**< dai control structure array pointer */ + int numControls; /**< dai controls the number of structure array elements */ + bool daiInitFlag; /**< dai init flag */ + unsigned long regVirtualAddr; /**< dai base reg IoRemap address */ + struct AudioRegCfgData *regConfig; /**< dai registers configured in HCS */ + struct AudioRegCfgGroupNode **regCfgGroup; /**< dai register group configured in HCS */ + struct OsalMutex mutex; /**< dai mutex */ }; -/* Dai host is defined in dai driver */ +/** + * @brief Defines Dai host in audio driver. + * + * @since 1.0 + * @version 1.0 + */ struct DaiHost { - struct IDeviceIoService service; - struct HdfDeviceObject *device; - void *priv; - bool daiInitFlag; + struct IDeviceIoService service; /**< Services provided by dai */ + struct HdfDeviceObject *device; /**< HDF device */ + void *priv; /**< Dai private data interface */ }; #ifdef __cplusplus diff --git a/include/audio/audio_dsp_if.h b/include/audio/audio_dsp_if.h index ae72f096bf03e26d215e471fec74174db336a359..8e39def5d9f1b8ffabbd338841fedf8003e016ca 100755 --- a/include/audio/audio_dsp_if.h +++ b/include/audio/audio_dsp_if.h @@ -15,35 +15,168 @@ extern "C" { #endif #endif /* __cplusplus */ +/** + * @brief Defines Dsp device name and data. + * + * @since 1.0 + * @version 1.0 + */ struct DspDevice { - const char *devDspName; - struct DspData *devData; - struct HdfDeviceObject *device; - struct DListHead list; + const char *devDspName; /**< Dsp device name */ + struct DspData *devData; /**< Dsp module private data */ + struct HdfDeviceObject *device; /**< HDF device */ + struct DListHead list; /**< Dsp list */ }; +/** + * @brief Defines Dsp operation function set. + * + * @since 1.0 + * @version 1.0 + */ struct AudioDspOps { - int32_t (*Startup)(const struct AudioCard *, const struct DspDevice *); - int32_t (*HwParams)(const struct AudioCard *, const struct AudioPcmHwParams *, const struct DspDevice *); - int32_t (*Trigger)(struct AudioCard *, int, struct DspDevice *); + /** + * @brief Defines Dsp device start up function. + * + * @param audioCard Indicates a audio card device. + * @param dsp Indicates a dsp device. + * + * @return Returns 0 if Dsp device start up success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Startup)(const struct AudioCard *audioCard, const struct DspDevice *dsp); + + /** + * @brief Defines Dsp device hardware param function. + * + * @param audioCard Indicates a audio card device. + * @param param Indicates pcm params set. + * + * @return Returns 0 if dsp param set success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*HwParams)(const struct AudioCard *audioCard, const struct AudioPcmHwParams *param); + + /** + * @brief Defines Dsp device trigger function. + * + * @param audioCard Indicates a audio card device. + * @param dsp Indicates a dsp device. + * + * @return Returns 0 if dsp device trigger success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Trigger)(struct AudioCard *audioCard, int, struct DspDevice *dsp); }; -/* Dsp host is defined in dsp driver */ +/** + * @brief Defines Dsp host in audio driver. + * + * @since 1.0 + * @version 1.0 + */ struct DspHost { - struct IDeviceIoService service; // dsp service - struct HdfDeviceObject *device; // dsp device - void *priv; // dsp private data + struct IDeviceIoService service; /**< Services provided by dsp */ + struct HdfDeviceObject *device; /**< HDF device */ + void *priv; /**< Dsp private data interface */ }; +/** + * @brief Defines dsp private data. + * + * @since 1.0 + * @version 1.0 + */ struct DspData { - const char *drvDspName; - /* dsp driver callbacks */ - int32_t (*DspInit)(const struct DspDevice *device); - int32_t (*Read)(struct DspDevice *, uint8_t *, uint32_t); - int32_t (*Write)(struct DspDevice *, uint8_t *, uint32_t); - int32_t (*decode)(const struct AudioCard *, const uint8_t *, const struct DspDevice *); - int32_t (*encode)(const struct AudioCard *, const uint8_t *, const struct DspDevice *); - int32_t (*Equalizer)(const struct AudioCard *, const uint8_t *, const struct DspDevice *); + const char *drvDspName; /**< Dsp driver name */ + + /** + * @brief Defines Dsp device init. + * + * @param dsp Indicates a Dsp device. + * + * @return Returns 0 if dsp device init success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*DspInit)(const struct DspDevice *dsp); + + /** + * @brief Defines Dsp device msgs read. + * + * @param dsp Indicates a dsp device. + * @param msgs Indicates transfer msgs data. + * @param len Indicates msgs length. + * + * @return Returns 0 if dsp device read msgs success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Read)(const struct DspDevice *dsp, const void *msgs, const uint32_t len); + + /** + * @brief Defines Dsp device msgs write. + * + * @param dsp Indicates a dsp device. + * @param msgs Indicates transfer msgs data. + * @param len Indicates msgs length. + * + * @return Returns 0 if dsp device write msgs success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Write)(const struct DspDevice *dsp, const void *msgs, const uint32_t len); + + /** + * @brief Defines Dsp device decode. + * + * @param audioCard Indicates a audio card. + * @param buf Indicates decode pcm buffer data. + * @param dsp Indicates a dsp device. + * + * @return Returns 0 if Dsp device decode success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Decode)(const struct AudioCard *audioCard, const uint8_t *buf, const struct DspDevice *dsp); + + /** + * @brief Defines Dsp device encode. + * + * @param audioCard audioCard Indicates a audio card. + * @param buf Indicates encode pcm buffer data. + * @param dsp Indicates a dsp device. + * + * @return Returns 0 if Dsp device encode success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Encode)(const struct AudioCard *audioCard, const uint8_t *buf, const struct DspDevice *dsp); + + /** + * @brief Defines Dsp device equalizer. + * + * @param audioCard audioCard Indicates a audio card. + * @param buf Indicates equalizer pcm buffer data. + * @param dsp Indicates a dsp device. + * + * @return Returns 0 if Dsp device equalizer success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*Equalizer)(const struct AudioCard *audioCard, const uint8_t *buf, const struct DspDevice *dsp); }; #ifdef __cplusplus diff --git a/include/audio/audio_platform_if.h b/include/audio/audio_platform_if.h index 6ac044d686358c1458b922746264d98908d2753b..bb6e09896ff01093c3a67cca8c5311fa7fa882c1 100755 --- a/include/audio/audio_platform_if.h +++ b/include/audio/audio_platform_if.h @@ -10,6 +10,7 @@ #define AUDIO_PLATFORM_IF_H #include "audio_host.h" +#include "audio_platform_base.h" #ifdef __cplusplus #if __cplusplus @@ -17,121 +18,194 @@ extern "C" { #endif #endif /* __cplusplus */ -#define I2S_IOCFG2_BASE1 0x0020 -#define I2S_IOCFG2_BASE2 0x0024 -#define I2S_IOCFG2_BASE3 0x0028 -#define I2S_IOCFG2_BASE4 0x002C -#define I2S_IOCFG2_BASE5 0x0030 - -#define I2S_IOCFG2_BASE1_VAL 0x663 -#define I2S_IOCFG2_BASE2_VAL 0x673 -#define I2S_IOCFG2_BASE3_VAL 0x573 -#define I2S_IOCFG2_BASE4_VAL 0x473 -#define I2S_IOCFG2_BASE5_VAL 0x433 - -#define I2S_IOCFG3_BASE1 0x44 -#define I2S_IOCFG3_BASE1_VAL 0x0600 - -#define GPIO_BASE1 0x2010 -#define GPIO_BASE2 0x2400 -#define GPIO_BASE3 0x2010 - -#define GPIO_BASE2_VAL 0x000000ff -#define GPIO_BASE3_VAL 0x00000000 - -#define IOCFG2_BASE_ADDR 0x112F0000 -#define IOCFG3_BASE_ADDR 0x10FF0000 -#define GPIO_BASE_ADDR 0x120D0000 -#define BASE_ADDR_REMAP_SIZE 0x10000 - -struct CircleBufInfo { - uint32_t cirBufSize; - uint32_t trafBufSize; - uint32_t period; - uint32_t periodSize; - uint32_t periodCount; - unsigned long phyAddr; - uint32_t *virtAddr; - uint32_t wbufOffSet; - uint32_t wptrOffSet; - uint32_t runStatus; - uint32_t chnId; - uint32_t enable; - struct OsalMutex buffMutex; - uint64_t framesPosition; -}; - -struct PcmInfo { - /* The number of channels in a frame */ - uint32_t channels; - /* The number of frames per second */ - uint32_t rate; - uint32_t bitWidth; - uint32_t frameSize; - bool isBigEndian; - bool isSignedData; - uint32_t startThreshold; - uint32_t stopThreshold; - uint32_t silenceThreshold; - uint32_t totalStreamSize; +/** + * @brief Defines paltform private data. + * + * @since 1.0 + * @version 1.0 + */ +struct PlatformData { + const char *drvPlatformName; /**< Platform module name */ + + /** + * @brief Defines platform device init. + * + * @param audioCard Indicates a audio card device. + * @param platform Indicates a platform device. + * + * @return Returns 0 if Platform device init success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*PlatformInit)(const struct AudioCard *audioCard, const struct PlatformDevice *platform); + + struct AudioDmaOps *ops; /**< Platform module private data */ + struct CircleBufInfo renderBufInfo; /**< Render pcm stream transfer */ + struct CircleBufInfo captureBufInfo; /**< Capture pcm stream transfer */ + struct PcmInfo pcmInfo; /**< Pcm stream info */ + bool platformInitFlag; /**< Platform init flag */ + struct AudioMmapData mmapData; /**< Mmap mode transfer data */ + uint32_t mmapLoopCount; /**< Loop count for mmap mode pcm stream */ + void *dmaPrv; /**< Platform dma private data */ }; -/* platform related definitions */ -struct AudioPlatformOps { - int32_t (*HwParams)(const struct AudioCard *, const struct AudioPcmHwParams *); - int32_t (*RenderTrigger)(struct AudioCard *, int); - int32_t (*CaptureTrigger)(struct AudioCard *, int); - uint32_t (*Pointer)(struct AudioCard *); - int32_t (*Write)(const struct AudioCard *, struct AudioTxData *); - int32_t (*Read)(const struct AudioCard *, struct AudioRxData *); - int32_t (*MmapWrite)(const struct AudioCard *, struct AudioTxMmapData *); - int32_t (*MmapRead)(const struct AudioCard *, struct AudioRxMmapData *); - int32_t (*RenderPrepare)(const struct AudioCard *); - int32_t (*CapturePrepare)(const struct AudioCard *); - int32_t (*RenderStart)(struct AudioCard *); - int32_t (*CaptureStart)(struct AudioCard *); - int32_t (*RenderStop)(struct AudioCard *); - int32_t (*CaptureStop)(struct AudioCard *); - int32_t (*RenderPause)(struct AudioCard *); - int32_t (*CapturePause)(struct AudioCard *); - int32_t (*RenderResume)(struct AudioCard *); - int32_t (*CaptureResume)(struct AudioCard *); +/** + * @brief Defines Dma operation function set. + * + * @since 1.0 + * @version 1.0 + */ +struct AudioDmaOps { + /** + * @brief Defines Dma buff alloc. + * + * @param platformData Indicates dma device. + * @param streamType Indicates capture or render. + * + * @return Returns 0 if dma buffer alloc success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*DmaBufAlloc)(struct PlatformData *platformData, const enum AudioStreamType streamType); + + /** + * @brief Defines dma buffer free. + * + * @param platformData Indicates dma device. + * @param streamType Indicates capture or render. + * + * @return Returns 0 if dma buffer free success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*DmaBufFree)(struct PlatformData *platformData, const enum AudioStreamType streamType); + + /** + * @brief Defines dma request channel. + * + * @param platformData Indicates dma device. + * + * @return Returns 0 if dma request channel success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*DmaRequestChannel)(const struct PlatformData *platformData); + + /** + * @brief Defines dma channel config. + * + * @param platformData Indicates dma device. + * + * @return Returns 0 if dma channel config set success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*DmaConfigChannel)(const struct PlatformData *platformData); + + /** + * @brief Defines dma prepare function. + * + * @param platformData Indicates dma device. + * + * @return Returns 0 if dma device prep set success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*DmaPrep)(const struct PlatformData *platformData); + + /** + * @brief Defines dma submit function. + * + * @param platformData Indicates dma device. + * + * @return Returns 0 if dma device submit succes; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*DmaSubmit)(const struct PlatformData *platformData); + + /** + * @brief Defines dma pending function. + * + * @param platformData Indicates dma device. + * + * @return Returns 0 if dma pending success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*DmaPending)(struct PlatformData *platformData); + + /** + * @brief Defines pcm stream transfer pause. + * + * @param platformData Indicates dma device. + * + * @return Returns 0 if pcm stream transfer pause success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*DmaPause)(struct PlatformData *platformData); + + /** + * @brief Defines pcm stream transfer resume. + * + * @param platformData Indicates dma device. + * + * @return Returns 0 if pcm stream transfer resume success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*DmaResume)(const struct PlatformData *platformData); + + /** + * @brief Defines Get the function of the current playback or recording position. + * + * @param platformData Indicates dma device. + * @param pointer Indicates dma pointer. + * + * @return Returns 0 if dma device pointer position get success; returns a non-zero value otherwise. + * + * @since 1.0 + * @version 1.0 + */ + int32_t (*DmaPointer)(struct PlatformData *platformData, uint32_t *pointer); }; +/** + * @brief Defines Dai device name and data. + * + * @since 1.0 + * @version 1.0 + */ struct PlatformDevice { - const char *devPlatformName; - struct PlatformData *devData; - struct HdfDeviceObject *device; - struct DListHead list; -}; - -struct PlatformData { - const char *drvPlatformName; - /* platform driver callbacks */ - int32_t (*PlatformInit)(const struct AudioCard *, const struct PlatformDevice *); - /* pcm creation and destruction */ - int32_t (*PcmNew)(struct PlatformDevice *); - void (*PcmFree)(struct PlatformDevice *); - /* platform stream ops */ - struct AudioPlatformOps *ops; + const char *devPlatformName; /**< Platform device name */ + struct PlatformData *devData; /**< Platform module private data */ + struct HdfDeviceObject *device; /**< HDF device */ + struct DListHead list; /**< Platform list */ }; -/* Platform host is defined in platform driver */ +/** + * @brief Defines Platform host in audio driver. + * + * @since 1.0 + * @version 1.0 + */ struct PlatformHost { - struct IDeviceIoService service; - struct HdfDeviceObject *device; - void *priv; - bool platformInitFlag; - struct CircleBufInfo renderBufInfo; - struct CircleBufInfo captureBufInfo; - struct PcmInfo pcmInfo; + struct IDeviceIoService service; /**< Services provided by patform */ + struct HdfDeviceObject *device; /**< HDF device */ + void *priv; /**< Platform private data interface */ }; -static inline struct PlatformHost *PlatformHostFromDevice(struct HdfDeviceObject *device) -{ - return (device == NULL) ? NULL : (struct PlatformHost *)device->service; -} - #ifdef __cplusplus #if __cplusplus } diff --git a/include/core/hdf_io_service_if.h b/include/core/hdf_io_service_if.h index 9dc9fd9011d82cd7997ff498a1fd0dcd8a4646b9..16aa780593b171c304b7d62b539bef41de839e3e 100644 --- a/include/core/hdf_io_service_if.h +++ b/include/core/hdf_io_service_if.h @@ -47,18 +47,15 @@ struct HdfIoService; * @since 1.0 */ typedef enum { - /** Default device */ - DEVICE_CLASS_DEFAULT = 0, - /** Platform device */ - DEVICE_CLASS_PAL, - /** Sensor device */ - DEVICE_CLASS_SENSOR, - /** Input device */ - DEVICE_CLASS_INPUT, - /** Display device */ - DEVICE_CLASS_DISPLAY, - /** Maximum value of a device class */ - DEVICE_CLASS_MAX + DEVICE_CLASS_DEFAULT = 0x1 << 0, /** Default device */ + DEVICE_CLASS_PALT = 0x1 << 1, /** Platform device */ + DEVICE_CLASS_SENSOR = 0x1 << 2, /** Sensor device */ + DEVICE_CLASS_INPUT = 0x1 << 3, /** Input device */ + DEVICE_CLASS_DISPLAY = 0x1 << 4, /** Display device */ + DEVICE_CLASS_AUDIO = 0x1 << 5, /** Audio device */ + DEVICE_CLASS_CAMERA = 0x1 << 6, /** Camera device */ + DEVICE_CLASS_USB = 0x1 << 7, /** USB device */ + DEVICE_CLASS_MAX = 0x1 << 8, /** Maximum value of a device class */ } DeviceClass; /** @@ -88,8 +85,8 @@ typedef int (*OnEventReceived)(void *priv, uint32_t id, struct HdfSBuf *data); * * @since 1.0 */ -typedef int (*OnDevEventReceive)(struct HdfDevEventlistener *listener, - struct HdfIoService *service, uint32_t id, struct HdfSBuf *data); +typedef int (*OnDevEventReceive)( + struct HdfDevEventlistener *listener, struct HdfIoService *service, uint32_t id, struct HdfSBuf *data); /** * @brief Defines a driver event listener object. @@ -130,9 +127,9 @@ struct HdfIoService { /** Pointer to the bound service entity, which is used for framework management. You can ignore it. */ struct HdfObject *target; /** Service call dispatcher */ - struct HdfIoDispatcher* dispatcher; + struct HdfIoDispatcher *dispatcher; /** Private data of the service */ - void* priv; + void *priv; }; /** @@ -176,7 +173,6 @@ void HdfIoServiceGroupRecycle(struct HdfIoServiceGroup *group); */ int32_t HdfIoServiceGroupAddService(struct HdfIoServiceGroup *group, struct HdfIoService *service); - /** * @brief Removes a driver service object from a specified driver service group. * diff --git a/include/core/hdf_pm.h b/include/core/hdf_pm.h index 1c8412fa46b9fc2d16deabedd3b3c03d9cf9f815..6d6ddbb59c3bee5b682677bada5fb4038ae7040a 100644 --- a/include/core/hdf_pm.h +++ b/include/core/hdf_pm.h @@ -38,5 +38,7 @@ int HdfPmRegisterPowerListener(struct HdfDeviceObject *deviceObject, const struc void HdfPmUnregisterPowerListener(struct HdfDeviceObject *deviceObject, const struct IPowerEventListener *listener); void HdfPmAcquireDevice(struct HdfDeviceObject *deviceObject); void HdfPmReleaseDevice(struct HdfDeviceObject *deviceObject); +void HdfPmAcquireDeviceAsync(struct HdfDeviceObject *deviceObject); +void HdfPmReleaseDeviceAsync(struct HdfDeviceObject *deviceObject); void HdfPmSetMode(struct HdfDeviceObject *deviceObject, uint32_t mode); #endif /* HDF_POWER_MANAGEMENT_H */ diff --git a/include/platform/adc_if.h b/include/platform/adc_if.h index 79c06a0a0e4761a2e9dca1dea5bc59e4c2a4eb89..33b347131e27179a3b0ea352f72e1a2932d9c36d 100644 --- a/include/platform/adc_if.h +++ b/include/platform/adc_if.h @@ -22,7 +22,7 @@ struct AdcIoMsg { uint32_t channel; }; -DevHandle AdcOpen(uint32_t num); +DevHandle AdcOpen(uint32_t number); void AdcClose(DevHandle handle); diff --git a/include/platform/dac_if.h b/include/platform/dac_if.h new file mode 100644 index 0000000000000000000000000000000000000000..84dfeb73ae25dff1f096ed8a18c3be58567df3dc --- /dev/null +++ b/include/platform/dac_if.h @@ -0,0 +1,87 @@ +/* + * Copyright (c) 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. + */ +/** + * @addtogroup DAC + * @{ + * + * @brief Provides Digital to analog converter (DAC) interfaces. + * + * This module allows a driver to perform operations on an DAC controller for accessing devices on the DAC channel, + * Including creating and destroying DAC controller handles and writing data + * + * @since 1.0 + */ +/** + * @file dac_if.h + * + * @brief Declares the standard DAC interface functions. + * + * @since 1.0 + */ + +#ifndef DAC_IF_H +#define DAC_IF_H + +#include "hdf_platform.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +struct DacIoMsg { + uint32_t number; + uint32_t channel; +}; + + /** + * @brief Obtains the handle of an DAC controller. + * + * You must call this function before accessing the DAC CHANNEL. + * + * @param number Indicates the DAC controller ID. + * + * @return Returns the pointer to the {@link DevHandle} of the DAC controller if the operation is successful; + * returns NULL otherwise. + * @since 1.0 + */ +DevHandle DacOpen(uint32_t number); + + /** + * @brief Releases the handle of an DAC controller. + * + * If you no longer need to access the DAC controller, you should call this function to close its handle so as + * to release unused memory resources. + * + * @param handle Indicates the pointer to the device handle of the DAC controller. + * + * @since 1.0 + */ +void DacClose(DevHandle handle); + + /** + * @brief Start the DAC device for transmission and write the target value in the specified DAC channel. + * + * @param handle Indicates the pointer to the device handle of the DAC controller obtained via {@link DacOpen}. + * @param channel represents the channel through which the DAC transmits messages. + * @param val represents the set digital target value. + * + * @return Returns 0 if the operation is successful; Returns a negative value otherwise.. + * + * @since 1.0 + */ +int32_t DacWrite(DevHandle handle, uint32_t channel, uint32_t val); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* DAC_IF_H */ diff --git a/include/platform/hdmi_if.h b/include/platform/hdmi_if.h new file mode 100644 index 0000000000000000000000000000000000000000..a7ad5073e80559bb548276ce7d4355db9daef65d --- /dev/null +++ b/include/platform/hdmi_if.h @@ -0,0 +1,801 @@ +/* + * Copyright (c) 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. + */ + +/** + * @addtogroup HDMI + * @{ + * + * @brief Declares standard APIs of basic High-Definition Multimedia Interface (HDMI) capabilities. + * + * You can use this module to access the HDMI and enable the driver to operate an HDMI sink device. + * These capabilities include start and stop tramnsfer on HDMI, setting some attributes, + * and read sink device's EDID data. + * + * @since 1.0 + */ + +/** + * @file hdmi_if.h + * + * @brief Declares the standard HDMI interface functions. + * + * @since 1.0 + */ + +#ifndef HDMI_IF_H +#define HDMI_IF_H + +#include "hdf_platform.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/** + * @brief Indicates that maximum length of an HDMI sink device's EDID is 512 bytes. + * + * @since 1.0 + */ +#define HDMI_EDID_MAX_LEN 512 + +/** + * @brief Enumerates deep color, + * see the section 6.2.4 of HDMI Specification 1.4 for details. + * + * @since 1.0 + */ +enum HdmiDeepColor { + HDMI_DEEP_COLOR_24BITS = 0, + HDMI_DEEP_COLOR_30BITS = 1, + HDMI_DEEP_COLOR_36BITS = 2, + HDMI_DEEP_COLOR_48BITS = 3, + HDMI_DEEP_COLOR_OFF = 0xff, + HDMI_DEEP_COLOR_BUTT, +}; + +/** + * @brief Enumerates video bit depth + * see the section 6.6 of HDMI Specification 1.4 for details. + * + * @since 1.0 + */ +enum HdmiVideoBitDepth { + HDMI_VIDEO_BIT_DEPTH_8 = 0, + HDMI_VIDEO_BIT_DEPTH_10 = 1, + HDMI_VIDEO_BIT_DEPTH_12 = 2, + HDMI_VIDEO_BIT_DEPTH_16 = 3, + HDMI_VIDEO_BIT_DEPTH_OFF, +}; + +/** + * @brief Enumerates color space, + * see the section 6 of HDMI Specification 1.4 for details. + * + * @since 1.0 + */ +enum HdmiColorSpace { + HDMI_COLOR_SPACE_RGB = 0, + HDMI_COLOR_SPACE_YCBCR422 = 1, + HDMI_COLOR_SPACE_YCBCR444 = 2, + HDMI_COLOR_SPACE_YCBCR420 = 3, + HDMI_COLOR_SPACE_BUTT, +}; + +/** + * @brief Enumerates colorimetry, see the section 6.7 of HDMI Specification 1.4 and + * the section 7.2 of HDMI Specification 2.0 for details. + * + * @since 1.0 + */ +enum HdmiColorimetry { + HDMI_COLORIMETRY_NO_DATA = 0, + HDMI_COLORIMETRY_ITU601 = 1, + HDMI_COLORIMETRY_ITU709 = 2, + HDMI_COLORIMETRY_EXTENDED = 3, +}; + +/** + * @brief Enumerates extended colorimetry, see the section 6.7 of HDMI Specification 1.4 and + * the section 7.2 of HDMI Specification 2.0 for details. + * + * @since 1.0 + */ +enum HdmiExtendedColorimetry { + HDMI_EXTENDED_COLORIMETRY_XV_YCC_601 = 0, + HDMI_EXTENDED_COLORIMETRY_XV_YCC_709 = 1, + HDMI_EXTENDED_COLORIMETRY_S_YCC_601 = 2, + HDMI_EXTENDED_COLORIMETRY_OPYCC_601 = 3, + HDMI_EXTENDED_COLORIMETRY_OPRGB = 4, + HDMI_EXTENDED_COLORIMETRY_BT2020_CONST_LUM = 5, + HDMI_EXTENDED_COLORIMETRY_BT2020 = 6, + HDMI_EXTENDED_COLORIMETRY_ADDITIONAL = 7, + HDMI_EXTENDED_COLORIMETRY_BUTT, +}; + +/** + * @brief Enumerates quantization range, see the section 6.6 of HDMI Specification 1.4 and + * the section 7.3 of HDMI Specification 2.0 for details. + * + * @since 1.0 + */ +enum HdmiQuantizationRange { + HDMI_QUANTIZATION_RANGE_DEFAULT = 0, + HDMI_QUANTIZATION_RANGE_LIMITED = 1, + HDMI_QUANTIZATION_RANGE_FULL = 2, + HDMI_QUANTIZATION_RANGE_BUTT, +}; + +/** + * @brief Enumerates YCC quantization range, see the section 6.6 of HDMI Specification 1.4 and + * the section 7.3 of HDMI Specification 2.0 for details. + * + * @since 1.0 + */ +enum HdmiYccQuantizationRange { + HDMI_YCC_QUANTIZATION_RANGE_LIMITED = 0, + HDMI_YCC_QUANTIZATION_RANGE_FULL = 1, + HDMI_YCC_QUANTIZATION_RANGE_BUTT, +}; + +/** + * @brief Enumerates video 3d structure, + * see the section 8.2.3 of HDMI Specification 1.4 for details. + * + * @since 1.0 + */ +enum HdmiVideo3dStructure { + HDMI_VS_VIDEO_3D_FRAME_PACKING = 0, + HDMI_VS_VIDEO_3D_FIELD_ALTERNATIVE = 1, + HDMI_VS_VIDEO_3D_LINE_ALTERNATIVE = 2, + HDMI_VS_VIDEO_3D_SIDE_BY_SIDE_FULL = 3, + HDMI_VS_VIDEO_3D_L_DEPTH = 4, + HDMI_VS_VIDEO_3D_L_DEPTH_GFX_GFX_DEPTH = 5, + HDMI_VS_VIDEO_3D_TOP_AND_BOTTOM = 6, + HDMI_VS_VIDEO_3D_SIDE_BY_SIDE_HALF = 8, + HDMI_VS_VIDEO_3D_BUTT, +}; + +/** + * @brief Enumerates video timing, + * see the section 8.2.3 of HDMI Specification 1.4 for details. + * + * @since 1.0 + */ +enum HdmiVideoTiming { + HDMI_VIDEO_TIMING_NONE = 0, + HDMI_VIDEO_TIMING_640X480P60 = 1, + HDMI_VIDEO_TIMING_720X480P60 = 2, + HDMI_VIDEO_TIMING_720X480P120 = 3, + HDMI_VIDEO_TIMING_720X480P240 = 4, + HDMI_VIDEO_TIMING_720X576P50 = 5, + HDMI_VIDEO_TIMING_720X576P100 = 6, + HDMI_VIDEO_TIMING_720X576P200 = 7, + HDMI_VIDEO_TIMING_1280X720P24 = 8, + HDMI_VIDEO_TIMING_1280X720P25 = 9, + HDMI_VIDEO_TIMING_1280X720P30 = 10, + HDMI_VIDEO_TIMING_1280X720P48 = 11, + HDMI_VIDEO_TIMING_1280X720P50 = 12, + HDMI_VIDEO_TIMING_1280X720P60 = 13, + HDMI_VIDEO_TIMING_1280X720P100 = 14, + HDMI_VIDEO_TIMING_1280X720P120 = 15, + HDMI_VIDEO_TIMING_1440X240P60 = 16, + HDMI_VIDEO_TIMING_1440X288P50 = 17, + HDMI_VIDEO_TIMING_1440X480I60 = 18, + HDMI_VIDEO_TIMING_1440X480P60 = 19, + HDMI_VIDEO_TIMING_1440X480I120 = 20, + HDMI_VIDEO_TIMING_1440X480I240 = 21, + HDMI_VIDEO_TIMING_1440X576I50 = 22, + HDMI_VIDEO_TIMING_1440X576P50 = 23, + HDMI_VIDEO_TIMING_1440X576I60 = 24, + HDMI_VIDEO_TIMING_1440X576I100 = 25, + HDMI_VIDEO_TIMING_1440X576I200 = 26, + HDMI_VIDEO_TIMING_2880X288P50 = 27, + HDMI_VIDEO_TIMING_2880X480I60 = 28, + HDMI_VIDEO_TIMING_2880X480P60 = 29, + HDMI_VIDEO_TIMING_2880X240I60 = 30, + HDMI_VIDEO_TIMING_2880X576I50 = 31, + HDMI_VIDEO_TIMING_2880X576P50 = 32, + HDMI_VIDEO_TIMING_1680X720P24 = 33, + HDMI_VIDEO_TIMING_1680X720P25 = 34, + HDMI_VIDEO_TIMING_1680X720P30 = 35, + HDMI_VIDEO_TIMING_1680X720P48 = 36, + HDMI_VIDEO_TIMING_1680X720P50 = 37, + HDMI_VIDEO_TIMING_1680X720P60 = 38, + HDMI_VIDEO_TIMING_1680X720P100 = 39, + HDMI_VIDEO_TIMING_1680X720P120 = 40, + HDMI_VIDEO_TIMING_2560X1080P24 = 41, + HDMI_VIDEO_TIMING_2560X1080P25 = 42, + HDMI_VIDEO_TIMING_2560X1080P30 = 43, + HDMI_VIDEO_TIMING_2560X1080P48 = 44, + HDMI_VIDEO_TIMING_2560X1080P50 = 45, + HDMI_VIDEO_TIMING_2560X1080P60 = 46, + HDMI_VIDEO_TIMING_2560X1080P100 = 47, + HDMI_VIDEO_TIMING_2560X1080P120 = 48, + HDMI_VIDEO_TIMING_1920X1080I60 = 49, + HDMI_VIDEO_TIMING_1920X1080P60 = 50, + HDMI_VIDEO_TIMING_1920X1080I50 = 51, + HDMI_VIDEO_TIMING_1920X1080P50 = 52, + HDMI_VIDEO_TIMING_1920X1080P24 = 53, + HDMI_VIDEO_TIMING_1920X1080P25 = 54, + HDMI_VIDEO_TIMING_1920X1080P30 = 55, + HDMI_VIDEO_TIMING_1920X1080P48 = 56, + HDMI_VIDEO_TIMING_1920X1080I100 = 57, + HDMI_VIDEO_TIMING_1920X1080I120 = 58, + HDMI_VIDEO_TIMING_1920X1080P120 = 59, + HDMI_VIDEO_TIMING_1920X1080P100 = 60, + HDMI_VIDEO_TIMING_3840X2160P24 = 61, + HDMI_VIDEO_TIMING_3840X2160P25 = 62, + HDMI_VIDEO_TIMING_3840X2160P30 = 63, + HDMI_VIDEO_TIMING_3840X2160P48 = 64, + HDMI_VIDEO_TIMING_3840X2160P50 = 65, + HDMI_VIDEO_TIMING_3840X2160P60 = 66, + HDMI_VIDEO_TIMING_3840X2160P100 = 67, + HDMI_VIDEO_TIMING_3840X2160P120 = 68, + HDMI_VIDEO_TIMING_4096X2160P24 = 69, + HDMI_VIDEO_TIMING_4096X2160P25 = 70, + HDMI_VIDEO_TIMING_4096X2160P30 = 71, + HDMI_VIDEO_TIMING_4096X2160P48 = 72, + HDMI_VIDEO_TIMING_4096X2160P50 = 73, + HDMI_VIDEO_TIMING_4096X2160P60 = 74, + HDMI_VIDEO_TIMING_4096X2160P100 = 75, + HDMI_VIDEO_TIMING_4096X2160P120 = 76, + HDMI_VIDEO_TIMING_5120X2160P24 = 77, + HDMI_VIDEO_TIMING_5120X2160P25 = 78, + HDMI_VIDEO_TIMING_5120X2160P30 = 79, + HDMI_VIDEO_TIMING_5120X2160P48 = 80, + HDMI_VIDEO_TIMING_5120X2160P50 = 81, + HDMI_VIDEO_TIMING_5120X2160P60 = 82, + HDMI_VIDEO_TIMING_5120X2160P100 = 83, + HDMI_VIDEO_TIMING_5120X2160P120 = 84, + HDMI_VIDEO_TIMING_7680X4320P24 = 85, + HDMI_VIDEO_TIMING_7680X4320P25 = 86, + HDMI_VIDEO_TIMING_7680X4320P30 = 87, + HDMI_VIDEO_TIMING_7680X4320P48 = 88, + HDMI_VIDEO_TIMING_7680X4320P50 = 89, + HDMI_VIDEO_TIMING_7680X4320P60 = 90, + HDMI_VIDEO_TIMING_7680X4320P100 = 91, + HDMI_VIDEO_TIMING_7680X4320P120 = 92, + HDMI_VIDEO_TIMING_10240X4320P24 = 93, + HDMI_VIDEO_TIMING_10240X4320P25 = 94, + HDMI_VIDEO_TIMING_10240X4320P30 = 95, + HDMI_VIDEO_TIMING_10240X4320P48 = 96, + HDMI_VIDEO_TIMING_10240X4320P50 = 97, + HDMI_VIDEO_TIMING_10240X4320P60 = 98, + HDMI_VIDEO_TIMING_10240X4320P100 = 99, + HDMI_VIDEO_TIMING_10240X4320P120 = 100, + HDMI_VIDEO_TIMING_VESA_DEFINE = 101, + HDMI_VIDEO_TIMING_VESA_800X600_60 = 102, + HDMI_VIDEO_TIMING_VESA_848X480_60 = 103, + HDMI_VIDEO_TIMING_VESA_1024X768_60 = 104, + HDMI_VIDEO_TIMING_VESA_1280X720_60 = 105, + HDMI_VIDEO_TIMING_VESA_1280X768_60 = 106, + HDMI_VIDEO_TIMING_VESA_1280X768_60_RB = 107, + HDMI_VIDEO_TIMING_VESA_1280X800_60 = 108, + HDMI_VIDEO_TIMING_VESA_1280X800_60_RB = 109, + HDMI_VIDEO_TIMING_VESA_1280X960_60 = 110, + HDMI_VIDEO_TIMING_VESA_1280X1024_60 = 111, + HDMI_VIDEO_TIMING_VESA_1360X768_60 = 112, + HDMI_VIDEO_TIMING_VESA_1366X768_60 = 113, + HDMI_VIDEO_TIMING_VESA_1400X1050_60 = 114, + HDMI_VIDEO_TIMING_VESA_1440X900_60 = 115, + HDMI_VIDEO_TIMING_VESA_1440X900_60_RB = 116, + HDMI_VIDEO_TIMING_VESA_1440X1050_60 = 117, + HDMI_VIDEO_TIMING_VESA_1440X1050_60_RB = 118, + HDMI_VIDEO_TIMING_VESA_1600X900_60_RB = 119, + HDMI_VIDEO_TIMING_VESA_1600X1200_60 = 120, + HDMI_VIDEO_TIMING_VESA_1680X1050_60 = 113, + HDMI_VIDEO_TIMING_VESA_1680X1050_60_RB = 114, + HDMI_VIDEO_TIMING_VESA_1792X1344_60 = 115, + HDMI_VIDEO_TIMING_VESA_1856X1392_60 = 116, + HDMI_VIDEO_TIMING_VESA_1920X1080_60 = 117, + HDMI_VIDEO_TIMING_VESA_1920X1200_60 = 118, + HDMI_VIDEO_TIMING_VESA_1920X1200_60_RB = 119, + HDMI_VIDEO_TIMING_VESA_1920X1440_60 = 120, + HDMI_VIDEO_TIMING_VESA_2048X1152_60 = 121, + HDMI_VIDEO_TIMING_VESA_2560X1440_60_RB = 122, + HDMI_VIDEO_TIMING_VESA_2560X1600_60 = 123, + HDMI_VIDEO_TIMING_VESA_2560X1600_60_RB = 124, + HDMI_VIDEO_TIMING_USER_DEFINE = 125, + HDMI_VIDEO_TIMING_USER_1920X2160_30 = 126, + HDMI_VIDEO_TIMING_USER_2560X1440_30 = 127, + HDMI_VIDEO_TIMING_USER_2560X1440_60 = 128, + HDMI_VIDEO_TIMING_USER_1280X720_60 = 129, + HDMI_VIDEO_TIMING_USER_1366X768_60 = 130, + HDMI_VIDEO_TIMING_USER_1600X900_60_RB = 131, + HDMI_VIDEO_TIMING_USER_1920X1080_60 = 132, + HDMI_VIDEO_TIMING_USER_2048X1152_60 = 133, + HDMI_VIDEO_TIMING_BUTT, +}; + +/** + * @brief Enumerates picture aspect ratio, + * see the section 8.2.1 of HDMI Specification 1.4 for details. + * + * @since 1.0 + */ +enum HdmiPictureAspectRatio { + HDMI_PICTURE_ASPECT_NO_DATA = 0, + HDMI_PICTURE_ASPECT_4_3 = 1, + HDMI_PICTURE_ASPECT_16_9 = 2, + HDMI_PICTURE_ASPECT_64_27 = 3, + HDMI_PICTURE_ASPECT_256_135 = 4, + HDMI_PICTURE_ASPECT_BUTT = 5, +}; + +/** + * @brief Enumerates active format aspect ratio, + * see the section 8.2.1 of HDMI Specification 1.4 for details. + * + * @since 1.0 + */ +enum HdmiActiveFormatAspectRatio { + HDMI_ACTIVE_FORMAT_ASPECT_16_9_TOP = 2, + HDMI_ACTIVE_FORMAT_ASPECT_14_9_TOP = 3, + HDMI_ACTIVE_FORMAT_ASPECT_16_9_CENTER = 4, + HDMI_ACTIVE_FORMAT_ASPECT_PICTURE = 8, + HDMI_ACTIVE_FORMAT_ASPECT_4_3 = 9, + HDMI_ACTIVE_FORMAT_ASPECT_16_9 = 10, + HDMI_ACTIVE_FORMAT_ASPECT_14_9 = 11, + HDMI_ACTIVE_FORMAT_ASPECT_4_3_SP_14_9 = 13, + HDMI_ACTIVE_FORMAT_ASPECT_16_9_SP_14_9 = 14, + HDMI_ACTIVE_FORMAT_ASPECT_16_9_SP_4_3 = 15, + HDMI_ACTIVE_FORMAT_ASPECT_BUTT, +}; + +/** + * @brief Enumerates Nups(non-uniform picture scaling), + * see the section 8.2.1 of HDMI Specification 1.4 for details. + * + * @since 1.0 + */ +enum HdmiNups { + HDMI_NUPS_UNKNOWN = 0, /* No Known non-uniform scaling */ + HDMI_NUPS_HORIZONTAL = 1, /* Picture has been scaled horizontally */ + HDMI_NUPS_VERTICAL = 2, /* Picture has been scaled vertically */ + HDMI_NUPS_BOTH = 3, /* Picture has been scaled horizontally and vertically */ +}; + +/** + * @brief Defines the video attribute struct. + * + * @since 1.0 + */ +struct HdmiVideoAttr { + uint32_t tmdsClock; /* unit: KHz */ + uint32_t pixelClock; /* unit: KHz */ + uint32_t pixelRepeat; + enum HdmiColorSpace colorSpace; + enum HdmiColorimetry colorimetry; + enum HdmiExtendedColorimetry extColorimetry; + enum HdmiQuantizationRange quantization; + enum HdmiYccQuantizationRange yccQuantization; + enum HdmiDeepColor deepColor; + enum HdmiVideo3dStructure _3dStruct; + enum HdmiVideoTiming timing; + enum HdmiPictureAspectRatio aspect; + enum HdmiActiveFormatAspectRatio activeAspect; + enum HdmiNups nups; + bool xvycc; +}; + +/** + * @brief Enumerates audio coding type, + * see the section 7 of HDMI Specification 1.4 for details. + * + * @since 1.0 + */ +enum HdmiAudioCodingType { + HDMI_AUDIO_CODING_TYPE_STREAM = 0, + HDMI_AUDIO_CODING_TYPE_LPCM = 1, + HDMI_AUDIO_CODING_TYPE_AC3 = 2, + HDMI_AUDIO_CODING_TYPE_MPEG1 = 3, + HDMI_AUDIO_CODING_TYPE_MP3 = 4, + HDMI_AUDIO_CODING_TYPE_MPEG2 = 5, + HDMI_AUDIO_CODING_TYPE_AAC_LC = 6, + HDMI_AUDIO_CODING_TYPE_DTS = 7, + HDMI_AUDIO_CODING_TYPE_ATRAC = 8, + HDMI_AUDIO_CODING_TYPE_OBA = 9, + HDMI_AUDIO_CODING_TYPE_EAC3 = 10, + HDMI_AUDIO_CODING_TYPE_DTS_HD = 11, + HDMI_AUDIO_CODING_TYPE_MLP = 12, + HDMI_AUDIO_CODING_TYPE_DST = 13, + HDMI_AUDIO_CODING_TYPE_WMA_PRO = 14, + HDMI_AUDIO_CODING_TYPE_CXT = 15, +}; + +/** + * @brief Enumerates audio interface type. + * + * @since 1.0 + */ +enum HdmiAudioInterfaceType { + HDMI_AUDIO_IF_TYPE_I2S = 0, /* Inter-IC Sound */ + HDMI_AUDIO_IF_TYPE_SPDIF = 1, /* Sony/Philips Digital Interface */ + HDMI_AUDIO_IF_TYPE_OTHER, +}; + +/** + * @brief Enumerates audio bit depth, + * see the section 7 of HDMI Specification 1.4 for details. + * + * @since 1.0 + */ +enum HdmiAudioBitDepth { + HDMI_ADIO_BIT_DEPTH_UNKNOWN, + HDMI_ADIO_BIT_DEPTH_8 = 8, + HDMI_ADIO_BIT_DEPTH_16 = 16, + HDMI_ADIO_BIT_DEPTH_18 = 18, + HDMI_ADIO_BIT_DEPTH_20 = 20, + HDMI_ADIO_BIT_DEPTH_24 = 24, + HDMI_ADIO_BIT_DEPTH_32 = 32, + HDMI_ADIO_BIT_DEPTH_BUTT, +}; + +/** + * @brief Enumerates sample rate used for audio, + * see the section 7.3 of HDMI Specification 1.4 for details. + * + * @since 1.0 + */ +enum HdmiSampleRate { + HDMI_SAMPLE_RATE_UNKNOWN, + HDMI_SAMPLE_RATE_8K = 8000, + HDMI_SAMPLE_RATE_11K = 11025, + HDMI_SAMPLE_RATE_12K = 12000, + HDMI_SAMPLE_RATE_16K = 16000, + HDMI_SAMPLE_RATE_22K = 22050, + HDMI_SAMPLE_RATE_24K = 24000, + HDMI_SAMPLE_RATE_32K = 32000, + HDMI_SAMPLE_RATE_44K = 44100, + HDMI_SAMPLE_RATE_48K = 48000, + HDMI_SAMPLE_RATE_88K = 88200, + HDMI_SAMPLE_RATE_96K = 96000, + HDMI_SAMPLE_RATE_176K = 176400, + HDMI_SAMPLE_RATE_192K = 192000, + HDMI_SAMPLE_RATE_768K = 768000, + HDMI_SAMPLE_RATE_BUTT, +}; + +/** + * @brief Enumerates audio format channel, + * see the section 7 of HDMI Specification 1.4 for details. + * + * @since 1.0 + */ +enum HdmiAudioFormatChannel { + HDMI_AUDIO_FORMAT_CHANNEL_2 = 2, + HDMI_AUDIO_FORMAT_CHANNEL_3, + HDMI_AUDIO_FORMAT_CHANNEL_4, + HDMI_AUDIO_FORMAT_CHANNEL_5, + HDMI_AUDIO_FORMAT_CHANNEL_6, + HDMI_AUDIO_FORMAT_CHANNEL_7, + HDMI_AUDIO_FORMAT_CHANNEL_8, + HDMI_AUDIO_FORMAT_CHANNEL_BUTT, +}; + +/** + * @brief Defines the audio attribute struct. + * + * @since 1.0 + */ +struct HdmiAudioAttr { + enum HdmiAudioCodingType codingType; + enum HdmiAudioInterfaceType ifType; + enum HdmiAudioBitDepth bitDepth; + enum HdmiSampleRate sampleRate; + bool downSample; + enum HdmiAudioFormatChannel channels; +}; + +/** + * @brief Enumerates Electro-Optical Transfer Function (EOTF), + * see the section 6.9 of CTA-861-G for details. + * + * @since 1.0 + */ +enum HdmiEotfType { + HDMI_EOTF_SDR_LUMIN = 0, /* Traditional gamma - SDR Luminance Range */ + HDMI_EOTF_HDR_LUMIN = 1, /* Traditional gamma - HDR Luminance Range */ + HDMI_EOTF_SMPTE_ST_2048 = 2, /* SMPTE ST 2048 */ + HDMI_EOTF_HLG = 3, /* Hybrid Log-Gamma (HLG) based on ITU-R BT.2100-0 */ + HDMI_EOTF_BUTT, +}; + +/** + * @brief Enumerates hdr colormetry, + * see HDMI Specification 2.1 for details. + * + * @since 1.0 + */ +enum HdmiHdrColormetry { + HDMI_HDR_COLORIMETRY_NONE, + HDMI_HDR_COLORIMETRY_ITU_601, + HDMI_HDR_COLORIMETRY_ITU_709, + HDMI_HDR_COLORIMETRY_EXTENDED, + HDMI_HDR_EXTENDED_COLORIMETRY_XV_YCC_601, + HDMI_HDR_EXTENDED_COLORIMETRY_XV_YCC_709, + HDMI_HDR_EXTENDED_COLORIMETRY_S_YCC_601, + HDMI_HDR_EXTENDED_COLORIMETRY_ADOBE_YCC_601, + HDMI_HDR_EXTENDED_COLORIMETRY_ADOBE_RGB, + HDMI_HDR_EXTENDED_COLORIMETRY_2020_CONST_LUMINOUS, /* BT2020 c_ycc */ + HDMI_HDR_EXTENDED_COLORIMETRY_2020_NON_CONST_LUMINOUW +}; + +/** + * @brief Enumerates hdr mode, + * see HDMI Specification 2.1 for details. + * + * @since 1.0 + */ +enum HdmiHdrMode { + HDMI_HDR_MODE_DISABLE, /* HDR & dolby mode disable */ + HDMI_HDR_MODE_DOLBY_NORMAL, /* dolby normal(ycbcr422-12bit) mode enable */ + HDMI_HDR_MODE_DOLBY_TUNNELING, /* dolby tunneling(RGB-8bit) mode enable */ + HDMI_HDR_MODE_CEA_861_3, /* HDR standard mode enable(according to ) */ + HDMI_HDR_MODE_CEA_861_3_AUTHEN, /* HDR authen mode */ + HDMI_HDR_MODE_BUTT +}; + +/** + * @brief Enumerates hdr user mode, + * see HDMI Specification 2.1 for details. + * + * @since 1.0 + */ +enum HdmiHdrUserMode { + HDMI_HDR_USERMODE_SDR, + HDMI_HDR_USERMODE_HDR10, + HDMI_HDR_USERMODE_DOLBY, + HDMI_HDR_USERMODE_BUTT +}; + +/** + * @brief Enumerates static metadata type, + * see the section 6.9 of CTA-861-G for details. + * + * @since 1.0 + */ +enum HdmiStaticMetadataType { + HDMI_DRM_STATIC_METADATA_TYPE_1 = 0, /* Static Metadata Type 1 */ + HDMI_DRM_STATIC_METADATA_BUTT, +}; + +/** + * @brief Enumerates static metadata descriptor1st, + * see the section 6.9 of CTA-861-G for details. + * + * @since 1.0 + */ +struct HdmiStaticMetadataDescriptor1st { + uint16_t displayPrimaries0X; /* display_primaries_x[0], in units of 0.00002 */ + uint16_t displayPrimaries0Y; /* display_primaries_y[0], in units of 0.00002 */ + uint16_t displayPrimaries1X; /* display_primaries_x[1], in units of 0.00002 */ + uint16_t displayPrimaries1Y; /* display_primaries_y[1], in units of 0.00002 */ + uint16_t displayPrimaries2X; /* display_primaries_x[2], in units of 0.00002 */ + uint16_t displayPrimaries2Y; /* display_primaries_y[2], in units of 0.00002 */ + uint16_t whitePointX; /* white_point_x, in units of 0.00002 */ + uint16_t whitePointY; /* white_point_y, in units of 0.00002 */ + uint16_t maxDisplayMasteringLuminance; /* max_display_mastering_luminance, in units of 1 cd/m^2 */ + uint16_t minDisplayMasteringLuminance; /* min_display_mastering_luminance, in units of 0.0001 cd/m^2 */ + uint16_t maxContentLightLevel; /* Maximum Content Light Level, in units of 1 cd/m^2 */ + uint16_t maxFrameAverageLightLevel; /* Maximum Frame-average Light Level, in units of 1 cd/m^2 */ +}; + +/** + * @brief Defines the static metadata descriptor, + * see the section 6.9 of CTA-861-G for details. + * + * @since 1.0 + */ +union HdmiStaticMetadataDescriptor { + struct HdmiStaticMetadataDescriptor1st type1; +}; + +/** + * @brief Defines the hdr attribute struct. + * + * @since 1.0 + */ +struct HdmiHdrAttr { + enum HdmiHdrMode mode; + enum HdmiHdrUserMode userMode; + /* The following members are valid, when mode is HDMI_HDR_MODE_CEA_861_3. */ + enum HdmiEotfType eotfType; + enum HdmiStaticMetadataType metadataType; + union HdmiStaticMetadataDescriptor descriptor; + enum HdmiHdrColormetry colorimetry; +}; + +/** + * @brief Defines the hdmi HPD(Hot Plug Detect) callback info. + * + * @since 1.0 + */ +struct HdmiHpdCallbackInfo { + void *data; + void (*callbackFunc)(void *data, bool hdp); +}; + +/** + * @brief Opens an HDMI controller with a specified bus number. + * + * Before using the HDMI interface, you can obtain the device handle of the HDMI controller + * by calling {@link HdmiOpen}. This function is used in pair with {@link HdmiClose}. + * + * @param busNum Indicates the bus number. + * + * @return Returns the device handle {@link DevHandle} of the HDMI controller if the operation is successful; + * returns NULL otherwise. + * + * @since 1.0 + */ +DevHandle HdmiOpen(uint16_t busNum); + +/** + * @brief HDMI transmission start. + * + * This function is used in pair with {@link HdmiStop}. + * + * @param handle Indicates the pointer to the device handle of the HDMI controller. + * + * @return Returns 0 if the operation is successful; returns a negative value if the operation fails. + * + * @since 1.0 + */ +int32_t HdmiStart(DevHandle handle); + +/** + * @brief HDMI transmission stop. + * + * This function is used in pair with {@link HdmiStart}. + * + * @param handle Indicates the pointer to the device handle of the HDMI controller. + * + * @return Returns 0 if the operation is successful; returns a negative value if the operation fails. + * + * @since 1.0 + */ +int32_t HdmiStop(DevHandle handle); + +/** + * @brief HDMI Avmute set. + * + * First put the display device into the black screen mute state, waitting for the HDMI output device switch, + * and then send a Clear AVMute signal, so that the display device to boot, so that the switching process of + * the screen will be shielded. + * + * @param handle Indicates the pointer to the device handle of the HDMI controller. + * @param enable Indicates whether to enable avmute. + * + * @return Returns 0 if the operation is successful; returns a negative value if the operation fails. + * + * @since 1.0 + */ +int32_t HdmiAvmuteSet(DevHandle handle, bool enable); + + +/** + * @brief HDMI deep color set. + * + * @param handle Indicates the pointer to the device handle of the HDMI controller. + * @param color Indicates the deep color to be set, see {@link HdmiDeepColor}. + * + * @return Returns 0 if the operation is successful; returns a negative value if the operation fails. + * + * @since 1.0 + */ +int32_t HdmiDeepColorSet(DevHandle handle, enum HdmiDeepColor color); + +/** + * @brief HDMI deep color get. + * + * @param handle Indicates the pointer to the device handle of the HDMI controller. + * @param color Indicates the pointer to the deep color to read, see {@link HdmiDeepColor}. + * + * @return Returns 0 if the operation is successful; returns a negative value if the operation fails. + * + * @since 1.0 + */ +int32_t HdmiDeepColorGet(DevHandle handle, enum HdmiDeepColor *color); + +/** + * @brief HDMI set video attribute. + * + * @param handle Indicates the pointer to the device handle of the HDMI controller. + * @param attr Indicates the pointer to the video attribute to set, see {@link HdmiVideoAttr}. + * + * @return Returns 0 if the operation is successful; returns a negative value if the operation fails. + * + * @since 1.0 + */ +int32_t HdmiSetVideoAttribute(DevHandle handle, struct HdmiVideoAttr *attr); + +/** + * @brief HDMI set audio attribute. + * + * @param handle Indicates the pointer to the device handle of the HDMI controller. + * @param attr Indicates the pointer to the audio attribute to set, see {@link HdmiAudioAttr}. + * + * @return Returns 0 if the operation is successful; returns a negative value if the operation fails. + * + * @since 1.0 + */ +int32_t HdmiSetAudioAttribute(DevHandle handle, struct HdmiAudioAttr *attr); + +/** + * @brief HDMI set hdr attribute. + * + * @param handle Indicates the pointer to the device handle of the HDMI controller. + * @param attr Indicates the pointer to the hdr attribute to set, see {@link HdmiHdrAttr}. + * + * @return Returns 0 if the operation is successful; returns a negative value if the operation fails. + * + * @since 1.0 + */ +int32_t HdmiSetHdrAttribute(DevHandle handle, struct HdmiHdrAttr *attr); + +/** + * @brief HDMI read sink device's raw EDID data. + * + * @param handle Indicates the pointer to the device handle of the HDMI controller. + * @param buffer Indicates the pointer to the data to read. + * @param len Indicates the length of the data to read. + * + * @return Returns the length of the data read if the operation is successful; + * returns a negative value or 0 if the operation fails. + * + * @since 1.0 + */ +int32_t HdmiReadSinkEdid(DevHandle handle, uint8_t *buffer, uint32_t len); + +/** + * @brief HDMI register HPD(Hot Plug Detect) callback function. + * + * @param handle Indicates the pointer to the device handle of the HDMI controller. + * @param callback Indicates the pointer to the callback info. + * + * @return Returns the length of the data read if the operation is successful; + * returns a negative value or 0 if the operation fails. + * + * @since 1.0 + */ +int32_t HdmiRegisterHpdCallbackFunc(DevHandle handle, struct HdmiHpdCallbackInfo *callback); + +/** + * @brief HDMI unregister HPD(Hot Plug Detect) callback function. + * + * @param handle Indicates the pointer to the device handle of the HDMI controller. + * + * @return Returns the length of the data read if the operation is successful; + * returns a negative value or 0 if the operation fails. + * + * @since 1.0 + */ +int32_t HdmiUnregisterHpdCallbackFunc(DevHandle handle); + +/** + * @brief Closes an HDMI controller. + * + * After the HDMI interface is used, you can close the HDMI controller by calling {@link HdmiClose}. + * This function is used in pair with {@link HdmiOpen}. + * + * @param handle Indicates the pointer to the device handle of the HDMI controller. + * + * @since 1.0 + */ +void HdmiClose(DevHandle handle); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_IF_H */ diff --git a/include/platform/i2s_if.h b/include/platform/i2s_if.h old mode 100644 new mode 100755 index a5106c68911062982c678c1799168b1c7a7843e6..bbb67caa82687243426bcfff18794920e567e13a --- a/include/platform/i2s_if.h +++ b/include/platform/i2s_if.h @@ -74,8 +74,8 @@ enum I2sWordWidth { enum I2sMode { I2S_MODE_MASTER_TX_MODE, I2S_MODE_MASTER_RX_MODE, - I2S_MODE_SLAVE_TX_MODE, - I2S_MODE_SLAVE_RX_MODE, + I2S_MODE_STANDBY_TX_MODE, + I2S_MODE_STANDBY_RX_MODE, }; enum I2sLoopMode { @@ -142,7 +142,7 @@ enum I2slFsSel { struct I2sCfg { enum I2sSampleRate sampleRate; /**< I2S sample rate, 8k,16k,32k... */ enum I2sWordWidth width; /**< I2S word width, 8bit,16bit,20bit,24bit... */ - enum I2sMode mode; /**< I2S mode, master/slave, tx/rx */ + enum I2sMode mode; /**< I2S mode, master/standby, tx/rx */ enum I2sPcmFscDelay syncMode; /**< pcm mode, FSC starts location */ enum I2sLoopMode loopMode; /**< is loopback */ enum I2sProtocolType type; /**< I2S protocol type */ diff --git a/include/platform/i3c_ccc.h b/include/platform/i3c_ccc.h new file mode 100644 index 0000000000000000000000000000000000000000..272efa902849fdb6d41f8ca4ecd63bfa7ef4efee --- /dev/null +++ b/include/platform/i3c_ccc.h @@ -0,0 +1,89 @@ +/* + * Copyright (c) 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 I3C_CCC_H +#define I3C_CCC_H + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/** CCC(Common Command Code) structure */ +struct I3cCccCmd; + +/** Broatcast commands */ +#define I3C_CCC_ENEC_B 0x00 +#define I3C_CCC_DISEC_B 0x01 +#define I3C_CCC_ENTAS0_B 0x02 +#define I3C_CCC_ENTAS1_B 0x03 +#define I3C_CCC_ENTAS2_B 0x04 +#define I3C_CCC_ENTAS3_B 0x05 +#define I3C_CCC_RSTDAA_B 0x06 +#define I3C_CCC_ENTDAA 0x07 +#define I3C_CCC_DEFSLVS 0x08 +#define I3C_CCC_SETMWL_B 0x09 +#define I3C_CCC_SETMRL_B 0x0a +#define I3C_CCC_ENTTM 0x0b +#define I3C_CCC_ENDXFER 0X12 +#define I3C_CCC_ENTHDR0 0x20 +#define I3C_CCC_ENTHDR1 0x21 +#define I3C_CCC_ENTHDR2 0x22 +#define I3C_CCC_ENTHDR3 0x23 +#define I3C_CCC_ENTHDR4 0x24 +#define I3C_CCC_ENTHDR5 0x25 +#define I3C_CCC_ENTHDR6 0x26 +#define I3C_CCC_ENTHDR7 0x27 +#define I3C_CCC_SETXTIME_B 0x28 +#define I3C_CCC_SETAASA 0X29 +#define I3C_CCC_VENDOR_B 0x61 +/** Driect commands */ +#define I3C_CCC_ENEC_D 0x80 +#define I3C_CCC_DISEC_D 0x81 +#define I3C_CCC_ENTAS0_D 0x82 +#define I3C_CCC_ENTAS1_D 0x83 +#define I3C_CCC_ENTAS2_D 0x84 +#define I3C_CCC_ENTAS3_D 0x85 +#define I3C_CCC_RSTDAA_D 0x86 +#define I3C_CCC_SETDASA 0x87 +#define I3C_CCC_SETNEWDA 0x88 +#define I3C_CCC_SETMWL_D 0x89 +#define I3C_CCC_SETMRL_D 0x8a +#define I3C_CCC_GETMWL 0x8b +#define I3C_CCC_GETMRL 0x8c +#define I3C_CCC_GETPID 0x8d +#define I3C_CCC_GETBCR 0x8e +#define I3C_CCC_GETDCR 0x8f +#define I3C_CCC_GETSTATUS 0x90 +#define I3C_CCC_GETACCMST 0x91 +#define I3C_CCC_SETBRGTGT 0x93 +#define I3C_CCC_GETMXDS 0x94 +#define I3C_CCC_GETHDRCAP 0x95 +#define I3C_CCC_SETXTIME_D 0x98 +#define I3C_CCC_GETXTIME 0x99 +#define I3C_CCC_VENDOR_D 0xe0 + +struct I3cCccCmd { + /** CCC(Common Command Code) */ + uint8_t cmd; + /** The destination address of the command, valid only if sending a direct CCC. */ + uint16_t dest; + /** When sending a read command, dataLength represents the length of the read data */ + uint32_t dataLength; + /** When sending a read command, buf is address of the buffer for storing transferred data */ + uint8_t *buf; +}; + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* I3C_CORE_H */ diff --git a/include/platform/i3c_if.h b/include/platform/i3c_if.h new file mode 100644 index 0000000000000000000000000000000000000000..4dce31073c6267fc9441bc10774179ccf1af9866 --- /dev/null +++ b/include/platform/i3c_if.h @@ -0,0 +1,252 @@ +/* + * Copyright (c) 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. + */ + +/** + * @addtogroup I3C + * @{ + * + * @brief Provides Improved Inter-Integrated Circuit (I3C) interfaces. + * + * This module allows a driver to perform operations on an I3C controller for accessing devices on the I3C bus, + * including creating and destroying I3C controller handles as well as reading and writing data. + * + * @since 1.0 + */ + +/** + * @file i3c_if.h + * + * @brief Declares the standard I3C interface functions. + * + * @since 1.0 + */ + +#ifndef I3C_IF_H +#define I3C_IF_H + +#include "hdf_platform.h" +#include "i3c_ccc.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +enum TransMode { + /** I2C transfer mode */ + I2C_MODE = 0, + /** I3C transfer mode */ + I3C_MODE, + /** CCC(Common Command Code) mode */ + CCC_CMD_MODE, +}; + +enum I3cBusMode { + /** Single Data Rate mode */ + I3C_BUS_SDR_MODE = 0, + /** High Data Rate mode */ + I3C_BUS_HDR_MODE, +}; + +/** + * @brief Defines the configurations of I3C controller. + * + * @since 1.0 + */ +struct I3cConfig { + /** I3C bus mode */ + enum I3cBusMode busMode; + /** Current master object, its NULL when the controller is the master */ + struct I3cDevice *curMaster; +}; + +/** + * @brief Defines the I3C transfer message used during I3C transfer, I2C transfer or sending CCC(Common Command Code). + * + * @attention This structure does not limit the data transfer length specified by len. + * The specific I3C controller determines the maximum length allowed. \n + * The device address addr indicates the original device address and does not need to + * contain the read/write flag bit. + * + * @since 1.0 + */ +struct I3cMsg { + /** Address of the target device */ + uint16_t addr; + /** Address of the buffer for storing transferred data */ + uint8_t *buf; + /** Length of the transferred data */ + uint16_t len; + /** + * Transfer Mode Flag | Description + * ------------| ----------------------- + * I2C_FLAG_READ | Read flag + * I2C_FLAG_READ_NO_ACK | No-ACK read flag + * I2C_FLAG_IGNORE_NO_ACK | Ignoring no-ACK flag + * I2C_FLAG_NO_START | No START condition flag + * I2C_FLAG_STOP | STOP condition flag + */ + uint16_t flags; + /** Transfer mode select, using I2C_MODE defalut */ + enum TransMode mode; + /** CCC(Common Command Code) structure, which is used in CCC_CMD_MODE transfer mode */ + struct I3cCccCmd *ccc; + /** I3C error code, update by driver */ + uint16_t err; +}; + +/** + * @brief Defines the data of I3C IBI(In-Band Interrupt). + * + * @attention The data of IBI can be obtained by payload and buf in the IBI function when generate an IBI. + * + * @since 1.0 + */ +struct I3cIbiData { + /** payload data length. Indicates the length of IBI payload data. It is automatically generated when an + * IBI is generated, do not modify while reading. + */ + uint32_t payload; + /** data buffer. The pointer of payload data. */ + uint8_t *buf; +}; + +enum I3cFlag { + /** Read flag. The value 1 indicates the read operation, and 0 indicates the write operation. */ + I3C_FLAG_READ = (0x1 << 0), + /** Non-ACK read flag. The value 1 indicates that no ACK signal is sent during the read process. */ + I3C_FLAG_READ_NO_ACK = (0x1 << 11), + /** Ignoring no-ACK flag. The value 1 indicates that the non-ACK signal is ignored. */ + I3C_FLAG_IGNORE_NO_ACK = (0x1 << 12), + /** + * No START condition flag. The value 1 indicates that there is no START condition for the message + * transfer. + */ + I3C_FLAG_NO_START = (0x1 << 14), + /** STOP condition flag. The value 1 indicates that the current transfer ends with a STOP condition. */ + I3C_FLAG_STOP = (0x1 << 15), +}; + +/** + * @brief IBI(In-Band Interrupt) callback function. + * + * Use {@link I3cRequestIbi} to attach it to an I3C device. + * + * @param handle Indicates the pointer to the device handle of the I3C controller obtained via {@link I3cOpen}. + * @param addr Indicates the address of device to requeset IBI(In-Band Interrupt). + * @param data Indicates the data structure of IBI. + * + * @return Returns 0 if the operation is successful; Returns a negative value otherwise. + * @since 1.0 + */ +typedef int32_t (*I3cIbiFunc)(DevHandle handle, uint16_t addr, struct I3cIbiData data); + +/** + * @brief Obtains the handle of an I3C controller. + * + * You must call this function before accessing the I3C bus. + * + * @param number Indicates the I3C controller ID. + * + * @return Returns the pointer to the {@link DevHandle} of the I3C controller if the operation is successful; + * returns NULL otherwise. + * + * @since 1.0 + */ +DevHandle I3cOpen(int16_t number); + + /** + * @brief Releases the handle of an I3C controller. + * + * If you no longer need to access the I3C controller, you should call this function to close its handle so as + * to release unused memory resources. + * + * @param handle Indicates the pointer to the device handle of the I3C controller obtained via {@link I3cOpen}. + * + * @since 1.0 + */ +void I3cClose(DevHandle handle); + + /** + * @brief Launches an transfer to an I3C device or a compatible I2C device, + * or send a CCC (Common Command Code) to an I3C device which is supported. + * + * @param handle Indicates the pointer to the device handle of the I3C controller obtained via {@link I3cOpen}. + * @param msg Indicates the pointer to the I3C transfer message structure array. + * @param count Indicates the length of the message structure array. + * @param mode Indicates the transmission mode. + * + * @return Returns the number of transferred message structures if the operation is successful; + * returns a negative value otherwise. + * @see I3cMsg + * @attention This function does not limit the number of message structures specified by count or the data + * length of each message structure. The specific I3C controller determines the maximum number and data length allowed. + * + * @since 1.0 + */ +int32_t I3cTransfer(DevHandle handle, struct I3cMsg *msg, int16_t count, enum TransMode mode); + + /** + * @brief Requeset an IBI(in-bind interrupt) for an I3C device which is supported. + * + * @param handle Indicates the pointer to the device handle of the I3C controller obtained via {@link I3cOpen}. + * @param addr Indicates the address of device to requeset IBI(In-Band Interrupt). + * @param func Indicates the call back function of the IBI. + * @param payload Indicates the length of payload data, in bytes. + * + * @return Returns 0 if the operation is successful; Returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t I3cRequestIbi(DevHandle handle, uint16_t addr, I3cIbiFunc func, uint32_t payload); + + /** + * @brief Free the IBI(in-bind interrupt) which is Requeseted by {@link I3cRequestIbi}. + * + * @param handle Indicates the pointer to the device handle of the I3C controller obtained via {@link I3cOpen}. + * @param addr Indicates the address of device to free IBI. + * + * @return Returns 0 if the operation is successful; Returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t I3cFreeIbi(DevHandle handle, uint16_t addr); + + /** + * @brief Set the config of a I3C controller. + * + * @param handle Indicates the pointer to the device handle of the I3C controller obtained via {@link I3cOpen}. + * @param config Indicates the pointer of a configuration structure to set. + * + * @return Returns 0 if the operation is successful; Returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t I3cSetConfig(DevHandle handle, struct I3cConfig *config); + + /** + * @brief Get the config of a I3C controller. + * + * @param handle Indicates the pointer to the device handle of the I3C controller obtained via {@link I3cOpen}. + * @param config Indicates the structure used to store the configuration. + * + * @return Returns 0 if the operation is successful; Returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t I3cGetConfig(DevHandle handle, struct I3cConfig *config); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* I3C_IF_H */ +/** @} */ diff --git a/include/platform/mipi_csi_if.h b/include/platform/mipi_csi_if.h new file mode 100755 index 0000000000000000000000000000000000000000..875cac07dda077885639d4bbfe5fa6e7233d1592 --- /dev/null +++ b/include/platform/mipi_csi_if.h @@ -0,0 +1,557 @@ +/* + * Copyright (c) 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. + */ + +/** + * @addtogroup MIPI CSI + * @{ + * + * @brief Defines standard MIPI CSI APIs for display driver development. + * + * This MIPI CSI module abstracts MIPI CSI capabilities of different system platforms to provide stable APIs + * for display driver development. You can use this module to obtain/release the MIPI CSI device handle, + * initialize the MIPI CSI device, and send/receive commands that interact with display peripherals. + * + * @since 1.0 + */ + +/** + * @file mipi_csi_if.h + * + * @brief Declares standard MIPI CSI APIs for display driver development. + * + * + * + * @since 1.0 + */ + +#ifndef MIPI_CSI_IF_H +#define MIPI_CSI_IF_H + +#include "hdf_platform.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/** + * @brief Maximum number of lanes supported by MIPI RX's Mipi device. + * + * @since 1.0 + */ +#define MIPI_LANE_NUM 4 + +/** + * @brief The maximum number of lanes supported by the LVDS device of Mipi Rx. + * + * @since 1.0 + */ +#define LVDS_LANE_NUM 4 + +/** + * @brief Defines the maximum number of virtual channels supported. + * + * @since 1.0 + */ +#define WDR_VC_NUM 4 + +/** + * @brief Define the number of synchronization codes for each virtual channel of LVDS. + * + * @since 1.0 + */ +#define SYNC_CODE_NUM 4 + +/** + * @brief Maximum 3 groups of extended data types. + * + * @since 1.0 + */ +#define MAX_EXT_DATA_TYPE_NUM 3 + +/** + * @brief Lane distribution of Mipi Rx. + * + * @since 1.0 + */ +typedef enum { + LANE_DIVIDE_MODE_0 = 0, + LANE_DIVIDE_MODE_1 = 1, + LANE_DIVIDE_MODE_BUTT +} LaneDivideMode; + +/** + * @brief MIPI RX input interface type. + * + * @since 1.0 + */ +typedef enum { + /** mipi */ + INPUT_MODE_MIPI = 0x0, + /** SUB_LVDS */ + INPUT_MODE_SUBLVDS = 0x1, + /** LVDS */ + INPUT_MODE_LVDS = 0x2, + /* HISPI */ + INPUT_MODE_HISPI = 0x3, + /** CMOS */ + INPUT_MODE_CMOS = 0x4, + /** BT601 */ + INPUT_MODE_BT601 = 0x5, + /** BT656 */ + INPUT_MODE_BT656 = 0x6, + /** BT1120 */ + INPUT_MODE_BT1120 = 0x7, + /** MIPI Bypass */ + INPUT_MODE_BYPASS = 0x8, + INPUT_MODE_BUTT +} InputMode; + +/** + * @brief Mipi Rx, SLVS input rate. + * + * @since 1.0 + */ +typedef enum { + /** output 1 pixel per clock */ + MIPI_DATA_RATE_X1 = 0, + /** output 2 pixel per clock */ + MIPI_DATA_RATE_X2 = 1, + MIPI_DATA_RATE_BUTT +} MipiDataRate; + +/** + * @brief Mipi crop area properties. + * + * @since 1.0 + */ +typedef struct { + int x; + int y; + unsigned int width; + unsigned int height; +} ImgRect; + +/** + * @brief Type of data transmitted. + * + * @since 1.0 + */ +typedef enum { + DATA_TYPE_RAW_8BIT = 0, + DATA_TYPE_RAW_10BIT, + DATA_TYPE_RAW_12BIT, + DATA_TYPE_RAW_14BIT, + DATA_TYPE_RAW_16BIT, + DATA_TYPE_YUV420_8BIT_NORMAL, + DATA_TYPE_YUV420_8BIT_LEGACY, + DATA_TYPE_YUV422_8BIT, + /** yuv422 8bit transform user define 16bit raw */ + DATA_TYPE_YUV422_PACKED, + DATA_TYPE_BUTT +} DataType; + +/** + * @brief Define YUV and RAW data format and bit depth. + * + * @since 1.0 + */ +typedef struct { + uint8_t devno; + unsigned int num; + unsigned int extDataBitWidth[MAX_EXT_DATA_TYPE_NUM]; + unsigned int extDataType[MAX_EXT_DATA_TYPE_NUM]; +} ExtDataType; + +/** + * @brief MIPI D-PHY WDR MODE defines + * + * @since 1.0 + */ +typedef enum { + HI_MIPI_WDR_MODE_NONE = 0x0, + /** Virtual Channel */ + HI_MIPI_WDR_MODE_VC = 0x1, + /** Data Type */ + HI_MIPI_WDR_MODE_DT = 0x2, + /** DOL Mode */ + HI_MIPI_WDR_MODE_DOL = 0x3, + HI_MIPI_WDR_MODE_BUTT +} MipiWdrMode; + +/** + * @brief Mipi device properties. + * + * @since 1.0 + */ +typedef struct { + /** data type: 8/10/12/14/16 bit */ + DataType inputDataType; + /** MIPI WDR mode */ + MipiWdrMode wdrMode; + /** laneId: -1 - disable */ + short laneId[MIPI_LANE_NUM]; + + union { + /** used by the HI_MIPI_WDR_MODE_DT */ + short dataType[WDR_VC_NUM]; + }; +} MipiDevAttr; + +/** + * @brief LVDS WDR mode. + * + * @since 1.0 + */ +typedef enum { + HI_WDR_MODE_NONE = 0x0, + HI_WDR_MODE_2F = 0x1, + HI_WDR_MODE_3F = 0x2, + HI_WDR_MODE_4F = 0x3, + HI_WDR_MODE_DOL_2F = 0x4, + HI_WDR_MODE_DOL_3F = 0x5, + HI_WDR_MODE_DOL_4F = 0x6, + HI_WDR_MODE_BUTT +} WdrMode; + +/** + * @brief LVDS synchronization mode. + * + * @since 1.0 + */ +typedef enum { + /** sensor SOL, EOL, SOF, EOF */ + LVDS_SYNC_MODE_SOF = 0, + /** SAV, EAV */ + LVDS_SYNC_MODE_SAV, + LVDS_SYNC_MODE_BUTT +} LvdsSyncMode; + +/** + * @brief LVDS Vsync type. + * + * @since 1.0 + */ +typedef enum { + LVDS_VSYNC_NORMAL = 0x00, + LVDS_VSYNC_SHARE = 0x01, + LVDS_VSYNC_HCONNECT = 0x02, + LVDS_VSYNC_BUTT +} LvdsVsyncType; + +/** + * @brief LVDS Vsync column synchronization parameters. + * + * @since 1.0 + */ +typedef struct { + LvdsVsyncType syncType; + + /* hconnect vsync blanking len, valid when the syncType is LVDS_VSYNC_HCONNECT */ + unsigned short hblank1; + unsigned short hblank2; +} LvdsVsyncAttr; + +/** + * @brief Frame ID type. + * + * @since 1.0 + */ +typedef enum { + LVDS_FID_NONE = 0x00, + /** frame identification id in SAV 4th */ + LVDS_FID_IN_SAV = 0x01, + /** frame identification id in first data */ + LVDS_FID_IN_DATA = 0x02, + LVDS_FID_BUTT +} LvdsFidType; + +/** + * @brief Frame ID configuration information. + * + * @since 1.0 + */ +typedef struct { + LvdsFidType fidType; + + /** Sony DOL has the Frame Information Line, in DOL H-Connection mode, + should configure this flag as false to disable output the Frame Information Line */ + unsigned char outputFil; +} LvdsFidAttr; + +/** + * @brief LVDS bit size end mode. + * + * @since 1.0 + */ +typedef enum { + LVDS_ENDIAN_LITTLE = 0x0, + LVDS_ENDIAN_BIG = 0x1, + LVDS_ENDIAN_BUTT +} LvdsBitEndian; + +/** + * @brief LVDS / SubLVDS / HiSPi device properties. + * + * @since 1.0 + */ +typedef struct { + /** data type: 8/10/12/14 bit */ + DataType inputDataType; + /** WDR mode */ + WdrMode wdrMode; + + /** sync mode: SOF, SAV */ + LvdsSyncMode syncMode; + /** normal, share, hconnect */ + LvdsVsyncAttr vsyncAttr; + /** frame identification code */ + LvdsFidAttr fidAttr; + + /** data endian: little/big */ + LvdsBitEndian dataEndian; + /** sync code endian: little/big */ + LvdsBitEndian syncCodeEndian; + /** laneId: -1 - disable */ + short laneId[LVDS_LANE_NUM]; + + /** each vc has 4 params, syncCode[i]: + syncMode is SYNC_MODE_SOF: SOF, EOF, SOL, EOL + syncMode is SYNC_MODE_SAV: invalid sav, invalid eav, valid sav, valid eav */ + unsigned short syncCode[LVDS_LANE_NUM][WDR_VC_NUM][SYNC_CODE_NUM]; +} LvdsDevAttr; + +/** + * @brief The attribute of the combo device. + * + * Since MIPI RX can interface with CSI-2, LVDS, HiSPi and other timing, Mipi Rx is called a combo device. + * + * @since 1.0 + */ +typedef struct { + /** device number */ + uint8_t devno; + /** input mode: MIPI/LVDS/SUBLVDS/HISPI/DC */ + InputMode inputMode; + MipiDataRate dataRate; + /** MIPI Rx device crop area (corresponding to the oringnal sensor input image size) */ + ImgRect imgRect; + + union { + MipiDevAttr mipiAttr; + LvdsDevAttr lvdsAttr; + }; +} ComboDevAttr; + +/** + * @brief PHY common mode voltage mode. + * + * @since 1.0 + */ +typedef enum { + PHY_CMV_GE1200MV = 0x00, + PHY_CMV_LT1200MV = 0x01, + PHY_CMV_BUTT +} PhyCmvMode; + +/** + * @brief Obtains the MIPI CSI device handle with a specified channel ID. + * + * @param id Indicates the MIPI CSI channel ID. + * + * @return Returns the MIPI CSI device handle if the operation is successful; returns NULL otherwise. + * + * @since 1.0 + */ +DevHandle MipiCsiOpen(uint8_t id); + +/** + * @brief Releases the MIPI CSI device handle. + * + * @param handle Indicates the MIPI CSI device handle obtained via {@link MipiCsiOpen}. + * + * @since 1.0 + */ +void MipiCsiClose(DevHandle handle); + +/** + * @brief Set the parameters of Mipi, CMOS or LVDS camera to the controller. + * + * The parameters including working mode, image area, image depth, data rate and physical channel. + * + * @param handle Indicates the MIPI CSI device handle obtained via {@link MipiCsiOpen}. + * @param pAttr Indicates the pointer to the attribute. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiSetComboDevAttr(DevHandle handle, ComboDevAttr *pAttr); + +/** + * @brief Set common mode voltage mode. + * + * @param handle Indicates the MIPI CSI device handle obtained via {@link MipiCsiOpen}. + * @param devno There are 2 device numbers in total, pointing to 0 or 1. + * @param cmvMode Common mode voltage mode parameters. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiSetPhyCmvmode(DevHandle handle, uint8_t devno, PhyCmvMode cmvMode); + +/** + * @brief Reset sensor. + * + * @param handle Indicates the MIPI CSI device handle obtained via {@link MipiCsiOpen}. + * @param snsResetSource The reset signal line number of sensor is called the reset source of sensor in software. + * sns is the abbreviation of sensor. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiResetSensor(DevHandle handle, uint8_t snsResetSource); + +/** + * @brief Unreset sensor. + * + * @param handle Indicates the MIPI CSI device handle obtained via {@link MipiCsiOpen}. + * @param snsResetSource The reset signal line number of sensor is called the reset source of sensor in software. + * sns is the abbreviation of sensor. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiUnresetSensor(DevHandle handle, uint8_t snsResetSource); + +/** + * @brief Reset Mipi Rx. + * + * Different s32WorkingViNum have different enSnsType. + * + * @param handle Indicates the MIPI CSI device handle obtained via {@link MipiCsiOpen}. + * @param comboDev MIPI RX or LVDS device type. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiResetRx(DevHandle handle, uint8_t comboDev); + +/** + * @brief Uneset MIPI RX. + * + * @param handle Indicates the MIPI CSI device handle obtained via {@link MipiCsiOpen}. + * @param comboDev MIPI RX or LVDS device type. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiUnresetRx(DevHandle handle, uint8_t comboDev); + +/** + * @brief Set the lane distribution of Mipi Rx. + * + * Select the specific mode according to the form of hardware connection. + * + * @param handle Indicates the MIPI CSI device handle obtained via {@link MipiCsiOpen}. + * @param laneDivideMode Lane division mode parameters. + * + * @since 1.0 + */ +int32_t MipiCsiSetHsMode(DevHandle handle, LaneDivideMode laneDivideMode); + +/** + * @brief Enable Mipi clock. + * + * Decide whether to use Mipi or LVDS according to the ensnstype parameter + * passed by the upper layer function. + * + * @param handle Indicates the MIPI CSI device handle obtained via {@link MipiCsiOpen}. + * @param comboDev MIPI RX or LVDS device type. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiEnableClock(DevHandle handle, uint8_t comboDev); + +/** + * @brief Disable the clock of Mipi device. + * + * @param handle Indicates the MIPI CSI device handle obtained via {@link MipiCsiOpen}. + * @param comboDev MIPI RX or LVDS device type. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiDisableClock(DevHandle handle, uint8_t comboDev); + +/** + * @brief Enable the sensor clock on Mipi. + * + * @param handle Indicates the MIPI CSI device handle obtained via {@link MipiCsiOpen}. + * @param snsClkSource The clock signal line number of sensor, which is called the clock source of sensor in software. + * sns is the abbreviation of sensor. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiEnableSensorClock(DevHandle handle, uint8_t snsClkSource); + +/** + * @brief Disable the sensor clock. + * + * @param handle Indicates the MIPI CSI device handle obtained via {@link MipiCsiOpen}. + * @param snsClkSource The clock signal line number of sensor, which is called the clock source of sensor in software. + * sns is the abbreviation of sensor. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiDisableSensorClock(DevHandle handle, uint8_t snsClkSource); + +/** + * @brief Set YUV and RAW data format and bit depth. + * + * @param handle Indicates the MIPI CSI device handle obtained via {@link MipiCsiOpen}. + * @param dataType Pointer to image data format. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiSetExtDataType(DevHandle handle, ExtDataType* dataType); + +/** + * @brief Sets additional parameters for a MIPI CSI device. + * + * @param handle Indicates the MIPI CSI device handle obtained via {@link MipiCsiOpen}. + * @param drvData Indicates the pointer to the additional parameters. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiSetDrvData(DevHandle handle, void *drvData); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* MIPI_CSI_IF_H */ diff --git a/include/platform/mipi_dsi_if.h b/include/platform/mipi_dsi_if.h index ca6b5d6cb2a7601f1da624ae93a05707c1f830a3..e77b45f3bef7c5d70b4b2c471d92c56f602d62f6 100644 --- a/include/platform/mipi_dsi_if.h +++ b/include/platform/mipi_dsi_if.h @@ -291,6 +291,18 @@ int32_t MipiDsiRx(DevHandle handle, struct DsiCmdDesc *cmd, int32_t readLen, uin */ int32_t MipiDsiAttach(DevHandle handle, uint8_t *name); +/** + * @brief Sets additional parameters for a MIPI DSI device. + * + * @param handle Indicates the MIPI DSI device handle obtained via {@link MipiDsiOpen}. + * @param panelData Indicates the pointer to the additional parameters. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiDsiSetDrvData(DevHandle handle, void *panelData); + #ifdef __cplusplus #if __cplusplus } diff --git a/include/platform/pin_if.h b/include/platform/pin_if.h new file mode 100644 index 0000000000000000000000000000000000000000..b42e71aa2b48d3c428d0fe6ff2ae96a59e85072b --- /dev/null +++ b/include/platform/pin_if.h @@ -0,0 +1,148 @@ +/* + * Copyright (c) 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. + */ + +/** + * @file pin_if.h + * + * @brief Declares the standard pin interface functions. + * + * @since 1.0 + */ + +#ifndef PIN_IF_H +#define PIN_IF_H + +#include "hdf_platform.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/** + * @brief Enumerates pin pull types. + * + * @since 1.0 + */ +enum PinPullType { + PIN_PULL_NONE = 0, /**< SET PIN SUSPEND. */ + PIN_PULL_UP = 1, /**< SET PIN RESISTANCE UP. */ + PIN_PULL_DOWN = 2, /**< SET PIN RESISTANCE DOWN. */ +}; +/** + * @brief Obtains the handle of a pin. + * + * You must call this function before setting a pin properties. + * + * @param pinName Indicates the pin which you want to setting properties. + * + * @return Returns the pointer to the {@link DevHandle} of the pin controller which + * to get a pin if the operation is successful; + * returns NULL otherwise. + * @since 1.0 + */ +DevHandle PinGet(const char *pinName); + +/** + * @brief Releases the handle of a pin. + * + * If you no longer need to access the pin, you should call this function to close its handle so as + * to release unused memory resources. + * + * @param handle Indicates the pointer to the device handle of the pin. + * + * @since 1.0 + */ +void PinPut(DevHandle handle); + +/** + * @brief Set the pin pullType configuration. + * + * You can call this function when you need to set the pin pull configuration. + * @param handle Indicates the pointer to the device handle of the pin. + * @param pullType Indicates the type of pin pull. + * + * @return Returns 0 if set the pin Pull configuration operation is successfully; + * Returns a negative value otherwise. + * @since 1.0 + */ +int32_t PinSetPull(DevHandle handle, enum PinPullType pullType); + +/** + * @brief Get the pin pullType configuration. + * + * You can call this function when you need to get the pin pull configuration. + * + * @param handle Indicates the pointer to the device handle of the pin. + * @param pullType Indicates the pointer of the Pin Pull Type. + * @return Returns 0 if get the pin Pull configuration operation is successfully; + * Returns a negative value otherwise. + * @since 1.0 + */ +int32_t PinGetPull(DevHandle handle, enum PinPullType *pullType); + +/** + * @brief Set the pin strength configuration. + * + * You can call this function when you need to set the pin strength configuration. + * @param handle Indicates the pointer to the device handle of the pin. + * @param strength Indicates the value of pin strength. + * + * @return Returns 0 if set the pin strength configuration operation is successfully; + * Returns a negative value otherwise. + * @since 1.0 + */ +int32_t PinSetStrength(DevHandle handle, uint32_t strength); + +/** + * @brief Get the pin strength configuration. + * + * You can call this function when you need to get the pin strength configuration. + * + * @param handle Indicates the pointer to the device handle of the pin. + * @param strength Indicates the pointer of the Pin strength value. + * @return Returns 0 if get the pin strength configuration operation is successfully; + * Returns a negative value otherwise. + * @since 1.0 + */ +int32_t PinGetStrength(DevHandle handle, uint32_t *strength); + +/** + * @brief Set the pin function configuration. + * + * You can call this function when you need to set the pin function configuration. + * + * @param handle Indicates the pointer to the device handle of the pin description. + * @param funcName Indicates the pointer of the pin function. + * @return Returns 0 if set the pin function configuration operation is successfully; + * returns a negative value otherwise. + * @since 1.0 + */ +int32_t PinSetFunc(DevHandle handle, const char *funcName); + +/** + * @brief Get the pin function configuration. + * + * You can call this function when you need to get the pin function configuration. + * + * @param handle Indicates the pointer to the device handle of the pin description. + * @param funcName Indicates the double pointer of the pin function. + * @return Returns 0 if get the pin function configuration operation is successfully; + * returns a negative value otherwise. + * @since 1.0 + */ +int32_t PinGetFunc(DevHandle handle, const char **funcName); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* PIN_IF_H */ diff --git a/include/platform/regulator_if.h b/include/platform/regulator_if.h new file mode 100755 index 0000000000000000000000000000000000000000..d3d01a9f9945b8b0c9c37f89202dd08611a8627c --- /dev/null +++ b/include/platform/regulator_if.h @@ -0,0 +1,151 @@ +/* + * Copyright (c) 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 REGULATOR_IF_H +#define REGULATOR_IF_H + +#include "hdf_platform.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/* regulator status on or off */ +enum RegulatorStatus { + REGULATOR_STATUS_ON = 1, + REGULATOR_STATUS_OFF, +}; + +/* regulator mode, set voltage or current */ +enum RegulatorChangeMode { + REGULATOR_CHANGE_VOLTAGE = 1, + REGULATOR_CHANGE_CURRENT, +}; +/** + * @brief Gets a regulator. + * + * This function must be called to get its device handle before operating the regulator. + * + * @param name Indicates regulator name. + * + * @return If the operation is successful, a pointer to the regulator device handle is returned. + * + * @since 1.0 + */ +DevHandle RegulatorOpen(const char *name); +/** + * @brief Releases a regulator. + * + * If you no longer need the regulator, call this function to release it + * + * @param handle Represents a pointer to the regulator device handle. + * + * @since 1.0 + */ +void RegulatorClose(DevHandle handle); +/** + * @brief Enables a regulator. + * + * @param handle Represents a pointer to the regulator handle, which is obtained through {@ link RegulatorOpen}. + * @return 0 If the regulator enables successfully; Otherwise, a negative value is returned. + * + * @attention That if the regulator has been enabled before calling this function, calling this function will succeed. + * + * @since 1.0 + */ +int32_t RegulatorEnable(DevHandle handle); +/** + * @brief Disable a regulator. + * + * @param handle Represents a pointer to the regulator handle, which is obtained through {@ link RegulatorOpen}. + * @return 0 If the regulator disable successfully; Otherwise, a negative value is returned. + * + * @attention If the regulator status alwayson is true or there is regulator child not disable, disabling fail + * + * @since 1.0 + */ +int32_t RegulatorDisable(DevHandle handle); +/** + * @brief Force disable a regulator. + * + * @param handle Represents a pointer to the regulator handle, which is obtained through {@ link RegulatorOpen}. + * @return 0 If the regulator disable successfully; Otherwise, a negative value is returned. + * + * @attention No matter whether the status of the regulator is alwayson or the status of the child is enable, + * the regulator is disabled. + * + * @since 1.0 + */ +int32_t RegulatorForceDisable(DevHandle handle); +/** + * @brief Set the output voltage range of a regulator. + * + * @param handle Represents a pointer to the regulator handle, which is obtained through {@ link RegulatorOpen}. + * @param minUv Represents minimum voltage + * @param minUv Represents maximum voltage + * @return 0 If the regulator setVoltage successfully; Otherwise, a negative value is returned. + * + * @attention If the set voltage is not within the contrants, the setting fails. + * + * @since 1.0 + */ +int32_t RegulatorSetVoltage(DevHandle handle, uint32_t minUv, uint32_t maxUv); +/** + * @brief Get a regulator voltage. + * + * @param handle Represents a pointer to the regulator handle, which is obtained through {@ link RegulatorOpen}. + * @param voltage Voltage obtained. + * @return 0 If the regulator get voltage successfully; Otherwise, a negative value is returned. + * + * @since 1.0 + */ +int32_t RegulatorGetVoltage(DevHandle handle, uint32_t *voltage); +/** + * @brief Set regulator current range + * + * @param handle Represents a pointer to the regulator handle, which is obtained through {@ link RegulatorOpen}. + * @param minUa Minimum current + * @param maxUa Maximum current + * @return 0 If the regulator set current range successfully; Otherwise, a negative value is returned. + * + * @attention If the setting range exceeds the limit, the setting fails + * + * @since 1.0 + */ +int32_t RegulatorSetCurrent(DevHandle handle, uint32_t minUa, uint32_t maxUa); +/** + * @brief Get a regulator current + * + * @param handle Represents a pointer to the regulator handle, which is obtained through {@ link RegulatorOpen}. + * @param voltage Current obtained + * @return 0 If the regulator getCurrent successfully; Otherwise, a negative value is returned. + * + * @since 1.0 + */ +int32_t RegulatorGetCurrent(DevHandle handle, uint32_t *regCurrent); +/** + * @brief Get a regulator status + * + * @param handle Represents a pointer to the regulator handle, which is obtained through {@ link RegulatorOpen}. + * @param status Status obtained, enable or disable + * @return 0 If the regulator get status successfully; Otherwise, a negative value is returned. + * + * @since 1.0 + */ +int32_t RegulatorGetStatus(DevHandle handle, uint32_t *status); +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* REGULATOR_IF_H */ +/** @} */ \ No newline at end of file diff --git a/include/platform/watchdog_if.h b/include/platform/watchdog_if.h index be2682670c31898e5337e58adc5c27dbe8bfe42a..cb443e463fc8ccf86e68ac7d6721c7f9c2086bac 100644 --- a/include/platform/watchdog_if.h +++ b/include/platform/watchdog_if.h @@ -63,7 +63,7 @@ enum WatchdogStatus { * * @since 1.0 */ -DevHandle WatchdogOpen(int16_t wdtId); +int32_t WatchdogOpen(int16_t wdtId, DevHandle *handle); /** * @brief Closes a watchdog. diff --git a/include/config/device_resource_if.h b/include/utils/device_resource_if.h similarity index 100% rename from include/config/device_resource_if.h rename to include/utils/device_resource_if.h diff --git a/include/utils/hcs_macro.h b/include/utils/hcs_macro.h new file mode 100755 index 0000000000000000000000000000000000000000..6f0714b8fd3f55328f556abc6ad42c34136a1153 --- /dev/null +++ b/include/utils/hcs_macro.h @@ -0,0 +1,32 @@ +/* + * 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 HCS_MACRO_H +#define HCS_MACRO_H + +// define utils macro +#define HCS_CAT(part1, part2) part1 ## part2 +#define HCS_ROOT root + +// define macro for module +#define HCS_NODE_EXISTS(node) HCS_CAT(node, _exists) +#define HCS_NODE(parent, node) HCS_CAT(parent, _##node) +#define HCS_NODE_HAS_PROP(node, prop) HCS_CAT(node, _##prop##_exists) +#define HCS_PROP(node, prop) HCS_CAT(node, _##prop) + +#define HCS_FOREACH_CHILD(node, func) \ + HCS_CAT(node, _foreach_child)(func) + +#define HCS_FOREACH_CHILD_VARGS(node, func, ...) \ + HCS_CAT(node, _foreach_child_vargs)(func, __VA_ARGS__) + +#define HCS_ARRAYS(arrays_node) HCS_CAT(arrays_node, _data) + +#define HCS_ARRAYS_SIZE(arrays_node) HCS_CAT(arrays_node, _array_size) + +#endif // HCS_MACRO_H \ No newline at end of file diff --git a/ability/sbuf/include/hdf_sbuf.h b/include/utils/hdf_sbuf.h similarity index 100% rename from ability/sbuf/include/hdf_sbuf.h rename to include/utils/hdf_sbuf.h diff --git a/include/wifi/wifi_mac80211_ops.h b/include/wifi/wifi_mac80211_ops.h index aa26a666d813fd88d0fb34e64104ece6b87fde5c..52c81b50bf89871d880561c912741379e86afe31 100644 --- a/include/wifi/wifi_mac80211_ops.h +++ b/include/wifi/wifi_mac80211_ops.h @@ -589,20 +589,6 @@ struct HdfMac80211BaseOps { */ int32_t (*GetHwCapability)(NetDevice *netDev, struct WlanHwCapability **capability); - int32_t (*RemainOnChannel)(NetDevice *netDev, WifiOnChannel *onChannel); - - int32_t (*CancelRemainOnChannel)(NetDevice *netDev); - - int32_t (*ProbeReqReport)(NetDevice *netDev, int32_t report); - - int32_t (*AddIf)(NetDevice *netDev, WifiIfAdd *ifAdd); - - int32_t (*RemoveIf)(NetDevice *netDev, WifiIfRemove *ifRemove); - - int32_t (*SetApWpsP2pIe)(NetDevice *netDev, WifiAppIe *appIe); - - int32_t (*GetDriverFlag)(struct NetDevice *netDev, WifiGetDrvFlags **params); - int32_t (*SendAction)(struct NetDevice *netDev, WifiActionData *actionData); int32_t (*GetIftype)(struct NetDevice *netDev, uint8_t *iftype); @@ -792,5 +778,21 @@ struct HdfMac80211APOps { int32_t (*GetAssociatedStasInfo)(NetDevice *netDev, WifiStaInfo *staInfo, uint32_t num); }; +struct HdfMac80211P2POps { + int32_t (*RemainOnChannel)(NetDevice *netDev, WifiOnChannel *onChannel); + + int32_t (*CancelRemainOnChannel)(NetDevice *netDev); + + int32_t (*ProbeReqReport)(NetDevice *netDev, int32_t report); + + int32_t (*AddIf)(NetDevice *netDev, WifiIfAdd *ifAdd); + + int32_t (*RemoveIf)(NetDevice *netDev, WifiIfRemove *ifRemove); + + int32_t (*SetApWpsP2pIe)(NetDevice *netDev, WifiAppIe *appIe); + + int32_t (*GetDriverFlag)(struct NetDevice *netDev, WifiGetDrvFlags **params); +}; + #endif // WIFI_MAC80211_OPS_H /** @} */ diff --git a/include/wifi/wifi_module.h b/include/wifi/wifi_module.h index 6bb836c2da7979d00566dfba14bba3265fb39acc..bb2d85d96ccea07020ee192112a171feda5fccac 100644 --- a/include/wifi/wifi_module.h +++ b/include/wifi/wifi_module.h @@ -163,6 +163,7 @@ struct HdfChipDriver { struct HdfMac80211BaseOps *ops; /**< MAC address for the basic feature */ struct HdfMac80211STAOps *staOps; /**< MAC address for the STA feature */ struct HdfMac80211APOps *apOps; /**< MAC address for the AP feature */ + struct HdfMac80211P2POps *p2pOps; /**< MAC address for the P2Pfeature */ void *priv; /**< Private data of the chip driver */ /** * @brief Initializes a chip driver. diff --git a/model/audio/common/include/audio_accessory_base.h b/model/audio/common/include/audio_accessory_base.h index ab0f94a06eb5bef64d733212169221c5fda576c7..2ee01ed99f0ebb7ee18c109d170e00c0c26a58ff 100755 --- a/model/audio/common/include/audio_accessory_base.h +++ b/model/audio/common/include/audio_accessory_base.h @@ -8,9 +8,12 @@ #ifndef AUDIO_ACCESSORY_BASE_H #define AUDIO_ACCESSORY_BASE_H - -#include "audio_host.h" #include "audio_control.h" +#include "audio_core.h" +#include "audio_host.h" +#include "audio_parse.h" +#include "audio_platform_base.h" +#include "audio_sapm.h" #ifdef __cplusplus #if __cplusplus @@ -48,17 +51,31 @@ enum I2sFrequencyRegVal { I2S_SAMPLE_FREQUENCY_REG_VAL_96000 = 0xB /* 96kHz sample_rate */ }; -enum I2sFormatRegVal { - I2S_SAMPLE_FORMAT_REG_VAL_MSB_24 = 0x2, /* MSB-justified data up to 24 bits */ - I2S_SAMPLE_FORMAT_REG_VAL_24 = 0x3, /* I2S data up to 24 bits */ - I2S_SAMPLE_FORMAT_REG_VAL_LSB_16 = 0x4, /* LSB-justified 16-bit data */ - I2S_SAMPLE_FORMAT_REG_VAL_LSB_18 = 0x5, /* LSB-justified 18-bit data */ - I2S_SAMPLE_FORMAT_REG_VAL_LSB_20 = 0x6, /* LSB-justified 20-bit data */ - I2S_SAMPLE_FORMAT_REG_VAL_LSB_24 = 0x7, /* LSB-justified 24-bit data */ +struct AccessoryTransferData { + uint16_t i2cDevAddr; + uint16_t i2cBusNumber; + uint32_t accessoryCfgCtrlCount; + struct AudioRegCfgGroupNode **accessoryRegCfgGroupNode; + struct AudioKcontrol *accessoryControls; }; -int32_t FormatToBitWidth(enum AudioFormat format, uint16_t *bitWidth); -int32_t RateToFrequency(uint32_t rate, uint16_t *freq); +struct DaiParamsVal { + uint32_t frequencyVal; + uint32_t formatVal; + uint32_t channelVal; +}; + +int32_t AccessoryI2cReadWrite(struct AudioAddrConfig *regAttr, uint16_t rwFlag); +int32_t AccessoryRegBitsRead(struct AudioMixerControl *regAttr, uint32_t *regValue); +int32_t AccessoryRegBitsUpdate(struct AudioMixerControl regAttr); + +int32_t AcessoryDeviceFrequencyParse(uint32_t rate, uint16_t *freq); +int32_t AccessoryDaiParamsUpdate(struct DaiParamsVal daiParamsVal); +int32_t AccessoryDeviceCfgGet(struct AccessoryData *data, struct AccessoryTransferData *transferData); +int32_t AccessoryDeviceCtrlRegInit(void); +int32_t AccessoryDeviceRegRead(const struct AccessoryDevice *codec, uint32_t reg, uint32_t *value); +int32_t AccessoryDeviceRegWrite(const struct AccessoryDevice *codec, uint32_t reg, uint32_t value); +int32_t AccessoryGetConfigInfo(const struct HdfDeviceObject *device, struct AccessoryData *accessoryData); #ifdef __cplusplus #if __cplusplus diff --git a/model/audio/common/include/audio_codec_base.h b/model/audio/common/include/audio_codec_base.h index f4d5bf3b30c29715e1a8a722e4e83f3d166f6a5c..984da900edde4187a1c125511bdafe5093b9bb6d 100755 --- a/model/audio/common/include/audio_codec_base.h +++ b/model/audio/common/include/audio_codec_base.h @@ -19,12 +19,11 @@ extern "C" { #endif #endif /* __cplusplus */ -int32_t CodecDeviceReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *value); -int32_t CodecDeviceWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t value); -int32_t CodecAiaoDeviceReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *value); -int32_t CodecAiaoDeviceWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t value); int32_t CodecGetServiceName(const struct HdfDeviceObject *device, const char **drvCodecName); int32_t CodecGetDaiName(const struct HdfDeviceObject *device, const char **drvDaiName); +int32_t CodecGetConfigInfo(const struct HdfDeviceObject *device, struct CodecData *codecData); +int32_t CodecSetConfigInfo(struct CodecData *codeData, struct DaiData *daiData); +int32_t CodecSetCtlFunc(struct CodecData *codeData, const void *aiaoGetCtrl, const void *aiaoSetCtrl); #ifdef __cplusplus #if __cplusplus diff --git a/model/audio/common/include/audio_dai_base.h b/model/audio/common/include/audio_dai_base.h new file mode 100644 index 0000000000000000000000000000000000000000..cf70a793c7b457b5615de7020caeb0961ca4f405 --- /dev/null +++ b/model/audio/common/include/audio_dai_base.h @@ -0,0 +1,33 @@ +/* + * Copyright (c) 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 AUDIO_DAI_BASE_H +#define AUDIO_DAI_BASE_H + +#include "audio_codec_if.h" +#include "audio_core.h" +#include "osal_io.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +struct DaiData *DaiDataFromCard(const struct AudioCard *card); +int32_t DaiGetConfigInfo(const struct HdfDeviceObject *device, struct DaiData *data); +int32_t DaiCheckSampleRate(unsigned int sampleRates); +int32_t DaiSetConfigInfo(struct DaiData *data); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif diff --git a/model/audio/common/include/audio_dma_base.h b/model/audio/common/include/audio_dma_base.h new file mode 100644 index 0000000000000000000000000000000000000000..8bd5013d83f9771b1b25341c312a9c53f615c8fb --- /dev/null +++ b/model/audio/common/include/audio_dma_base.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 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 AUDIO_DMA_BASE_H +#define AUDIO_DMA_BASE_H + +#include "audio_host.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +int32_t AudioDmaBufAlloc(struct PlatformData *data, enum AudioStreamType streamType); +int32_t AudioDmaBufFree(struct PlatformData *data, enum AudioStreamType streamType); +int32_t AudioDmaRequestChannel(struct PlatformData *data); +int32_t AudioDmaConfigChannel(struct PlatformData *data); +int32_t AudioDmaPrep(struct PlatformData *data); +int32_t AudioDmaSubmit(struct PlatformData *data); +int32_t AudioDmaPending(struct PlatformData *data); +int32_t AudioDmaPause(struct PlatformData *data); +int32_t AudioDmaResume(struct PlatformData *data); +int32_t AudioDmaPointer(struct PlatformData *data, uint32_t *pointer); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif diff --git a/model/audio/common/include/audio_driver_log.h b/model/audio/common/include/audio_driver_log.h new file mode 100644 index 0000000000000000000000000000000000000000..73ccacc24d6df9ef358c0f3082c239d311a82c08 --- /dev/null +++ b/model/audio/common/include/audio_driver_log.h @@ -0,0 +1,105 @@ +/* + * Copyright (c) 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 AUDIO_DRIVER_LOG_H +#define AUDIO_DRIVER_LOG_H +#include "hdf_log.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +// 1 is on; 0 is off +#define AUDIO_ADM_DEBUG_ON 0 +#define AUDIO_DRIVER_DEBUG_ON 0 +#define AUDIO_DEVICE_DEBUG_ON 0 + +// audio ADM log define +#ifdef __LITEOS__ +#define ADM_LOG_DEBUG(fmt, arg...) do { \ + } while (0) +#elif AUDIO_ADM_DEBUG_ON +#define ADM_LOG_DEBUG(fmt, arg...) do { \ + HDF_LOGD("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) +#else +#define ADM_LOG_DEBUG(fmt, arg...) do { \ + } while (0) +#endif + +#define ADM_LOG_ERR(fmt, arg...) do { \ + HDF_LOGE("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define ADM_LOG_INFO(fmt, arg...) do { \ + HDF_LOGI("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define ADM_LOG_WARNING(fmt, arg...) do { \ + HDF_LOGW("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +// audio driver log define +#ifdef __LITEOS__ +#define AUDIO_DRIVER_LOG_DEBUG(fmt, arg...) do { \ + } while (0) +#elif AUDIO_DRIVER_DEBUG_ON +#define AUDIO_DRIVER_LOG_DEBUG(fmt, arg...) do { \ + HDF_LOGD("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) +#else +#define AUDIO_DRIVER_LOG_DEBUG(fmt, arg...) do { \ + } while (0) +#endif + +#define AUDIO_DRIVER_LOG_ERR(fmt, arg...) do { \ + HDF_LOGE("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define AUDIO_DRIVER_LOG_INFO(fmt, arg...) do { \ + HDF_LOGI("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define AUDIO_DRIVER_LOG_WARNING(fmt, arg...) do { \ + HDF_LOGW("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +// audio device log define +#ifdef __LITEOS__ +#define AUDIO_DEVICE_LOG_DEBUG(fmt, arg...) do { \ + } while (0) +#elif AUDIO_DEVICE_DEBUG_ON +#define AUDIO_DEVICE_LOG_DEBUG(fmt, arg...) do { \ + HDF_LOGD("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) +#else +#define AUDIO_DEVICE_LOG_DEBUG(fmt, arg...) do { \ + } while (0) +#endif + +#define AUDIO_DEVICE_LOG_ERR(fmt, arg...) do { \ + HDF_LOGE("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define AUDIO_DEVICE_LOG_INFO(fmt, arg...) do { \ + HDF_LOGI("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#define AUDIO_DEVICE_LOG_WARNING(fmt, arg...) do { \ + HDF_LOGW("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ + } while (0) + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* AUDIO_DRIVER_LOG_H */ diff --git a/model/audio/common/include/audio_dsp_base.h b/model/audio/common/include/audio_dsp_base.h new file mode 100644 index 0000000000000000000000000000000000000000..5cf40234586024cc850dd4c72b4fa6614c060d7b --- /dev/null +++ b/model/audio/common/include/audio_dsp_base.h @@ -0,0 +1,29 @@ +/* + * Copyright (c) 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 AUDIO_DSP_BASE_H +#define AUDIO_DSP_BASE_H + +#include "audio_host.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +int32_t DspGetServiceName(const struct HdfDeviceObject *device, const char **drvDspName); +int32_t DspGetDaiName(const struct HdfDeviceObject *device, const char **drvDaiName); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* AUDIO_DSP_BASE_H */ diff --git a/model/audio/common/include/audio_platform_base.h b/model/audio/common/include/audio_platform_base.h index 72a9608c00157409484e92cef17c85e62537003f..b895710b8397adf192ed78acf676c5f381f74c81 100755 --- a/model/audio/common/include/audio_platform_base.h +++ b/model/audio/common/include/audio_platform_base.h @@ -9,7 +9,6 @@ #ifndef AUDIO_PLATFORM_BASE_H #define AUDIO_PLATFORM_BASE_H -#include "audio_platform_if.h" #include "audio_host.h" #ifdef __cplusplus @@ -18,6 +17,10 @@ extern "C" { #endif #endif /* __cplusplus */ +#define MIN_PERIOD_SIZE 4096 +#define BITSTOBYTE 8 +#define MAX_BUFF_SIZE (64 * 1024) + enum DataBitWidth { DATA_BIT_WIDTH8 = 8, /* 8 bit witdth */ DATA_BIT_WIDTH16 = 16, /* 16 bit witdth */ @@ -27,9 +30,60 @@ enum DataBitWidth { DATA_BIT_WIDTH32 = 32, /* 32 bit witdth */ }; -struct PlatformData *PlatformDataFromDevice(const struct AudioCard *card); -int32_t PlatformCreatePlatformHost(const struct AudioCard *card, struct PlatformHost **platformHost); +enum PcmStatus { + PCM_STOP = 0, /* pcm stream stop flag */ + PCM_PAUSE, /* pcm stream pause flag */ + PCM_START, /* pcm stream start flag */ +}; + +struct CircleBufInfo { + uint32_t cirBufSize; /* Current DMA cache size */ + uint32_t trafBufSize; /* PCM data per transmission default size */ + uint32_t period; /* not used */ + uint32_t periodSize; /* DMA cache period size */ + uint32_t periodCount; /* Number of DMA cache periods */ + unsigned long phyAddr; /* DMA cache physical address */ + uint32_t *virtAddr; /* DMA cache virtual address */ + uint32_t wbufOffSet; /* DMA cache write address offset */ + uint32_t wptrOffSet; /* DMA cache write pointer offset */ + uint32_t rbufOffSet; /* DMA cache read address offset */ + uint32_t rptrOffSet; /* DMA cache read pointer offset */ + enum PcmStatus runStatus; /* PCM status */ + uint32_t chnId; /* Channel ID */ + uint32_t enable; /* Enable identification */ + struct OsalMutex buffMutex; /* mutex */ + uint32_t framesPosition; /* Frame position */ + uint32_t pointer; /* Read/write pointer position during playback and recording */ + uint32_t periodsMax; /* Maximum number of periods */ + uint32_t periodsMin; /* Minimum number of periods */ + uint32_t cirBufMax; /* Size of DMA cache requested */ + uint32_t curTrafSize; /* The size of each actual transmission of PCM data */ +}; + +unsigned int SysReadl(unsigned long addr); +void SysWritel(unsigned long addr, unsigned int value); + +struct PlatformData *PlatformDataFromCard(const struct AudioCard *card); +uint32_t AudioBytesToFrames(uint32_t frameBits, uint32_t size); int32_t AudioDataBigEndianChange(char *srcData, uint32_t audioLen, enum DataBitWidth bitWidth); +int32_t AudioFramatToBitWidth(enum AudioFormat format, unsigned int *bitWidth); +int32_t AudioSetPcmInfo(struct PlatformData *platformData, const struct AudioPcmHwParams *param); +int32_t AudioSetRenderBufInfo(struct PlatformData *data, const struct AudioPcmHwParams *param); +int32_t AudioSetCaptureBufInfo(struct PlatformData *data, const struct AudioPcmHwParams *param); +int32_t AudioPcmWrite(const struct AudioCard *card, struct AudioTxData *txData); +int32_t AudioPcmRead(const struct AudioCard *card, struct AudioRxData *rxData); +int32_t AudioPcmMmapWrite(const struct AudioCard *card, const struct AudioMmapData *txMmapData); +int32_t AudioPcmMmapRead(const struct AudioCard *card, const struct AudioMmapData *rxMmapData); +int32_t AudioRenderOpen(const struct AudioCard *card); +int32_t AudioCaptureOpen(const struct AudioCard *card); +int32_t AudioRenderClose(const struct AudioCard *card); +int32_t AudioPcmPointer(const struct AudioCard *card, uint32_t *pointer); +int32_t AudioCaptureClose(const struct AudioCard *card); +int32_t AudioHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param); +int32_t AudioRenderPrepare(const struct AudioCard *card); +int32_t AudioCapturePrepare(const struct AudioCard *card); +int32_t AudioRenderTrigger(struct AudioCard *card, int cmd); +int32_t AudioCaptureTrigger(struct AudioCard *card, int cmd); #ifdef __cplusplus #if __cplusplus diff --git a/model/audio/common/src/audio_accessory_base.c b/model/audio/common/src/audio_accessory_base.c index 715440022f0330ad3440b6501ac106e6e1b1b32a..7e79e56fcbea61a10749d90fcf61872bb9f1bafe 100755 --- a/model/audio/common/src/audio_accessory_base.c +++ b/model/audio/common/src/audio_accessory_base.c @@ -7,29 +7,251 @@ */ #include "audio_accessory_base.h" -#include "audio_device_log.h" +#include "audio_driver_log.h" +#include "i2c_if.h" +#include "osal_time.h" -#define HDF_LOG_TAG audio_accessory_base +#define HDF_LOG_TAG "audio_accessory_base" -int32_t FormatToBitWidth(enum AudioFormat format, uint16_t *bitWidth) +#define COMM_SHIFT_8BIT (8) +#define COMM_MASK_FF (0xFF) +#define COMM_WAIT_TIMES (10) // ms + +#define I2C_REG_LEN (1) +#define I2C_REG_MSGLEN (3) +#define I2C_MSG_NUM (2) +#define I2C_MSG_BUF_SIZE (2) + +uint16_t g_i2cDevAddr, g_i2cBusNumber; +struct AudioRegCfgGroupNode **g_audioRegCfgGroupNode = NULL; +struct AudioKcontrol *g_audioControls = NULL; + +/* + * release I2C object public function + */ +static void AccessoryI2cRelease(struct I2cMsg *msgs, int16_t msgSize, DevHandle i2cHandle) { - // current set default format(standard) for 16/24 bit - switch (format) { - case AUDIO_FORMAT_PCM_16_BIT: - *bitWidth = I2S_SAMPLE_FORMAT_REG_VAL_24; - break; - case AUDIO_FORMAT_PCM_24_BIT: - *bitWidth = I2S_SAMPLE_FORMAT_REG_VAL_24; - break; - default: - AUDIO_DEVICE_LOG_ERR("format: %d is not support.", format); - return HDF_ERR_NOT_SUPPORT; + if (msgs != NULL) { + if (msgSize == 0 && msgs->buf != NULL) { + OsalMemFree(msgs->buf); + msgs->buf = NULL; + } else if (msgSize == 1 && msgs[0].buf != NULL) { + OsalMemFree(msgs[0].buf); + msgs[0].buf = NULL; + } else if (msgSize >= I2C_MSG_NUM) { + if (msgs[0].buf != NULL) { + msgs[0].buf = NULL; + } + if (msgs[1].buf != NULL) { + OsalMemFree(msgs[1].buf); + msgs[1].buf = NULL; + } + } + AUDIO_DRIVER_LOG_DEBUG("OsalMemFree msgBuf success.\n"); + } + // close i2c device + if (i2cHandle != NULL) { + I2cClose(i2cHandle); + i2cHandle = NULL; + AUDIO_DRIVER_LOG_DEBUG("I2cClose success.\n"); + } +} + +static int32_t AccessoryI2cMsgFill(const struct AudioAddrConfig *regAttr, uint16_t rwFlag, + uint8_t *regs, struct I2cMsg *msgs) +{ + uint8_t *msgBuf = NULL; + if (rwFlag != 0 && rwFlag != I2C_FLAG_READ) { + AUDIO_DRIVER_LOG_ERR("invalid rwFlag value: %d.", rwFlag); + return HDF_ERR_INVALID_PARAM; + } + regs[0] = regAttr->addr; + msgs[0].addr = g_i2cDevAddr; + msgs[0].flags = 0; + msgs[0].len = I2C_REG_MSGLEN; + AUDIO_DRIVER_LOG_DEBUG("msgs[0].addr=0x%02x, regs[0]=0x%02x.", msgs[0].addr, regs[0]); + if (rwFlag == 0) { // write + // S 11011A2A1 0 A ADDR A MS1 A LS1 A <....> P + msgBuf = OsalMemCalloc(I2C_REG_MSGLEN); + if (msgBuf == NULL) { + AUDIO_DRIVER_LOG_ERR("[write]: malloc buf failed!"); + return HDF_ERR_MALLOC_FAIL; + } + msgBuf[0] = regs[0]; + msgBuf[1] = (uint8_t)(regAttr->value >> COMM_SHIFT_8BIT); // High 8 bit + msgBuf[I2C_MSG_BUF_SIZE] = (uint8_t)(regAttr->value & COMM_MASK_FF); // Low 8 bit + msgs[0].buf = msgBuf; + AUDIO_DRIVER_LOG_DEBUG("msgBuf[1]=0x%02x.", msgBuf[1]); + AUDIO_DRIVER_LOG_DEBUG("msgBuf[2]=0x%02x.", msgBuf[I2C_MSG_BUF_SIZE]); + } else { + // S 11011A2A1 0 A ADDR A Sr 11011A2A1 1 A MS1 A LS1 A <....> NA P + msgBuf = OsalMemCalloc(I2C_MSG_NUM); + if (msgBuf == NULL) { + AUDIO_DRIVER_LOG_ERR("[read]: malloc buf failed!"); + return HDF_ERR_MALLOC_FAIL; + } + msgs[0].len = 1; + msgs[0].buf = regs; + msgs[1].addr = g_i2cDevAddr; + msgs[1].flags = I2C_FLAG_READ; + msgs[1].len = I2C_MSG_NUM; + msgs[1].buf = msgBuf; + } + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +int32_t AccessoryI2cReadWrite(struct AudioAddrConfig *regAttr, uint16_t rwFlag) +{ + int32_t ret; + DevHandle i2cHandle; + int16_t transferMsgCount = 1; + uint8_t regs[I2C_REG_LEN]; + struct I2cMsg msgs[I2C_MSG_NUM]; + (void)memset_s(msgs, sizeof(struct I2cMsg) * I2C_MSG_NUM, 0, sizeof(struct I2cMsg) * I2C_MSG_NUM); + + AUDIO_DRIVER_LOG_DEBUG("entry.\n"); + if (regAttr == NULL || rwFlag < 0 || rwFlag > 1) { + AUDIO_DRIVER_LOG_ERR("invalid parameter."); + return HDF_ERR_INVALID_PARAM; + } + i2cHandle = I2cOpen(g_i2cBusNumber); + if (i2cHandle == NULL) { + AUDIO_DRIVER_LOG_ERR("open i2cBus:%u failed! i2cHandle:%p", g_i2cBusNumber, i2cHandle); + return HDF_FAILURE; + } + if (rwFlag == I2C_FLAG_READ) { + transferMsgCount = I2C_MSG_NUM; + } + ret = AccessoryI2cMsgFill(regAttr, rwFlag, regs, msgs); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AccessoryI2cMsgFill failed!"); + I2cClose(i2cHandle); + return HDF_FAILURE; + } + ret = I2cTransfer(i2cHandle, msgs, transferMsgCount); + if (ret != transferMsgCount) { + AUDIO_DRIVER_LOG_ERR("I2cTransfer err:%d", ret); + AccessoryI2cRelease(msgs, transferMsgCount, i2cHandle); + return HDF_FAILURE; + } + if (rwFlag == I2C_FLAG_READ) { + regAttr->value = (msgs[1].buf[0] << COMM_SHIFT_8BIT) | msgs[1].buf[1]; // result value 16 bit + AUDIO_DRIVER_LOG_DEBUG("[read]: regAttr->regValue=0x%04x.\n", regAttr->value); + } + AccessoryI2cRelease(msgs, transferMsgCount, i2cHandle); + return HDF_SUCCESS; +} + +// Read contrl reg bits value +int32_t AccessoryRegBitsRead(struct AudioMixerControl *regAttr, uint32_t *regValue) +{ + int32_t ret; + struct AudioAddrConfig regVal; + if (regAttr == NULL || regAttr->reg < 0 || regValue == NULL) { + AUDIO_DRIVER_LOG_ERR("input invalid parameter."); + return HDF_ERR_INVALID_PARAM; + } + regVal.addr = regAttr->reg; + ret = AccessoryI2cReadWrite(®Val, I2C_FLAG_READ); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AccessoryRegBitsRead failed."); + return HDF_FAILURE; + } + *regValue = regVal.value; + regAttr->value = (regVal.value >> regAttr->shift) & regAttr->mask; + if (regAttr->value > regAttr->max || regAttr->value < regAttr->min) { + AUDIO_DRIVER_LOG_ERR("invalid bitsValue=0x%x", regAttr->value); + return HDF_FAILURE; + } + if (regAttr->invert) { + regAttr->value = regAttr->max - regAttr->value; + } + AUDIO_DRIVER_LOG_DEBUG("regAddr=0x%x, regValue=0x%x, currBitsValue=0x%x", + regAttr->reg, regVal.value, regAttr->value); + AUDIO_DRIVER_LOG_DEBUG("mask=0x%x, shift=%d, max=0x%x,min=0x%x, invert=%d", + regAttr->mask, regAttr->shift, regAttr->max, regAttr->min, regAttr->invert); + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +// Update contrl reg bits value +int32_t AccessoryRegBitsUpdate(struct AudioMixerControl regAttr) +{ + int32_t ret; + struct AudioAddrConfig regVal; + uint32_t newValue, newMask, value; + if (regAttr.reg < 0) { + AUDIO_DRIVER_LOG_ERR("input invalid parameter."); + return HDF_ERR_INVALID_PARAM; + } + if (regAttr.invert) { + regAttr.value = regAttr.max - regAttr.value; + } + newValue = regAttr.value << regAttr.shift; + newMask = regAttr.mask << regAttr.shift; + ret = AccessoryRegBitsRead(®Attr, &value); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("AccessoryRegBitsRead faileded, ret=%d.", ret); + return HDF_FAILURE; + } + regVal.value = (value & ~newMask) | (newValue & newMask); + regVal.addr = regAttr.reg; + ret = AccessoryI2cReadWrite(®Val, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AccessoryI2cReadWrite faileded."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("regAddr=0x%x, regValue=0x%x, oldValue=0x%x, newValue=0x%x,", + regAttr.reg, regVal.value, regAttr.value, newValue); + AUDIO_DRIVER_LOG_DEBUG(" mask=0x%x, shift=%d, max=0x%x, min=0x%x, invert=%d", + newMask, regAttr.shift, regAttr.max, regAttr.min, regAttr.invert); + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +// update external codec I2S frequency +int32_t AccessoryDaiParamsUpdate(struct DaiParamsVal daiParamsVal) +{ + int32_t ret; + const int itemNum = 3; // current only 3 items(frequency, format, channel) + struct AudioMixerControl *regAttr = NULL; + ret = (g_audioRegCfgGroupNode == NULL || g_audioRegCfgGroupNode[AUDIO_DAI_PATAM_GROUP] == NULL + || g_audioRegCfgGroupNode[AUDIO_DAI_PATAM_GROUP]->regCfgItem == NULL + || g_audioRegCfgGroupNode[AUDIO_DAI_PATAM_GROUP]->itemNum < itemNum); + if (ret) { + AUDIO_DRIVER_LOG_ERR("g_audioRegCfgGroupNode[AUDIO_DAI_PATAM_GROUP] is NULL."); + return HDF_FAILURE; + } + regAttr = g_audioRegCfgGroupNode[AUDIO_DAI_PATAM_GROUP]->regCfgItem; + regAttr[0].value = daiParamsVal.frequencyVal; + ret = AccessoryRegBitsUpdate(regAttr[0]); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("set freq failed."); + return HDF_FAILURE; } + regAttr[1].value = daiParamsVal.formatVal; + ret = AccessoryRegBitsUpdate(regAttr[1]); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("set format failed."); + return HDF_FAILURE; + } + regAttr[itemNum - 1].value = daiParamsVal.channelVal; + ret = AccessoryRegBitsUpdate(regAttr[itemNum - 1]); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("set channel failed."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("success."); return HDF_SUCCESS; } -int32_t RateToFrequency(uint32_t rate, uint16_t *freq) +int32_t AcessoryDeviceFrequencyParse(uint32_t rate, uint16_t *freq) { + if (freq == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL"); + return HDF_FAILURE; + } switch (rate) { case I2S_SAMPLE_FREQUENCY_8000: *freq = I2S_SAMPLE_FREQUENCY_REG_VAL_8000; @@ -68,8 +290,141 @@ int32_t RateToFrequency(uint32_t rate, uint16_t *freq) *freq = I2S_SAMPLE_FREQUENCY_REG_VAL_96000; break; default: - AUDIO_DEVICE_LOG_ERR("rate: %d is not support.", rate); + AUDIO_DRIVER_LOG_ERR("rate: %d is not support.", rate); return HDF_ERR_NOT_SUPPORT; } + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +int32_t AccessoryDeviceCfgGet(struct AccessoryData *accessoryData, + struct AccessoryTransferData *accessoryTransferData) +{ + int32_t ret; + int32_t index; + int32_t audioCfgCtrlCount; + + ret = (accessoryData == NULL || accessoryData->regConfig == NULL || accessoryTransferData == NULL); + if (ret) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + g_i2cDevAddr = accessoryTransferData->i2cDevAddr; + g_i2cBusNumber = accessoryTransferData->i2cBusNumber; + g_audioRegCfgGroupNode = accessoryData->regConfig->audioRegParams; + ret = (g_audioRegCfgGroupNode[AUDIO_CTRL_CFG_GROUP] == NULL || + g_audioRegCfgGroupNode[AUDIO_CTRL_CFG_GROUP]->ctrlCfgItem == NULL || + g_audioRegCfgGroupNode[AUDIO_CTRL_PATAM_GROUP] == NULL || + g_audioRegCfgGroupNode[AUDIO_CTRL_PATAM_GROUP]->regCfgItem == NULL); + if (ret) { + AUDIO_DRIVER_LOG_ERR("parsing params is NULL."); + return HDF_FAILURE; + } + struct AudioControlConfig *ctlcfgItem = g_audioRegCfgGroupNode[AUDIO_CTRL_CFG_GROUP]->ctrlCfgItem; + audioCfgCtrlCount = g_audioRegCfgGroupNode[AUDIO_CTRL_CFG_GROUP]->itemNum; + g_audioControls = (struct AudioKcontrol *)OsalMemCalloc(audioCfgCtrlCount * sizeof(struct AudioKcontrol)); + accessoryTransferData->accessoryRegCfgGroupNode = g_audioRegCfgGroupNode; + accessoryTransferData->accessoryCfgCtrlCount = audioCfgCtrlCount; + accessoryTransferData->accessoryControls = g_audioControls; + for (index = 0; index < audioCfgCtrlCount; index++) { + g_audioControls[index].iface = ctlcfgItem[index].iface; + g_audioControls[index].name = g_audioControlsList[ctlcfgItem[index].arrayIndex]; + g_audioControls[index].Info = AudioInfoCtrlOps; + g_audioControls[index].privateValue = + (unsigned long)(uintptr_t)(void*)(&g_audioRegCfgGroupNode[AUDIO_CTRL_PATAM_GROUP]->regCfgItem[index]); + g_audioControls[index].Get = AudioAccessoryGetCtrlOps; + g_audioControls[index].Set = AudioAccessorySetCtrlOps; + } + return HDF_SUCCESS; +} + +/* + * init control reg to default value + */ +int32_t AccessoryDeviceCtrlRegInit(void) +{ + int32_t ret, i; + // Set codec control register(00h-14h) default value + ret = (g_audioRegCfgGroupNode == NULL || g_audioRegCfgGroupNode[AUDIO_INIT_GROUP] == NULL + || g_audioRegCfgGroupNode[AUDIO_INIT_GROUP]->addrCfgItem == NULL); + if (ret) { + AUDIO_DRIVER_LOG_ERR("g_audioRegCfgGroupNode[AUDIO_INIT_GROUP] is NULL."); + return HDF_FAILURE; + } + struct AudioAddrConfig *initCfg = g_audioRegCfgGroupNode[AUDIO_INIT_GROUP]->addrCfgItem; + for (i = 0; i < g_audioRegCfgGroupNode[AUDIO_INIT_GROUP]->itemNum; i++) { + AUDIO_DRIVER_LOG_DEBUG("i=%d, Addr = [0x%2x]", i, initCfg[i].addr); + ret = AccessoryI2cReadWrite(&initCfg[i], 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AccessoryI2cReadWrite(write) err, regAttr.regAddr: 0x%x.\n", + initCfg[i].addr); + return HDF_FAILURE; + } + OsalMSleep(COMM_WAIT_TIMES); + } + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +int32_t AccessoryDeviceRegRead(const struct AccessoryDevice *codec, uint32_t reg, uint32_t *val) +{ + int32_t ret; + struct AudioAddrConfig regAttr; + if (val == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_ERR_INVALID_OBJECT; + } + (void)codec; + regAttr.addr = (uint8_t)reg; + regAttr.value = 0; + ret = AccessoryI2cReadWrite(®Attr, I2C_FLAG_READ); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("failed."); + return HDF_FAILURE; + } + *val = regAttr.value; + AUDIO_DRIVER_LOG_DEBUG("success"); + return HDF_SUCCESS; +} + +int32_t AccessoryDeviceRegWrite(const struct AccessoryDevice *codec, uint32_t reg, uint32_t value) +{ + int32_t ret; + struct AudioAddrConfig regAttr; + (void)codec; + regAttr.addr = (uint8_t)reg; + regAttr.value = (uint16_t)value; + ret = AccessoryI2cReadWrite(®Attr, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("failed."); + return HDF_FAILURE; + } + AUDIO_DRIVER_LOG_DEBUG("success"); + return HDF_SUCCESS; +} + +int32_t AccessoryGetConfigInfo(const struct HdfDeviceObject *device, struct AccessoryData *accessoryData) +{ + if (device == NULL || accessoryData == NULL) { + AUDIO_DRIVER_LOG_ERR("param is null!"); + return HDF_FAILURE; + } + + if (accessoryData->regConfig != NULL) { + ADM_LOG_ERR("g_codecData regConfig fail!"); + return HDF_FAILURE; + } + + accessoryData->regConfig = (struct AudioRegCfgData *)OsalMemCalloc(sizeof(*(accessoryData->regConfig))); + if (accessoryData->regConfig == NULL) { + ADM_LOG_ERR("malloc AudioRegCfgData fail!"); + return HDF_FAILURE; + } + + if (CodecGetRegConfig(device, accessoryData->regConfig) != HDF_SUCCESS) { + ADM_LOG_ERR("CodecGetRegConfig fail!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; } diff --git a/model/audio/common/src/audio_codec_base.c b/model/audio/common/src/audio_codec_base.c index 6d7d0a46d366e6513635171c35dd88b56748a1e2..ee753581d8c135f6188754a8523407f08b2300fb 100755 --- a/model/audio/common/src/audio_codec_base.c +++ b/model/audio/common/src/audio_codec_base.c @@ -7,159 +7,255 @@ */ #include "audio_codec_base.h" +#include "audio_driver_log.h" +#include "audio_parse.h" +#include "audio_sapm.h" #define HDF_LOG_TAG audio_codec_base -int32_t CodecDeviceReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val) +int32_t CodecGetServiceName(const struct HdfDeviceObject *device, const char **drvCodecName) { - unsigned long acodecVir; - struct VirtualAddress *virtualAdd = NULL; - AUDIO_DRIVER_LOG_DEBUG("entry"); + const struct DeviceResourceNode *node = NULL; + struct DeviceResourceIface *drsOps = NULL; + int32_t ret; - if ((codec == NULL) || (codec->device == NULL) || (val == NULL)) { - AUDIO_DRIVER_LOG_ERR("input param codec or codec->device is NULL."); - return HDF_ERR_INVALID_OBJECT; + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("input device para is nullptr."); + return HDF_FAILURE; } - virtualAdd = (struct VirtualAddress *)((volatile uintptr_t)codec->device->priv); - if (virtualAdd == NULL) { - AUDIO_DRIVER_LOG_ERR("virtualAdd is NULL."); - return HDF_ERR_INVALID_OBJECT; + + node = device->property; + if (node == NULL) { + AUDIO_DRIVER_LOG_ERR("node instance is nullptr."); + return HDF_FAILURE; + } + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + AUDIO_DRIVER_LOG_ERR("from resouce get drsOps fail!"); + return HDF_FAILURE; + } + + ret = drsOps->GetString(node, "serviceName", drvCodecName, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("read codecServiceName fail!"); + return ret; } - acodecVir = virtualAdd->acodecVir; - *val = OSAL_READL((void *)(acodecVir + reg)); - AUDIO_DRIVER_LOG_DEBUG("success"); return HDF_SUCCESS; } -int32_t CodecDeviceWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t value) +int32_t CodecGetDaiName(const struct HdfDeviceObject *device, const char **drvDaiName) { - unsigned long acodecVir; - struct VirtualAddress *virtualAdd = NULL; - AUDIO_DRIVER_LOG_DEBUG("entry"); + const struct DeviceResourceNode *node = NULL; + struct DeviceResourceIface *drsOps = NULL; + int32_t ret; - if ((codec == NULL) || (codec->device == NULL)) { - AUDIO_DRIVER_LOG_ERR("param codec or codec->device is NULL."); - return HDF_ERR_INVALID_OBJECT; + if (device == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; } - virtualAdd = (struct VirtualAddress *)((volatile uintptr_t)codec->device->priv); - if (virtualAdd == NULL) { - AUDIO_DRIVER_LOG_ERR("virtualAdd is NULL."); - return HDF_ERR_INVALID_OBJECT; + node = device->property; + if (node == NULL) { + AUDIO_DRIVER_LOG_ERR("drs node is NULL."); + return HDF_FAILURE; + } + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + AUDIO_DRIVER_LOG_ERR("drs ops failed!"); + return HDF_FAILURE; } - acodecVir = virtualAdd->acodecVir; - OSAL_WRITEL(value, (void *)(acodecVir + reg)); + ret = drsOps->GetString(node, "codecDaiName", drvDaiName, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("read codecDaiName fail!"); + return ret; + } - AUDIO_DRIVER_LOG_DEBUG("success"); return HDF_SUCCESS; } -int32_t CodecAiaoDeviceReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val) +int32_t CodecGetConfigInfo(const struct HdfDeviceObject *device, struct CodecData *codecData) { - unsigned long aiaoVir; - struct VirtualAddress *virtualAdd = NULL; - AUDIO_DRIVER_LOG_DEBUG("entry"); + if (device == NULL || codecData == NULL) { + AUDIO_DRIVER_LOG_ERR("param is null!"); + return HDF_FAILURE; + } - if ((codec == NULL) || (codec->device == NULL) || (val == NULL)) { - AUDIO_DRIVER_LOG_ERR("codec or codec->device is NULL."); - return HDF_ERR_INVALID_OBJECT; + if (codecData->regConfig != NULL) { + ADM_LOG_ERR("g_codecData regConfig fail!"); + return HDF_FAILURE; } - virtualAdd = (struct VirtualAddress *)((volatile uintptr_t)codec->device->priv); - if (virtualAdd == NULL) { - AUDIO_DRIVER_LOG_ERR("virtualAdd is NULL."); - return HDF_ERR_INVALID_OBJECT; + codecData->regConfig = (struct AudioRegCfgData *)OsalMemCalloc(sizeof(*(codecData->regConfig))); + if (codecData->regConfig == NULL) { + ADM_LOG_ERR("malloc AudioRegCfgData fail!"); + return HDF_FAILURE; } - aiaoVir = virtualAdd->aiaoVir; - *val = OSAL_READL((void *)(aiaoVir + reg)); + if (CodecGetRegConfig(device, codecData->regConfig) != HDF_SUCCESS) { + ADM_LOG_ERR("CodecGetRegConfig fail!"); + return HDF_FAILURE; + } - AUDIO_DRIVER_LOG_DEBUG("success"); return HDF_SUCCESS; } -int32_t CodecAiaoDeviceWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t value) +static int32_t SapmCtrlToSapmComp(struct AudioSapmComponent *sapmComponents, + const struct AudioSapmCtrlConfig *sapmCompItem, uint16_t index) { - unsigned long aiaoVir; - struct VirtualAddress *virtualAdd = NULL; - AUDIO_DRIVER_LOG_DEBUG("entry"); - - if ((codec == NULL) || (codec->device == NULL)) { - AUDIO_DRIVER_LOG_ERR("codec or codec->device is NULL."); - return HDF_ERR_INVALID_OBJECT; - } - virtualAdd = (struct VirtualAddress *)((volatile uintptr_t)codec->device->priv); - if (virtualAdd == NULL) { - AUDIO_DRIVER_LOG_ERR("virtualAdd is NULL."); - return HDF_ERR_INVALID_OBJECT; + if (sapmComponents == NULL || sapmCompItem == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; } - aiaoVir = virtualAdd->aiaoVir; - OSAL_WRITEL(value, (void *)(aiaoVir + reg)); + sapmComponents[index].componentName = + g_audioSapmCompNameList[sapmCompItem[index].compNameIndex]; + sapmComponents[index].reg = sapmCompItem[index].reg; + sapmComponents[index].sapmType = sapmCompItem[index].sapmType; + sapmComponents[index].mask = sapmCompItem[index].mask; + sapmComponents[index].shift = sapmCompItem[index].shift; + sapmComponents[index].invert = sapmCompItem[index].invert; + sapmComponents[index].kcontrolsNum = sapmCompItem[index].kcontrolsNum; - AUDIO_DRIVER_LOG_DEBUG("success"); return HDF_SUCCESS; } -int32_t CodecGetServiceName(const struct HdfDeviceObject *device, const char **drvCodecName) +static int32_t CodecSetSapmConfigInfo(struct CodecData *codeData, struct AudioRegCfgGroupNode **regCfgGroup) { - const struct DeviceResourceNode *node = NULL; - struct DeviceResourceIface *drsOps = NULL; - int32_t ret; + uint16_t index; - if (device == NULL) { - AUDIO_DRIVER_LOG_ERR("input device para is nullptr."); + if (codeData == NULL || regCfgGroup == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); return HDF_FAILURE; } - node = device->property; - if (node == NULL) { - AUDIO_DRIVER_LOG_ERR("node instance is nullptr."); + struct AudioSapmCtrlConfig *sapmCompItem = regCfgGroup[AUDIO_SAPM_COMP_GROUP]->sapmCompItem; + struct AudioControlConfig *sapmCtrlItem = regCfgGroup[AUDIO_SAPM_CFG_GROUP]->ctrlCfgItem; + struct AudioMixerControl *ctlSapmRegCfgItem = regCfgGroup[AUDIO_CTRL_SAPM_PATAM_GROUP]->regCfgItem; + + if (sapmCompItem == NULL || sapmCtrlItem == NULL || ctlSapmRegCfgItem == NULL) { + AUDIO_DRIVER_LOG_ERR("sapmCompItem, sapmCtrlItem, ctlSapmRegCfgItem is NULL."); return HDF_FAILURE; } - drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); - if (drsOps == NULL || drsOps->GetString == NULL) { - AUDIO_DRIVER_LOG_ERR("from resouce get drsOps fail!"); + + struct AudioKcontrol *audioSapmControls = (struct AudioKcontrol *)OsalMemCalloc( + regCfgGroup[AUDIO_SAPM_CFG_GROUP]->itemNum * sizeof(struct AudioKcontrol)); + if (audioSapmControls == NULL) { + AUDIO_DRIVER_LOG_ERR("OsalMemCalloc failed."); return HDF_FAILURE; } + for (index = 0; index < regCfgGroup[AUDIO_SAPM_CFG_GROUP]->itemNum; index++) { + audioSapmControls[index].iface = sapmCtrlItem[index].iface; + audioSapmControls[index].name = g_audioSapmCfgNameList[sapmCtrlItem[index].arrayIndex]; + audioSapmControls[index].privateValue = (unsigned long)(uintptr_t)(void*)(&ctlSapmRegCfgItem[index]); + audioSapmControls[index].Info = AudioInfoCtrlOps; + audioSapmControls[index].Get = AudioCodecSapmGetCtrlOps; + audioSapmControls[index].Set = AudioCodecSapmSetCtrlOps; + } - ret = drsOps->GetString(node, "serviceName", drvCodecName, 0); - if (ret != HDF_SUCCESS) { - AUDIO_DRIVER_LOG_ERR("read codecServiceName fail!"); - return ret; + codeData->numSapmComponent = regCfgGroup[AUDIO_SAPM_COMP_GROUP]->itemNum; + codeData->sapmComponents = (struct AudioSapmComponent *) + OsalMemCalloc(codeData->numSapmComponent * sizeof(struct AudioSapmComponent)); + if (codeData->sapmComponents == NULL) { + OsalMemFree(audioSapmControls); + AUDIO_DRIVER_LOG_ERR("OsalMemCalloc failed."); + return HDF_FAILURE; + } + + for (index = 0; index < codeData->numSapmComponent; index++) { + if (SapmCtrlToSapmComp(codeData->sapmComponents, sapmCompItem, index)) { + OsalMemFree(audioSapmControls); + return HDF_FAILURE; + } + + if (sapmCompItem[index].kcontrolsNum) { + codeData->sapmComponents[index].kcontrolNews = + &audioSapmControls[sapmCompItem[index].kcontrolNews - 1]; + } } return HDF_SUCCESS; } -int32_t CodecGetDaiName(const struct HdfDeviceObject *device, const char **drvDaiName) +int32_t CodecSetConfigInfo(struct CodecData *codeData, struct DaiData *daiData) { - const struct DeviceResourceNode *node = NULL; - struct DeviceResourceIface *drsOps = NULL; - int32_t ret; + uint16_t index; - if (device == NULL) { + if (codeData == NULL || daiData == NULL || codeData->regConfig == NULL) { AUDIO_DRIVER_LOG_ERR("input para is NULL."); return HDF_FAILURE; } - node = device->property; - if (node == NULL) { - AUDIO_DRIVER_LOG_ERR("drs node is NULL."); + struct AudioIdInfo *audioIdInfo = &(codeData->regConfig->audioIdInfo); + struct AudioRegCfgGroupNode **regCfgGroup = codeData->regConfig->audioRegParams; + daiData->regCfgGroup = regCfgGroup; + codeData->regCfgGroup = regCfgGroup; + if (audioIdInfo == NULL || regCfgGroup == NULL) { + AUDIO_DRIVER_LOG_ERR("audioIdInfo or regCfgGroup is NULL."); return HDF_FAILURE; } - drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); - if (drsOps == NULL || drsOps->GetString == NULL) { - AUDIO_DRIVER_LOG_ERR("drs ops failed!"); + + struct AudioControlConfig *compItem = regCfgGroup[AUDIO_CTRL_CFG_GROUP]->ctrlCfgItem; + struct AudioMixerControl *ctlRegCfgItem = regCfgGroup[AUDIO_CTRL_PATAM_GROUP]->regCfgItem; + if (compItem == NULL || ctlRegCfgItem == NULL) { + AUDIO_DRIVER_LOG_ERR("compItem or ctlRegCfgItem is NULL."); return HDF_FAILURE; } - ret = drsOps->GetString(node, "codecDaiName", drvDaiName, 0); - if (ret != HDF_SUCCESS) { - AUDIO_DRIVER_LOG_ERR("read codecDaiName fail!"); - return ret; + codeData->numControls = regCfgGroup[AUDIO_CTRL_CFG_GROUP]->itemNum; + codeData->controls = + (struct AudioKcontrol *)OsalMemCalloc(codeData->numControls * sizeof(struct AudioKcontrol)); + if (codeData->controls == NULL) { + AUDIO_DRIVER_LOG_ERR("OsalMemCalloc failed."); + return HDF_FAILURE; + } + + for (index = 0; index < codeData->numControls; index++) { + codeData->controls[index].iface = compItem[index].iface; + codeData->controls[index].name = g_audioControlsList[compItem[index].arrayIndex]; + codeData->controls[index].Info = AudioInfoCtrlOps; + codeData->controls[index].privateValue = (unsigned long)(uintptr_t)(void*)(&ctlRegCfgItem[index]); + if (compItem[index].enable) { + codeData->controls[index].Get = AudioCodecGetCtrlOps; + codeData->controls[index].Set = AudioCodecSetCtrlOps; + } + } + + codeData->virtualAddress = (uintptr_t)OsalIoRemap(audioIdInfo->chipIdRegister, audioIdInfo->chipIdSize); + + if (CodecSetSapmConfigInfo(codeData, regCfgGroup) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t CodecSetCtlFunc(struct CodecData *codeData, const void *aiaoGetCtrl, const void *aiaoSetCtrl) +{ + uint32_t index; + if (codeData == NULL || codeData->regConfig == NULL || + aiaoGetCtrl == NULL || aiaoSetCtrl == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + struct AudioRegCfgGroupNode **regCfgGroup = codeData->regConfig->audioRegParams; + if (regCfgGroup == NULL || regCfgGroup[AUDIO_CTRL_CFG_GROUP] == NULL) { + AUDIO_DRIVER_LOG_ERR("regCfgGroup or regCfgGroup[AUDIO_CTRL_CFG_GROUP] is NULL."); + return HDF_FAILURE; + } + + struct AudioControlConfig *compItem = regCfgGroup[AUDIO_CTRL_CFG_GROUP]->ctrlCfgItem; + if (compItem == NULL) { + AUDIO_DRIVER_LOG_ERR("compItem is NULL."); + return HDF_FAILURE; + } + + for (index = 0; index < codeData->numControls; index++) { + if (!compItem[index].enable) { + codeData->controls[index].Get = aiaoGetCtrl; + codeData->controls[index].Set = aiaoSetCtrl; + } } return HDF_SUCCESS; diff --git a/model/audio/common/src/audio_dai_base.c b/model/audio/common/src/audio_dai_base.c new file mode 100644 index 0000000000000000000000000000000000000000..0b9822acd0280bc392dd61e7fdf3c08388f73409 --- /dev/null +++ b/model/audio/common/src/audio_dai_base.c @@ -0,0 +1,114 @@ +/* + * Copyright (c) 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 "audio_core.h" +#include "audio_driver_log.h" + +struct DaiData *DaiDataFromCard(const struct AudioCard *card) +{ + if (card == NULL || card->rtd == NULL || card->rtd->cpuDai == NULL) { + AUDIO_DRIVER_LOG_ERR("param is null."); + return NULL; + } + return card->rtd->cpuDai->devData; +} + + +int32_t DaiGetConfigInfo(const struct HdfDeviceObject *device, struct DaiData *data) +{ + if (device == NULL || data == NULL) { + AUDIO_DRIVER_LOG_ERR("param is null!"); + return HDF_FAILURE; + } + + if (data->regConfig != NULL) { + ADM_LOG_ERR("g_codecData regConfig fail!"); + return HDF_FAILURE; + } + + data->regConfig = (struct AudioRegCfgData *)OsalMemCalloc(sizeof(*(data->regConfig))); + if (data->regConfig == NULL) { + ADM_LOG_ERR("malloc AudioRegCfgData fail!"); + return HDF_FAILURE; + } + + if (CodecGetRegConfig(device, data->regConfig) != HDF_SUCCESS) { + ADM_LOG_ERR("dai GetRegConfig fail!"); + OsalMemFree(data->regConfig); + data->regConfig = NULL; + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t DaiCheckSampleRate(unsigned int sampleRates) +{ + bool check = (sampleRates == AUDIO_SAMPLE_RATE_8000 || sampleRates == AUDIO_SAMPLE_RATE_12000 || + sampleRates == AUDIO_SAMPLE_RATE_11025 || sampleRates == AUDIO_SAMPLE_RATE_16000 || + sampleRates == AUDIO_SAMPLE_RATE_22050 || sampleRates == AUDIO_SAMPLE_RATE_24000 || + sampleRates == AUDIO_SAMPLE_RATE_32000 || sampleRates == AUDIO_SAMPLE_RATE_44100 || + sampleRates == AUDIO_SAMPLE_RATE_48000 || sampleRates == AUDIO_SAMPLE_RATE_64000 || + sampleRates == AUDIO_SAMPLE_RATE_96000); + if (check) { + return HDF_SUCCESS; + } else { + AUDIO_DRIVER_LOG_ERR("FramatToSampleRate fail: Invalid sampling rate: %d.", sampleRates); + return HDF_ERR_NOT_SUPPORT; + } +} + +int32_t DaiSetConfigInfo(struct DaiData *data) +{ + uint16_t index; + struct AudioRegCfgGroupNode **regCfgGroup = NULL; + struct AudioMixerControl *patRegCfgItemTmp = NULL; + struct AudioControlConfig *item = NULL; + + if (data == NULL || data->regConfig == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is NULL."); + return HDF_FAILURE; + } + + regCfgGroup = data->regConfig->audioRegParams; + if (regCfgGroup == NULL) { + AUDIO_DRIVER_LOG_DEBUG("regCfgGroup is null."); + return HDF_SUCCESS; + } + + patRegCfgItemTmp = regCfgGroup[AUDIO_CTRL_PATAM_GROUP]->regCfgItem; + item = regCfgGroup[AUDIO_CTRL_CFG_GROUP]->ctrlCfgItem; + + if (patRegCfgItemTmp == NULL || item == NULL) { + AUDIO_DRIVER_LOG_ERR("patRegCfgItemTmp or item is NULL."); + return HDF_FAILURE; + } + + data->numControls = regCfgGroup[AUDIO_CTRL_CFG_GROUP]->itemNum; + data->controls = (struct AudioKcontrol *)OsalMemCalloc(data->numControls * sizeof(struct AudioKcontrol)); + if (data->controls == NULL) { + AUDIO_DRIVER_LOG_ERR("OsalMemCalloc failed."); + return HDF_FAILURE; + } + + for (index = 0; index < data->numControls; index++) { + data->controls[index].iface = item[index].iface; + if (item[index].arrayIndex >= AUDIO_CTRL_LIST_MAX) { + AUDIO_DRIVER_LOG_ERR("Array super index."); + return HDF_FAILURE; + } + data->controls[index].name = g_audioControlsList[item[index].arrayIndex]; + data->controls[index].Info = AudioInfoCtrlOps; + data->controls[index].privateValue = (unsigned long)(uintptr_t)(void*)(&patRegCfgItemTmp[index]); + data->controls[index].Get = AudioCpuDaiGetCtrlOps; + data->controls[index].Set = AudioCpuDaiSetCtrlOps; + } + + return HDF_SUCCESS; +} + diff --git a/model/audio/common/src/audio_dma_base.c b/model/audio/common/src/audio_dma_base.c new file mode 100644 index 0000000000000000000000000000000000000000..214edc6849972fce33b6fecd9443ac1361183d71 --- /dev/null +++ b/model/audio/common/src/audio_dma_base.c @@ -0,0 +1,88 @@ +/* + * Copyright (c) 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 "audio_platform_if.h" + +int32_t AudioDmaBufAlloc(struct PlatformData *data, enum AudioStreamType streamType) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaBufAlloc != NULL) { + return data->ops->DmaBufAlloc(data, streamType); + } + return HDF_FAILURE; +} + +int32_t AudioDmaBufFree(struct PlatformData *data, enum AudioStreamType streamType) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaBufFree != NULL) { + return data->ops->DmaBufFree(data, streamType); + } + return HDF_FAILURE; +} + +int32_t AudioDmaRequestChannel(struct PlatformData *data) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaConfigChannel != NULL) { + return data->ops->DmaRequestChannel(data); + } + return HDF_FAILURE; +} + +int32_t AudioDmaConfigChannel(struct PlatformData *data) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaConfigChannel != NULL) { + return data->ops->DmaConfigChannel(data); + } + return HDF_FAILURE; +} + +int32_t AudioDmaPrep(struct PlatformData *data) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaPrep != NULL) { + return data->ops->DmaPrep(data); + } + return HDF_FAILURE; +} + +int32_t AudioDmaSubmit(struct PlatformData *data) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaSubmit != NULL) { + return data->ops->DmaSubmit(data); + } + return HDF_FAILURE; +} + +int32_t AudioDmaPending(struct PlatformData *data) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaPending != NULL) { + return data->ops->DmaPending(data); + } + return HDF_FAILURE; +} + +int32_t AudioDmaPause(struct PlatformData *data) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaPause != NULL) { + return data->ops->DmaPause(data); + } + return HDF_FAILURE; +} + +int32_t AudioDmaResume(struct PlatformData *data) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaResume != NULL) { + return data->ops->DmaResume(data); + } + return HDF_FAILURE; +} + +int32_t AudioDmaPointer(struct PlatformData *data, uint32_t *pointer) +{ + if (data != NULL && data->ops != NULL && data->ops->DmaPointer != NULL) { + return data->ops->DmaPointer(data, pointer); + } + return HDF_FAILURE; +} diff --git a/model/audio/common/src/audio_dsp_base.c b/model/audio/common/src/audio_dsp_base.c old mode 100755 new mode 100644 index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..3fb0c38cad9fd1fd72cb5e852c3f1e0e71ed39f3 --- a/model/audio/common/src/audio_dsp_base.c +++ b/model/audio/common/src/audio_dsp_base.c @@ -0,0 +1,74 @@ +/* + * Copyright (c) 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 "audio_dsp_base.h" +#include "audio_driver_log.h" + +#define HDF_LOG_TAG audio_dsp_base + +int32_t DspGetServiceName(const struct HdfDeviceObject *device, const char **drvDspName) +{ + const struct DeviceResourceNode *node = NULL; + struct DeviceResourceIface *drsOps = NULL; + int32_t ret; + + if (device == NULL || drvDspName == NULL) { + AUDIO_DRIVER_LOG_ERR("device is NULL."); + return HDF_FAILURE; + } + + node = device->property; + if (node == NULL) { + AUDIO_DRIVER_LOG_ERR("deivce property is NULL."); + return HDF_FAILURE; + } + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + AUDIO_DRIVER_LOG_ERR("from resource get drsops failed!"); + return HDF_FAILURE; + } + + ret = drsOps->GetString(node, "serviceName", drvDspName, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("read DspServiceName fail!"); + return ret; + } + + return HDF_SUCCESS; +} + +int32_t DspGetDaiName(const struct HdfDeviceObject *device, const char **drvDaiName) +{ + const struct DeviceResourceNode *node = NULL; + struct DeviceResourceIface *drsOps = NULL; + int32_t ret; + + if (device == NULL || drvDaiName == NULL) { + AUDIO_DRIVER_LOG_ERR("input para is null pointer."); + return HDF_FAILURE; + } + + node = device->property; + if (node == NULL) { + AUDIO_DRIVER_LOG_ERR("drs node is null pointer."); + return HDF_FAILURE; + } + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + AUDIO_DRIVER_LOG_ERR("drs ops fail!"); + return HDF_FAILURE; + } + + ret = drsOps->GetString(node, "dspDaiName", drvDaiName, 0); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("read dspDaiName fail!"); + return ret; + } + + return HDF_SUCCESS; +} diff --git a/model/audio/common/src/audio_platform_base.c b/model/audio/common/src/audio_platform_base.c index 29337f0e476b210301bf8493045be98d9c01256b..f64fe04557c9ecf40c661f6869ab16facf7a2acf 100755 --- a/model/audio/common/src/audio_platform_base.c +++ b/model/audio/common/src/audio_platform_base.c @@ -7,11 +7,33 @@ */ #include "audio_platform_base.h" -#include "audio_core.h" +#include "audio_driver_log.h" +#include "audio_dma_base.h" +#include "audio_sapm.h" +#include "audio_stream_dispatch.h" +#include "osal_time.h" +#include "osal_uaccess.h" #define HDF_LOG_TAG audio_platform_base +const int MAX_PERIOD_SIZE = 1024 * 16; +const int MAX_PERIOD_COUNT = 32; +const int MIN_PERIOD_COUNT = 4; +const int RENDER_TRAF_BUF_SIZE = 1024; +const int MIN_BUFF_SIZE = 16 * 1024; +const int TIME_OUT_CONST = 50; +const int SLEEP_TIME = 5; -struct PlatformData *PlatformDataFromDevice(const struct AudioCard *card) +unsigned int SysReadl(unsigned long addr) +{ + return *(volatile unsigned int *)(uintptr_t)(addr); +} + +void SysWritel(unsigned long addr, unsigned int value) +{ + *(volatile unsigned int *)(uintptr_t)(addr) = value; +} + +struct PlatformData *PlatformDataFromCard(const struct AudioCard *card) { if (card == NULL || card->rtd == NULL || card->rtd->platform == NULL) { AUDIO_DRIVER_LOG_ERR("param is null."); @@ -20,55 +42,1105 @@ struct PlatformData *PlatformDataFromDevice(const struct AudioCard *card) return card->rtd->platform->devData; } -int32_t PlatformCreatePlatformHost(const struct AudioCard *card, struct PlatformHost **platformHost) +uint32_t AudioBytesToFrames(uint32_t frameBits, uint32_t size) +{ + if (size == 0) { + AUDIO_DRIVER_LOG_ERR("size is null."); + return 0; + } else { + return (frameBits / size); + } +} + + +int32_t AudioDataBigEndianChange(char *srcData, uint32_t audioLen, enum DataBitWidth bitWidth) +{ + if (srcData == NULL) { + AUDIO_DRIVER_LOG_ERR("srcData is NULL."); + return HDF_FAILURE; + } + uint64_t i; + uint16_t framesize; + char *changeData = srcData; + uint32_t *pData = (uint32_t *)changeData; + + switch (bitWidth) { + case DATA_BIT_WIDTH8: + return HDF_SUCCESS; + case DATA_BIT_WIDTH24: + framesize = 3; /* 3 byte , convert step is 3 byte */ + for (i = 0; i < audioLen; i += framesize) { + // swap the first and the third byte, second and fourth unchanged + *pData = ((((*pData) >> 0x10) & 0x000000FF) | + ((*pData) & 0xFF00FF00) | + (((*pData) << 0x10) & 0x00FF0000)); + changeData += framesize; + pData = (uint32_t *)changeData; + } + break; + case DATA_BIT_WIDTH16: + default: + framesize = 4; /* 2 byte, convert step is 4 byte */ + for (i = 0; i < audioLen; i += framesize) { + // swap the first and second byte, swap the third and fourth byte + *pData = ((((*pData) << 0x08) & 0xFF00FF00) | + (((*pData) >> 0x08) & 0x00FF00FF)); + pData++; + } + break; + } + return HDF_SUCCESS; +} + +int32_t AudioFramatToBitWidth(enum AudioFormat format, unsigned int *bitWidth) +{ + if (bitWidth == NULL) { + AUDIO_DRIVER_LOG_ERR("bitWidth is null."); + return HDF_FAILURE; + } + switch (format) { + case AUDIO_FORMAT_PCM_16_BIT: + *bitWidth = DATA_BIT_WIDTH16; + break; + + case AUDIO_FORMAT_PCM_24_BIT: + *bitWidth = DATA_BIT_WIDTH24; + break; + + default: + AUDIO_DRIVER_LOG_ERR("format: %d is not define.", format); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioSetPcmInfo(struct PlatformData *platformData, const struct AudioPcmHwParams *param) +{ + if (platformData == NULL || param == NULL) { + AUDIO_DRIVER_LOG_ERR("platform is NULL."); + return HDF_FAILURE; + } + platformData->pcmInfo.rate = param->rate; + platformData->pcmInfo.frameSize = param->channels * platformData->pcmInfo.bitWidth / BITSTOBYTE; + platformData->pcmInfo.channels = param->channels; + + platformData->renderBufInfo.chnId = 0; + platformData->captureBufInfo.chnId = 0; + + platformData->pcmInfo.isBigEndian = param->isBigEndian; + platformData->pcmInfo.isSignedData = param->isSignedData; + + platformData->pcmInfo.startThreshold = param->startThreshold; + platformData->pcmInfo.stopThreshold = param->stopThreshold; + platformData->pcmInfo.silenceThreshold = param->silenceThreshold; + + platformData->pcmInfo.interleaved = 1; + platformData->pcmInfo.channels = param->channels; + platformData->pcmInfo.streamType = param->streamType; + + return HDF_SUCCESS; +} + +int32_t AudioSetRenderBufInfo(struct PlatformData *data, const struct AudioPcmHwParams *param) { - if (platformHost == NULL) { - AUDIO_DRIVER_LOG_ERR("input param platformHost is invalid."); + uint32_t size; + + if (data == NULL || param == NULL) { + AUDIO_DRIVER_LOG_ERR("platform is NULL."); + return HDF_FAILURE; + } + data->renderBufInfo.period = param->period; + if (param->periodSize < MIN_PERIOD_SIZE || param->periodSize > MAX_PERIOD_SIZE) { + AUDIO_DRIVER_LOG_ERR("periodSize is invalid."); + return HDF_FAILURE; + } + data->renderBufInfo.periodSize = param->periodSize; + if (param->periodCount < MIN_PERIOD_COUNT || param->periodCount > MAX_PERIOD_COUNT) { + AUDIO_DRIVER_LOG_ERR("periodCount is invalid."); + return HDF_FAILURE; + } + data->renderBufInfo.periodCount = param->periodCount; + + data->renderBufInfo.trafBufSize = RENDER_TRAF_BUF_SIZE; + + size = data->renderBufInfo.periodCount * data->renderBufInfo.periodSize; + if (size < MIN_BUFF_SIZE || size > MAX_BUFF_SIZE) { + AUDIO_DRIVER_LOG_ERR("buffSize is invalid."); + return HDF_FAILURE; + } + + data->renderBufInfo.cirBufSize = size; + return HDF_SUCCESS; +} + +int32_t AudioSetCaptureBufInfo(struct PlatformData *data, const struct AudioPcmHwParams *param) +{ + if (data == NULL || param == NULL) { + AUDIO_DRIVER_LOG_ERR("platform is NULL."); + return HDF_FAILURE; + } + + data->captureBufInfo.period = param->period; + if (param->periodSize < MIN_PERIOD_SIZE || param->periodSize > MAX_PERIOD_SIZE) { + AUDIO_DRIVER_LOG_ERR("periodSize is invalid %d.", param->periodSize); + return HDF_FAILURE; + } + data->captureBufInfo.periodSize = param->periodSize; + if (param->periodCount < MIN_PERIOD_COUNT || param->periodCount > MAX_PERIOD_COUNT) { + AUDIO_DRIVER_LOG_ERR("periodCount is invalid %d.", param->periodCount); + return HDF_FAILURE; + } + data->captureBufInfo.periodCount = param->periodCount; + + if (param->silenceThreshold < MIN_PERIOD_SIZE || param->silenceThreshold > MAX_PERIOD_SIZE) { + AUDIO_DRIVER_LOG_ERR("silenceThreshold is invalid %d.", param->silenceThreshold); + return HDF_FAILURE; + } + data->captureBufInfo.trafBufSize = param->silenceThreshold; + data->captureBufInfo.cirBufSize = param->periodSize * param->periodCount; + if (data->captureBufInfo.cirBufSize > data->captureBufInfo.cirBufMax) { + AUDIO_DRIVER_LOG_ERR("cirBufSize is invalid %d.", data->captureBufInfo.cirBufSize); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioWriteProcBigEndian(const struct PlatformData *data, struct AudioTxData *txData) +{ + uint32_t buffSize; + + if (data == NULL || txData == NULL || txData->buf == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is null."); + return HDF_FAILURE; + } + + buffSize = (uint32_t)txData->frames * data->pcmInfo.frameSize; + if (data->pcmInfo.isBigEndian) { + if (AudioDataBigEndianChange(txData->buf, buffSize, data->pcmInfo.bitWidth) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed."); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +static enum CriBuffStatus AudioDmaBuffStatus(const struct AudioCard *card) +{ + uint32_t dataAvailable; + uint32_t residual; + uint32_t pointer = 0; + uint32_t wptr; + uint32_t rptr; + + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL || data->ops == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (AudioPcmPointer(card, &pointer) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("get Pointer failed."); + return ENUM_CIR_BUFF_FULL; + } + + if (data->pcmInfo.streamType == AUDIO_RENDER_STREAM) { + data->renderBufInfo.pointer = pointer; + rptr = data->renderBufInfo.pointer * data->pcmInfo.frameSize; + dataAvailable = (data->renderBufInfo.wbufOffSet - rptr) % data->renderBufInfo.cirBufSize; + residual = data->renderBufInfo.cirBufSize - dataAvailable; + if ((residual > data->renderBufInfo.trafBufSize)) { + return ENUM_CIR_BUFF_NORMAL; + } + return ENUM_CIR_BUFF_FULL; + } else if (data->pcmInfo.streamType == AUDIO_CAPTURE_STREAM) { + rptr = data->captureBufInfo.rptrOffSet; + wptr = pointer * data->pcmInfo.frameSize; + data->captureBufInfo.pointer = pointer; + + if (wptr >= rptr) { + // [S ... R ... W ... E] + dataAvailable = wptr - rptr; + if (dataAvailable < data->captureBufInfo.trafBufSize) { + AUDIO_DRIVER_LOG_DEBUG("empty rptr: %d wptr: %d trafBufSize: %d ", rptr, + wptr, data->captureBufInfo.trafBufSize); + return ENUM_CIR_BUFF_EMPTY; + } + } + AUDIO_DRIVER_LOG_DEBUG("rptr: %d wptr: %d trafBufSize: %d ", rptr, wptr, data->captureBufInfo.trafBufSize); + return ENUM_CIR_BUFF_NORMAL; + } else { + AUDIO_DRIVER_LOG_ERR("streamType is invalead."); + return ENUM_CIR_BUFF_FULL; + } +} + +int32_t AudioPcmWrite(const struct AudioCard *card, struct AudioTxData *txData) +{ + struct PlatformData *data = NULL; + enum CriBuffStatus status; + uint32_t wPtr; + int ret; + + if (card == NULL || txData == NULL || txData->buf == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is null."); + return HDF_FAILURE; + } + + data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("from PlatformDataFromCard get platformData is NULL."); + return HDF_FAILURE; + } + + // 1. Computed buffer size + data->renderBufInfo.trafBufSize = txData->frames * data->pcmInfo.frameSize; + + // 2. Big Small Exchange + if (data->pcmInfo.isBigEndian) { + if (AudioDataBigEndianChange(txData->buf, data->renderBufInfo.trafBufSize, + data->pcmInfo.bitWidth) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed."); + return HDF_FAILURE; + } + } + // 3. Buffer state checking + status = AudioDmaBuffStatus(card); + if (status != ENUM_CIR_BUFF_NORMAL) { + txData->status = ENUM_CIR_BUFF_FULL; + return HDF_SUCCESS; + } + + // 4. write buffer + if (data->renderBufInfo.trafBufSize > data->renderBufInfo.cirBufSize) { + AUDIO_DRIVER_LOG_ERR("transferFrameSize is tool big."); + return HDF_FAILURE; + } + wPtr = data->renderBufInfo.wbufOffSet % data->renderBufInfo.cirBufSize; + + if (data->renderBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("render buffer is null."); + return HDF_FAILURE; + } + ret = memcpy_s((char *)(data->renderBufInfo.virtAddr) + wPtr, + data->renderBufInfo.trafBufSize, txData->buf, data->renderBufInfo.trafBufSize); + if (ret != 0) { + AUDIO_DRIVER_LOG_ERR("memcpy_s failed."); + return HDF_FAILURE; + } + txData->status = ENUM_CIR_BUFF_NORMAL; + data->renderBufInfo.wptrOffSet = wPtr + data->renderBufInfo.trafBufSize; + data->renderBufInfo.wbufOffSet += data->renderBufInfo.trafBufSize; + + return HDF_SUCCESS; +} + +static int32_t PcmReadData(struct PlatformData *data, struct AudioRxData *rxData) +{ + uint32_t wptr; + uint32_t rptr; + uint32_t validDataSize; + + if (data == NULL || rxData == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is null."); + return HDF_FAILURE; + } + + rxData->buf = (char *)(data->captureBufInfo.virtAddr) + data->captureBufInfo.rptrOffSet; + wptr = data->captureBufInfo.pointer * data->pcmInfo.frameSize; + rptr = data->captureBufInfo.rptrOffSet; + data->captureBufInfo.curTrafSize = data->captureBufInfo.trafBufSize; + if (rptr > wptr) { + validDataSize = data->captureBufInfo.cirBufSize - rptr; + if (validDataSize < data->captureBufInfo.trafBufSize) { + data->captureBufInfo.curTrafSize = validDataSize; + } + } + + // 3. Big Small Exchange + if (!data->pcmInfo.isBigEndian) { + if (rxData->buf == NULL || AudioDataBigEndianChange(rxData->buf, + data->captureBufInfo.curTrafSize, data->pcmInfo.bitWidth) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed."); + return HDF_FAILURE; + } + } + + rxData->frames = data->captureBufInfo.curTrafSize / data->pcmInfo.frameSize; + rxData->bufSize = data->captureBufInfo.curTrafSize; + rxData->status = ENUM_CIR_BUFF_NORMAL; + + return HDF_SUCCESS; +} + +int32_t AudioPcmRead(const struct AudioCard *card, struct AudioRxData *rxData) +{ + struct PlatformData *data = NULL; + enum CriBuffStatus status; + + if (card == NULL || rxData == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is null."); + return HDF_FAILURE; + } + + data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("from PlatformDataFromCard get platformData is NULL."); + return HDF_FAILURE; + } + if (data->captureBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("capture buffer is null."); + return HDF_FAILURE; + } + + // 1. Buffer state checking + status = AudioDmaBuffStatus(card); + if (status != ENUM_CIR_BUFF_NORMAL) { + rxData->status = ENUM_CIR_BUFF_EMPTY; + rxData->buf = (char *)(data->captureBufInfo.virtAddr) + data->captureBufInfo.rptrOffSet; + rxData->frames = 0; + rxData->bufSize = 0; + AUDIO_DRIVER_LOG_DEBUG("buff is empty."); + return HDF_SUCCESS; + } + + // 2. read buffer + if (PcmReadData(data, rxData) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("Pcm Read Data fail."); + return HDF_FAILURE; + } + + // 4. update rptr + data->captureBufInfo.rptrOffSet += data->captureBufInfo.curTrafSize; + if (data->captureBufInfo.rptrOffSet >= data->captureBufInfo.cirBufSize) { + data->captureBufInfo.rptrOffSet = 0; + } + return HDF_SUCCESS; +} + +static int32_t MmapWriteData(struct PlatformData *data, char *tmpBuf) +{ + uint32_t wPtr; + int ret; + + if (data->renderBufInfo.trafBufSize > data->renderBufInfo.cirBufSize) { + AUDIO_DRIVER_LOG_ERR("transferFrameSize is tool big."); + return HDF_FAILURE; + } + + wPtr = data->renderBufInfo.wbufOffSet % data->renderBufInfo.cirBufSize; + ret = CopyFromUser(tmpBuf, (char *)data->mmapData.memoryAddress + data->mmapData.offset, + data->renderBufInfo.trafBufSize); + if (ret != EOK) { + AUDIO_DRIVER_LOG_ERR("CopyFromUser failed."); + return HDF_FAILURE; + } + + ret = memcpy_s((char *)(data->renderBufInfo.virtAddr) + wPtr, data->renderBufInfo.trafBufSize, + tmpBuf, data->renderBufInfo.trafBufSize); + if (ret != 0) { + AUDIO_DRIVER_LOG_ERR("memcpy_s failed."); + return HDF_FAILURE; + } + + data->renderBufInfo.wptrOffSet = wPtr + data->renderBufInfo.trafBufSize; + data->renderBufInfo.wbufOffSet += data->renderBufInfo.trafBufSize; + data->renderBufInfo.framesPosition += data->renderBufInfo.trafBufSize / data->pcmInfo.frameSize; + data->mmapData.offset += data->renderBufInfo.trafBufSize; + data->mmapLoopCount++; + return HDF_SUCCESS; +} + +static int32_t AudioMmapWriteTransfer(const struct AudioCard *card) +{ + uint32_t timeout = 0; + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + if (data->renderBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("render buffer is null."); + return HDF_FAILURE; + } + + uint32_t totalSize = (uint32_t)data->mmapData.totalBufferFrames * data->pcmInfo.frameSize; + uint32_t lastBuffSize = ((totalSize % MIN_PERIOD_SIZE) == 0) ? MIN_PERIOD_SIZE : (totalSize % MIN_PERIOD_SIZE); + uint32_t loopTimes = (lastBuffSize == MIN_PERIOD_SIZE) ? + (totalSize / MIN_PERIOD_SIZE) : (totalSize / MIN_PERIOD_SIZE + 1); + data->mmapLoopCount = 0; + char *tmpBuf = OsalMemCalloc(MIN_PERIOD_SIZE); + if (tmpBuf == NULL) { + AUDIO_DRIVER_LOG_ERR("tmpBuf is null."); + return HDF_FAILURE; + } + while (data->mmapLoopCount < loopTimes && data->renderBufInfo.runStatus != PCM_STOP) { + if (data->renderBufInfo.runStatus == PCM_PAUSE) { + OsalMSleep(5); + continue; + } + + if (AudioDmaBuffStatus(card) != ENUM_CIR_BUFF_NORMAL) { + OsalMSleep(SLEEP_TIME); + AUDIO_DRIVER_LOG_DEBUG("dma buff status ENUM_CIR_BUFF_FULL."); + timeout++; + if (timeout >= TIME_OUT_CONST) { + AUDIO_DRIVER_LOG_ERR("timeout failed."); + OsalMemFree(tmpBuf); + return HDF_FAILURE; + } + continue; + } + timeout = 0; + data->renderBufInfo.trafBufSize = (data->mmapLoopCount < (loopTimes - 1)) ? MIN_PERIOD_SIZE : lastBuffSize; + + if (MmapWriteData(data, tmpBuf) != HDF_SUCCESS) { + OsalMemFree(tmpBuf); + return HDF_FAILURE; + } + } + + if (data->mmapLoopCount > loopTimes) { + data->renderBufInfo.runStatus = PCM_STOP; + } + + OsalMemFree(tmpBuf); + return HDF_SUCCESS; +} + +int32_t AudioPcmMmapWrite(const struct AudioCard *card, const struct AudioMmapData *txMmapData) +{ + int32_t ret; + struct PlatformData *data = NULL; + AUDIO_DRIVER_LOG_DEBUG("entry."); + + data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (txMmapData == NULL || txMmapData->memoryAddress == NULL || txMmapData->transferFrameSize <= 0 || + txMmapData->totalBufferFrames <= 0) { + AUDIO_DRIVER_LOG_ERR("param is invalid."); return HDF_ERR_INVALID_PARAM; } - if (card == NULL || card->rtd == NULL || card->rtd->platform == NULL) { + + data->mmapData.offset = txMmapData->offset; + data->mmapData.memoryAddress = txMmapData->memoryAddress; + data->mmapData.totalBufferFrames = txMmapData->totalBufferFrames; + data->mmapData.transferFrameSize = txMmapData->transferFrameSize; + data->mmapLoopCount = 0; + + AUDIO_DRIVER_LOG_DEBUG("*******offset=0x%x memoryAddress=0x%x totalBufferFrames=0x%x transferFrameSize=0x%x ", + data->mmapData.offset, data->mmapData.memoryAddress, data->mmapData.totalBufferFrames, + data->mmapData.transferFrameSize); + + ret = AudioMmapWriteTransfer(card); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioMmapTransfer fail."); + return HDF_FAILURE; + } + + AUDIO_DRIVER_LOG_DEBUG("render mmap write success."); + return HDF_SUCCESS; +} + +static int32_t MmapReadData(struct PlatformData *data, const struct AudioMmapData *rxMmapData, uint32_t offset) +{ + uint32_t wPtr; + uint32_t rPtr; + uint32_t validDataSize; + + if (data == NULL || rxMmapData == NULL) { + AUDIO_DRIVER_LOG_ERR("data is null."); + return HDF_FAILURE; + } + + rPtr = data->captureBufInfo.rptrOffSet; + wPtr = data->captureBufInfo.pointer * data->pcmInfo.frameSize; + if (rPtr > wPtr) { + validDataSize = data->captureBufInfo.cirBufSize - rPtr; + if (validDataSize < data->captureBufInfo.trafBufSize) { + data->captureBufInfo.curTrafSize = validDataSize; + } + } + if (!data->pcmInfo.isBigEndian) { + if (AudioDataBigEndianChange((char *)(data->captureBufInfo.virtAddr) + rPtr, + data->captureBufInfo.curTrafSize, data->pcmInfo.bitWidth) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioDataBigEndianChange: failed."); + return HDF_FAILURE; + } + } + + if (CopyToUser((char *)rxMmapData->memoryAddress + offset, + (char *)(data->captureBufInfo.virtAddr) + rPtr, data->captureBufInfo.curTrafSize) != 0) { + AUDIO_DRIVER_LOG_ERR("CopyToUser failed."); + return HDF_FAILURE; + } + + // 4. update rptr + data->captureBufInfo.rptrOffSet += data->captureBufInfo.curTrafSize; + if (data->captureBufInfo.rptrOffSet >= data->captureBufInfo.cirBufSize) { + data->captureBufInfo.rptrOffSet = 0; + } + data->captureBufInfo.framesPosition += data->captureBufInfo.curTrafSize / data->pcmInfo.frameSize; + + return HDF_SUCCESS; +} + +int32_t AudioMmapReadTransfer(const struct AudioCard *card, const struct AudioMmapData *rxMmapData) +{ + uint32_t offset = 0; + enum CriBuffStatus status; + uint32_t timeout = 0; + + if (card == NULL || rxMmapData == NULL || rxMmapData->memoryAddress == NULL || + rxMmapData->totalBufferFrames <= 0) { + AUDIO_DRIVER_LOG_ERR("param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + uint32_t frameSize = data->pcmInfo.frameSize; + uint32_t totalSize = (uint32_t)rxMmapData->totalBufferFrames * frameSize; + data->captureBufInfo.pointer = 0; + data->captureBufInfo.curTrafSize = data->captureBufInfo.trafBufSize; + if (data->captureBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("capture buffer is null."); + return HDF_FAILURE; + } + + do { + if (data->captureBufInfo.runStatus == PCM_PAUSE) { + OsalMSleep(5); + continue; + } + + // 1. get buffer status + status = AudioDmaBuffStatus(card); + if (status != ENUM_CIR_BUFF_NORMAL) { + OsalMSleep(SLEEP_TIME); + AUDIO_DRIVER_LOG_DEBUG("dma buff status ENUM_CIR_BUFF_FULL."); + timeout++; + if (timeout >= TIME_OUT_CONST) { + AUDIO_DRIVER_LOG_ERR("timeout failed."); + return HDF_FAILURE; + } + continue; + } + timeout = 0; + + // 2. read data + if (MmapReadData(data, rxMmapData, offset) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("MmapReadData fail."); + return HDF_FAILURE; + } + offset += data->captureBufInfo.curTrafSize; + } while (offset < totalSize && data->captureBufInfo.runStatus != 0); + return HDF_SUCCESS; +} + +int32_t AudioPcmMmapRead(const struct AudioCard *card, const struct AudioMmapData *rxMmapData) +{ + int32_t ret; + struct PlatformData *data = NULL; + AUDIO_DRIVER_LOG_DEBUG("entry."); + + ret = (card == NULL || rxMmapData == NULL || rxMmapData->memoryAddress == NULL + || rxMmapData->totalBufferFrames <= 0); + if (ret) { + AUDIO_DRIVER_LOG_ERR("param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + + data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + ret = AudioMmapReadTransfer(card, rxMmapData); + if (ret) { + AUDIO_DRIVER_LOG_ERR("AudioMmapReadTransfer fail."); + return HDF_ERR_INVALID_PARAM; + } + + AUDIO_DRIVER_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +static int32_t AudioRenderBuffInit(struct PlatformData *platformData) +{ + int ret; + + if (platformData == NULL) { AUDIO_DRIVER_LOG_ERR("input para is NULL."); return HDF_FAILURE; } - *platformHost = PlatformHostFromDevice(card->rtd->platform->device); - if (*platformHost == NULL) { - AUDIO_DRIVER_LOG_ERR("PlatformHostFromDevice faile."); + if (platformData->renderBufInfo.virtAddr != NULL) { + return HDF_SUCCESS; + } + + platformData->renderBufInfo.cirBufMax = MAX_BUFF_SIZE; + platformData->renderBufInfo.phyAddr = 0; + + ret = AudioDmaBufAlloc(platformData, AUDIO_RENDER_STREAM); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail."); + return HDF_FAILURE; + } + + if (platformData->renderBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("mem alloc failed."); return HDF_FAILURE; } + + (void)memset_s(platformData->renderBufInfo.virtAddr, platformData->renderBufInfo.cirBufMax, + 0, platformData->renderBufInfo.cirBufMax); + return HDF_SUCCESS; } -int32_t AudioDataBigEndianChange(char *srcData, uint32_t audioLen, enum DataBitWidth bitWidth) +static int32_t AudioRenderBuffFree(struct PlatformData *platformData) { - uint64_t i; - uint16_t framesize; - char temp; - if (srcData == NULL) { - AUDIO_DRIVER_LOG_ERR("srcData is NULL."); + int ret; + + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL."); return HDF_FAILURE; } - switch (bitWidth) { - case DATA_BIT_WIDTH8: - framesize = 1; /* 1 byte */ + ret = AudioDmaBufFree(platformData, AUDIO_RENDER_STREAM); + if (ret) { + AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail."); + return HDF_FAILURE; + } + + platformData->renderBufInfo.virtAddr = NULL; + platformData->renderBufInfo.phyAddr = 0; + return HDF_SUCCESS; +} + +static int32_t AudioCaptureBuffInit(struct PlatformData *platformData) +{ + int ret; + + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL."); + return HDF_FAILURE; + } + if (platformData->captureBufInfo.virtAddr != NULL) { + return HDF_SUCCESS; + } + + platformData->captureBufInfo.cirBufMax = MAX_BUFF_SIZE; + platformData->captureBufInfo.phyAddr = 0; + + ret = AudioDmaBufAlloc(platformData, AUDIO_CAPTURE_STREAM); + if (ret) { + AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail."); + return HDF_FAILURE; + } + + if (platformData->captureBufInfo.virtAddr == NULL) { + AUDIO_DRIVER_LOG_ERR("mem alloc failed."); + return HDF_FAILURE; + } + + (void)memset_s(platformData->captureBufInfo.virtAddr, platformData->captureBufInfo.cirBufMax, 0, + platformData->captureBufInfo.cirBufMax); + + return HDF_SUCCESS; +} + +static int32_t AudioCaptureBuffFree(struct PlatformData *platformData) +{ + int ret; + + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL."); + return HDF_FAILURE; + } + + ret = AudioDmaBufFree(platformData, AUDIO_CAPTURE_STREAM); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("Dma Buf Alloc fail."); + return HDF_FAILURE; + } + + platformData->captureBufInfo.virtAddr = NULL; + platformData->captureBufInfo.phyAddr = 0; + return HDF_SUCCESS; +} + +int32_t AudioRenderOpen(const struct AudioCard *card) +{ + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (data->renderBufInfo.virtAddr == NULL) { + if (AudioRenderBuffInit(data) != HDF_SUCCESS) { + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +int32_t AudioRenderClose(const struct AudioCard *card) +{ + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + return AudioRenderBuffFree(data); +} + +int32_t AudioCaptureOpen(const struct AudioCard *card) +{ + if (card == NULL) { + AUDIO_DRIVER_LOG_ERR("param card is NULL."); + return HDF_FAILURE; + } + + struct PlatformData *platformData = PlatformDataFromCard(card); + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (platformData->captureBufInfo.virtAddr == NULL) { + if (AudioCaptureBuffInit(platformData) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioCaptureBuffInit: fail."); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureClose(const struct AudioCard *card) +{ + if (card == NULL) { + AUDIO_DRIVER_LOG_ERR("param card is NULL."); + return HDF_FAILURE; + } + + struct PlatformData *platformData = PlatformDataFromCard(card); + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + return AudioCaptureBuffFree(platformData); +} + +static int32_t AudioPcmPending(struct AudioCard *card) +{ + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (AudioDmaSubmit(data) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DmaPending fail."); + return HDF_FAILURE; + } + + if (AudioDmaPending(data) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DmaPending fail."); + return HDF_FAILURE; + } + + if (AudioSampSetPowerMonitor(card, false) != HDF_SUCCESS) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static int32_t AudioPcmPause(struct AudioCard *card) +{ + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (AudioDmaPause(data) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DmaPause fail."); + return HDF_FAILURE; + } + + if (AudioSampSetPowerMonitor(card, true) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t AudioPcmResume(struct AudioCard *card) +{ + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (AudioDmaResume(data) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("DmaPause fail."); + return HDF_FAILURE; + } + + if (AudioSampPowerUp(card) != HDF_SUCCESS) { + return HDF_FAILURE; + } + if (AudioSampSetPowerMonitor(card, false) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioRenderTrigger(struct AudioCard *card, int cmd) +{ + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + switch (cmd) { + case AUDIO_DRV_PCM_IOCTL_RENDER_START: + if (AudioPcmPending(card) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioPcmPending fail."); + return HDF_FAILURE; + } + + data->renderBufInfo.runStatus = PCM_START; break; - case DATA_BIT_WIDTH16: - framesize = 2; /* 2 bytes */ + case AUDIO_DRV_PCM_IOCTL_RENDER_STOP: + if (AudioPcmPause(card) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail."); + return HDF_FAILURE; + } + + data->renderBufInfo.runStatus = PCM_STOP; break; - case DATA_BIT_WIDTH24: - framesize = 3; /* 3 bytes */ + case AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE: + if (AudioPcmPause(card) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail."); + return HDF_FAILURE; + } + + data->renderBufInfo.runStatus = PCM_PAUSE; + break; + case AUDIO_DRV_PCM_IOCTL_RENDER_RESUME: + if (AudioPcmResume(card) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioPcmResume fail."); + return HDF_FAILURE; + } + + data->renderBufInfo.runStatus = PCM_START; break; default: - framesize = 2; /* default 2 bytes */ + AUDIO_DRIVER_LOG_ERR("invalude cmd id: %d.", cmd); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureTrigger(struct AudioCard *card, int cmd) +{ + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + switch (cmd) { + case AUDIO_DRV_PCM_IOCTL_CAPTURE_START: + if (AudioPcmPending(card) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioPcmPending fail."); + return HDF_FAILURE; + } + + data->captureBufInfo.runStatus = PCM_START; break; + case AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP: + if (AudioPcmPause(card) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail."); + return HDF_FAILURE; + } + + data->captureBufInfo.runStatus = PCM_STOP; + break; + case AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE: + if (AudioPcmPause(card) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioPcmPause fail."); + return HDF_FAILURE; + } + + data->captureBufInfo.runStatus = PCM_PAUSE; + break; + case AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME: + if (AudioPcmResume(card) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("AudioPcmResume fail."); + return HDF_FAILURE; + } + + data->captureBufInfo.runStatus = PCM_START; + break; + default: + AUDIO_DRIVER_LOG_ERR("invalude cmd id: %d.", cmd); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHwParams(const struct AudioCard *card, const struct AudioPcmHwParams *param) +{ + const int chnlCntMin = 1; + const int chnlCntMax = 2; + + if (card == NULL || param == NULL || param->cardServiceName == NULL) { + AUDIO_DRIVER_LOG_ERR("input param is NULL."); + return HDF_FAILURE; } - for (i = 0; i < audioLen; i += framesize) { - temp = srcData[i]; - srcData[i] = srcData[i + framesize - 1]; - srcData[i + framesize - 1] = temp; + if (param->channels < chnlCntMin || param->channels > chnlCntMax) { + AUDIO_DRIVER_LOG_ERR("channels param is invalid."); + return HDF_FAILURE; + } + + struct PlatformData *platformData = PlatformDataFromCard(card); + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("platformData is null."); + return HDF_FAILURE; + } + + if (AudioFramatToBitWidth(param->format, &platformData->pcmInfo.bitWidth) != HDF_SUCCESS) { + return HDF_FAILURE; + } + if (AudioSetPcmInfo(platformData, param) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioDmaRequestChannel(platformData) != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("Dma Request Channel fail."); + return HDF_FAILURE; + } + + if (param->streamType == AUDIO_RENDER_STREAM) { + if (AudioSetRenderBufInfo(platformData, param) != HDF_SUCCESS) { + return HDF_FAILURE; + } + } else if (param->streamType == AUDIO_CAPTURE_STREAM) { + if (AudioSetCaptureBufInfo(platformData, param) != HDF_SUCCESS) { + return HDF_FAILURE; + } + } else { + AUDIO_DRIVER_LOG_ERR("param streamType is invalid."); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioRenderPrepare(const struct AudioCard *card) +{ + int ret; + if (card == NULL) { + AUDIO_DRIVER_LOG_ERR("param card is NULL."); + return HDF_FAILURE; + } + + struct PlatformData *platformData = PlatformDataFromCard(card); + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (platformData->renderBufInfo.virtAddr != NULL) { + (void)memset_s(platformData->renderBufInfo.virtAddr, platformData->renderBufInfo.cirBufSize, 0, + platformData->renderBufInfo.cirBufSize); + } + platformData->renderBufInfo.wbufOffSet = 0; + platformData->renderBufInfo.wptrOffSet = 0; + platformData->pcmInfo.totalStreamSize = 0; + platformData->renderBufInfo.framesPosition = 0; + platformData->renderBufInfo.pointer = 0; + + ret = AudioDmaConfigChannel(platformData); + if (ret) { + AUDIO_DRIVER_LOG_ERR("Dma Config Channel fail."); + return HDF_FAILURE; } - AUDIO_DRIVER_LOG_DEBUG("audioLen = %d\n", audioLen); + + return HDF_SUCCESS; +} + +int32_t AudioCapturePrepare(const struct AudioCard *card) +{ + int ret; + if (card == NULL) { + AUDIO_DRIVER_LOG_ERR("param card is NULL."); + return HDF_FAILURE; + } + + struct PlatformData *platformData = PlatformDataFromCard(card); + if (platformData == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + if (platformData->captureBufInfo.virtAddr != NULL) { + (void)memset_s(platformData->captureBufInfo.virtAddr, platformData->captureBufInfo.cirBufSize, 0, + platformData->captureBufInfo.cirBufSize); + } + platformData->captureBufInfo.rbufOffSet = 0; + platformData->captureBufInfo.rptrOffSet = 0; + platformData->captureBufInfo.chnId = 0; + platformData->pcmInfo.totalStreamSize = 0; + platformData->captureBufInfo.framesPosition = 0; + platformData->captureBufInfo.pointer = 0; + + ret = AudioDmaConfigChannel(platformData); + if (ret) { + AUDIO_DRIVER_LOG_ERR("Dma Config Channel fail."); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioPcmPointer(const struct AudioCard *card, uint32_t *pointer) +{ + int ret; + if (card == NULL || pointer == NULL) { + AUDIO_DRIVER_LOG_ERR("param card is NULL."); + return HDF_FAILURE; + } + + struct PlatformData *data = PlatformDataFromCard(card); + if (data == NULL) { + AUDIO_DRIVER_LOG_ERR("PlatformDataFromCard failed."); + return HDF_FAILURE; + } + + ret = AudioDmaPointer(data, pointer); + if (ret != HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("Dma Pointer fail."); + return HDF_FAILURE; + } + return HDF_SUCCESS; } diff --git a/model/audio/common/test/unittest/common/audio_accessory_base_test.cpp b/model/audio/common/test/unittest/common/audio_accessory_base_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..159dd09cdb3301ef590d94d917da4dd3007602f3 --- /dev/null +++ b/model/audio/common/test/unittest/common/audio_accessory_base_test.cpp @@ -0,0 +1,100 @@ +/* + * Copyright (c) 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 "audio_common_test.h" +#include +#include "hdf_uhdf_test.h" + +using namespace testing::ext; +namespace { +class AudioAccessoryBaseTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void AudioAccessoryBaseTest::SetUpTestCase() +{ + HdfTestOpenService(); +} + +void AudioAccessoryBaseTest::TearDownTestCase() +{ + HdfTestCloseService(); +} + +void AudioAccessoryBaseTest::SetUp() +{ +} + +void AudioAccessoryBaseTest::TearDown() +{ +} + +HWTEST_F(AudioAccessoryBaseTest, AudioAccessoryBaseTest_I2cReadWrite, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTI2CREADWRITE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioAccessoryBaseTest, AudioAccessoryBaseTest_RegBitsRead, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTREGBITSREAD, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioAccessoryBaseTest, AudioAccessoryBaseTest_RegBitsUpdate, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTREGBITSUPDATE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioAccessoryBaseTest, AudioAccessoryBaseTest_DeviceFrequencyParse, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDEVICEFREQUENCYPARSE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioAccessoryBaseTest, AudioAccessoryBaseTest_DaiParamsUpdate, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDAIPARAMSUPDATE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioAccessoryBaseTest, AudioAccessoryBaseTest_DeviceCfgGet, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDEVICECFGGET, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioAccessoryBaseTest, AudioAccessoryBaseTest_DeviceCtrlRegInit, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDEVICECTRLREGINIT, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioAccessoryBaseTest, AudioAccessoryBaseTest_DeviceRegRead, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDEVICEREGREAD, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioAccessoryBaseTest, AudioAccessoryBaseTest_DeviceRegWrite, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDEVICEREGWRITE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioAccessoryBaseTest, AudioAccessoryBaseTest_AccessoryGetConfigInfo, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTAGETCONFIGINFO, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +} diff --git a/model/audio/common/test/unittest/common/audio_codec_base_test.cpp b/model/audio/common/test/unittest/common/audio_codec_base_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..406d6d776bdaaaf06bd4a53a3d9061c0c1c0494d --- /dev/null +++ b/model/audio/common/test/unittest/common/audio_codec_base_test.cpp @@ -0,0 +1,71 @@ +/* + * Copyright (c) 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 "audio_common_test.h" +#include +#include "hdf_uhdf_test.h" + +using namespace testing::ext; + +namespace { +class AudioCodecBaseTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void AudioCodecBaseTest::SetUpTestCase() +{ + HdfTestOpenService(); +} + +void AudioCodecBaseTest::TearDownTestCase() +{ + HdfTestCloseService(); +} + +void AudioCodecBaseTest::SetUp() +{ +} + +void AudioCodecBaseTest::TearDown() +{ +} + +HWTEST_F(AudioCodecBaseTest, AudioCodecBaseTest_GetServiceName, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTGETSERVICENAME, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioCodecBaseTest, AudioCodecBaseTest_GetDaiName, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTGETDAINAME, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioCodecBaseTest, AudioCodecBaseTest_GetConfigInfo, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTGETCONFIGINFO, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioCodecBaseTest, AudioCodecBaseTest_SetConfigInfo, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTSETCONFIGINFO, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioCodecBaseTest, AudioCodecBaseTest_SetCtlFunc, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTSETCTLFUNC, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +} diff --git a/model/audio/common/test/unittest/common/audio_common_test.h b/model/audio/common/test/unittest/common/audio_common_test.h new file mode 100644 index 0000000000000000000000000000000000000000..26bcd52cc823b291de9c2085e7f442ae13299ce5 --- /dev/null +++ b/model/audio/common/test/unittest/common/audio_common_test.h @@ -0,0 +1,76 @@ +/* + * Copyright (c) 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 AUDIO_COMMON_TEST_H +#define AUDIO_COMMON_TEST_H + +#include "hdf_types.h" + +const int32_t g_testAudioType = 701; // 701 is TEST_AUDIO_TYPE + +enum { + TESTI2CREADWRITE = 48, + TESTREGBITSREAD, + TESTREGBITSUPDATE, + TESTDEVICEFREQUENCYPARSE, + TESTDAIPARAMSUPDATE, + TESTDEVICECFGGET, + TESTDEVICECTRLREGINIT, + TESTDEVICEREGREAD, + TESTDEVICEREGWRITE, + TESTAGETCONFIGINFO, + + TESTGETSERVICENAME, + TESTGETDAINAME, + TESTGETCONFIGINFO, + TESTSETCONFIGINFO, + TESTSETCTLFUNC, + + TESTDAIDATAFROMCARD, + TESTDAIGETCONFIGINFO, + TESTDAICHECKSAMPLERATE, + TESTDAISETCONFIGINFO, + + TESTDMABUFALLOC, + TESTDMABUFFREE, + TESTDMAREQUESTCHANNEL, + TESTDMACONFIGCHANNEL, + TESTDMAPREP, + TESTDMASUBMIT, + TESTDMAPENDING, + TESTDMAPAUSE, + TESTDMARESUME, + TESTDMAPOINTER, + + TESTDSPGETSERVICENAME, + TESTDSPGETDAINAME, + + TESTDATAFROMCARD, + TESTBYTESTOFRAMES, + TESTDATABIGENDIANCHANGE, + TESTFRAMATTOBITWIDTH, + TESTSETPCMINFO, + TESTSETRENDERBUFINFO, + TESTSETCAPTUREBUFINFO, + TESTPCMWRITE, + TESTPCMREAD, + TESTPCMMMAPWRITE, + TESTPCMMMAPREAD, + TESTRENDEROPEN, + TESTCAPTUREOPEN, + TESTRENDERCLOSE, + TESTPCMPOINTER, + TESTCAPTURECLOSE, + TESTHWPARAMS, + TESTRENDERPREPARE, + TESTCAPTUREPREPARE, + TESTRENDERTRIGGER, + TESTCAPTURETRIGGER, +}; + +#endif /* AUDIO_COMMON_TEST_H */ diff --git a/model/audio/common/test/unittest/common/audio_dai_base_test.cpp b/model/audio/common/test/unittest/common/audio_dai_base_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..d52654186fb75f1d553fa84562a4695a5adaff1f --- /dev/null +++ b/model/audio/common/test/unittest/common/audio_dai_base_test.cpp @@ -0,0 +1,65 @@ +/* + * Copyright (c) 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 "audio_common_test.h" +#include +#include "hdf_uhdf_test.h" + +using namespace testing::ext; + +namespace { +class AudioDaiBaseTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void AudioDaiBaseTest::SetUpTestCase() +{ + HdfTestOpenService(); +} + +void AudioDaiBaseTest::TearDownTestCase() +{ + HdfTestCloseService(); +} + +void AudioDaiBaseTest::SetUp() +{ +} + +void AudioDaiBaseTest::TearDown() +{ +} + +HWTEST_F(AudioDaiBaseTest, AudioDaiBaseTest_DataFromCard, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDAIDATAFROMCARD, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioDaiBaseTest, AudioDaiBaseTest_GetConfigInfo, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDAIGETCONFIGINFO, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioDaiBaseTest, AudioDaiBaseTest_CheckSampleRate, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDAICHECKSAMPLERATE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioDaiBaseTest, AudioDaiBaseTest_SetConfigInfo, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDAISETCONFIGINFO, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +} diff --git a/model/audio/common/test/unittest/common/audio_dma_base_test.cpp b/model/audio/common/test/unittest/common/audio_dma_base_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..1cfb5fc12327effedd79e5ee76ffe5486e5cc4e0 --- /dev/null +++ b/model/audio/common/test/unittest/common/audio_dma_base_test.cpp @@ -0,0 +1,101 @@ +/* + * Copyright (c) 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 "audio_common_test.h" +#include +#include "hdf_uhdf_test.h" + +using namespace testing::ext; + +namespace { +class AudioDmaBaseTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void AudioDmaBaseTest::SetUpTestCase() +{ + HdfTestOpenService(); +} + +void AudioDmaBaseTest::TearDownTestCase() +{ + HdfTestCloseService(); +} + +void AudioDmaBaseTest::SetUp() +{ +} + +void AudioDmaBaseTest::TearDown() +{ +} + +HWTEST_F(AudioDmaBaseTest, AudioDmaBaseTest_DmaBufAlloc, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDMABUFALLOC, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioDmaBaseTest, AudioDmaBaseTest_DmaBufFree, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDMABUFFREE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioDmaBaseTest, AudioDmaBaseTest_DmaRequestChannel, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDMAREQUESTCHANNEL, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioDmaBaseTest, AudioDmaBaseTest_DmaConfigChannel, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDMACONFIGCHANNEL, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioDmaBaseTest, AudioDmaBaseTest_DmaPrep, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDMAPREP, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioDmaBaseTest, AudioDmaBaseTest_DmaSubmit, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDMASUBMIT, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioDmaBaseTest, AudioDmaBaseTest_DmaPending, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDMAPENDING, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioDmaBaseTest, AudioDmaBaseTest_DmaPause, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDMAPAUSE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioDmaBaseTest, AudioDmaBaseTest_DmaResume, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDMARESUME, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioDmaBaseTest, AudioDmaBaseTest_DmaPointer, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDMAPOINTER, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +} diff --git a/model/audio/dispatch/test/unittest/common/audio_stream_dispatch_test.cpp b/model/audio/common/test/unittest/common/audio_dsp_base_test.cpp old mode 100755 new mode 100644 similarity index 52% rename from model/audio/dispatch/test/unittest/common/audio_stream_dispatch_test.cpp rename to model/audio/common/test/unittest/common/audio_dsp_base_test.cpp index 50bd21dcb33801432d9962cb098caeca6f0cd071..253c23b6db35f9e70f31347651db3683794d8957 --- a/model/audio/dispatch/test/unittest/common/audio_stream_dispatch_test.cpp +++ b/model/audio/common/test/unittest/common/audio_dsp_base_test.cpp @@ -12,7 +12,8 @@ using namespace testing::ext; -class AudioStreamDispatchTest : public testing::Test { +namespace { +class AudioDspBaseTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(); @@ -20,26 +21,33 @@ public: void TearDown(); }; -void AudioStreamDispatchTest::SetUpTestCase() +void AudioDspBaseTest::SetUpTestCase() { HdfTestOpenService(); } -void AudioStreamDispatchTest::TearDownTestCase() +void AudioDspBaseTest::TearDownTestCase() { HdfTestCloseService(); } -void AudioStreamDispatchTest::SetUp() +void AudioDspBaseTest::SetUp() { } -void AudioStreamDispatchTest::TearDown() +void AudioDspBaseTest::TearDown() { } -HWTEST_F(AudioStreamDispatchTest, AudioStreamDispatchTest001, TestSize.Level0) +HWTEST_F(AudioDspBaseTest, AudioDspBaseTest_DspGetServiceName, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTSTREAMDISPATCH, -1}; + struct HdfTestMsg msg = {g_testAudioType, TESTDSPGETSERVICENAME, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } + +HWTEST_F(AudioDspBaseTest, AudioDspBaseTest_DspGetDaiName, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDSPGETDAINAME, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +} diff --git a/model/audio/common/test/unittest/common/audio_platform_base_test.cpp b/model/audio/common/test/unittest/common/audio_platform_base_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..5524237630bd67c27c2dd39aeb60dc36add3394a --- /dev/null +++ b/model/audio/common/test/unittest/common/audio_platform_base_test.cpp @@ -0,0 +1,167 @@ +/* + * Copyright (c) 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 "audio_common_test.h" +#include +#include "hdf_uhdf_test.h" + +using namespace testing::ext; + +namespace { +class AudioPlatformBaseTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void AudioPlatformBaseTest::SetUpTestCase() +{ + HdfTestOpenService(); +} + +void AudioPlatformBaseTest::TearDownTestCase() +{ + HdfTestCloseService(); +} + +void AudioPlatformBaseTest::SetUp() +{ +} + +void AudioPlatformBaseTest::TearDown() +{ +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_PlatformDataFromCardTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDATAFROMCARD, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioBytesToFramesTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTBYTESTOFRAMES, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioDataBigEndianChangeTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTDATABIGENDIANCHANGE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioFramatToBitWidthTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTFRAMATTOBITWIDTH, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioSetPcmInfoTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTSETPCMINFO, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioSetRenderBufInfoTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTSETRENDERBUFINFO, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioSetCaptureBufInfoTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTSETCAPTUREBUFINFO, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioPcmWriteTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTPCMWRITE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioPcmReadTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTPCMREAD, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioPcmMmapWriteTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTPCMMMAPWRITE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioPcmMmapReadTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTPCMMMAPREAD, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioRenderOpenTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTRENDEROPEN, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioCaptureOpenTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTCAPTUREOPEN, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioRenderCloseTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTRENDERCLOSE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioPcmPointerTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTPCMPOINTER, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioCaptureCloseTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTCAPTURECLOSE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioHwParamsTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTHWPARAMS, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioRenderPrepareTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTRENDERPREPARE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioCapturePrepareTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTCAPTUREPREPARE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioRenderTriggerTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTRENDERTRIGGER, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioPlatformBaseTest, AudioPlatformBaseTest_AudioCaptureTriggerTest, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TESTCAPTURETRIGGER, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +} diff --git a/model/audio/core/include/audio_control.h b/model/audio/core/include/audio_control.h index cc674f739729ae8c27eecf8607fb9161d1755f2c..a8fa1034b02c3b1a3a20c2e0ee1e59601c7384a0 100755 --- a/model/audio/core/include/audio_control.h +++ b/model/audio/core/include/audio_control.h @@ -11,7 +11,6 @@ #include "hdf_dlist.h" - #ifdef __cplusplus #if __cplusplus extern "C" { @@ -37,11 +36,6 @@ struct AudioCtrlElemValue { uint32_t value[2]; }; -struct AudioKcontrol; -typedef int32_t (*KconfigInfo_t)(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemInfo *elemInfo); -typedef int32_t (*KconfigGet_t)(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue); -typedef int32_t (*KconfigSet_t)(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue); - /* mixer control */ struct AudioMixerControl { int32_t min; @@ -53,14 +47,15 @@ struct AudioMixerControl { uint32_t shift; uint32_t rshift; /* right sound channel reg shift */ uint32_t invert; + uint32_t value; }; struct AudioKcontrol { const char *name; /* ASCII name of item */ int32_t iface; - KconfigInfo_t Info; - KconfigGet_t Get; - KconfigSet_t Set; + int32_t (*Info)(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemInfo *elemInfo); + int32_t (*Get)(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue); + int32_t (*Set)(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue); void *privateData; void *pri; unsigned long privateValue; diff --git a/model/audio/core/include/audio_core.h b/model/audio/core/include/audio_core.h index 6235bbb7a169698ac3bba7f587ffa5dc3918e106..30faa241d6d80f35f49b870f8df0ae0cc088f87b 100755 --- a/model/audio/core/include/audio_core.h +++ b/model/audio/core/include/audio_core.h @@ -23,85 +23,58 @@ extern "C" { #endif #endif /* __cplusplus */ -#define CHANNEL_MAX_NUM 2 -#define CHANNEL_MIN_NUM 1 +int32_t AudioDeviceReadReg(unsigned long virtualAddress, uint32_t reg, uint32_t *value); +int32_t AudioDeviceWriteReg(unsigned long virtualAddress, uint32_t reg, uint32_t value); -#define AUDIO_DAI_LINK_COMPLETE 1 -#define AUDIO_DAI_LINK_UNCOMPLETE 0 - -#define AUDIO_DRIVER_LOG_ERR(fmt, arg...) do { \ - HDF_LOGE("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) - -#define AUDIO_DRIVER_LOG_INFO(fmt, arg...) do { \ - HDF_LOGI("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) - -#define AUDIO_DRIVER_LOG_WARNING(fmt, arg...) do { \ - HDF_LOGW("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) - -#define AUDIO_DRIVER_LOG_DEBUG(fmt, arg...) do { \ - HDF_LOGD("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) - -enum AudioDeviceType { - AUDIO_DAI_DEVICE, - AUDIO_DSP_DEVICE, - AUDIO_PLATFORM_DEVICE, - AUDIO_CODEC_DEVICE, - AUDIO_ACCESSORY_DEVICE, - AUDIO_DEVICE_BUTT, -}; - -enum PlayStatus { - STREAM_START = 4, - STREAM_STOP, -}; - -/* Dai registration interface */ -int32_t AudioSocRegisterDai(struct HdfDeviceObject *device, struct DaiData *data); -/* Platform registration interface */ -int32_t AudioSocRegisterPlatform(struct HdfDeviceObject *device, struct PlatformData *data); -/* Codec registration interface */ +int32_t AudioSocRegisterPlatform(struct HdfDeviceObject *device, struct PlatformData *platformData); +int32_t AudioSocRegisterDai(struct HdfDeviceObject *device, struct DaiData *daiData); +int32_t AudioRegisterDsp(struct HdfDeviceObject *device, struct DspData *dspData, struct DaiData *DaiData); int32_t AudioRegisterCodec(struct HdfDeviceObject *device, struct CodecData *codecData, struct DaiData *daiData); +int32_t AudioRegisterAccessory(struct HdfDeviceObject *device, + struct AccessoryData *accessoryData, struct DaiData *daiData); + int32_t AudioBindDaiLink(struct AudioCard *audioCard, const struct AudioConfigData *configData); -int32_t AudioSocDeviceRegister(struct HdfDeviceObject *device, void *data, enum AudioDeviceType deviceType); -int32_t AudioSocRegisterDsp(struct HdfDeviceObject *device, struct DaiData *data); -int32_t AudioRegisterAccessory(struct HdfDeviceObject *device, struct AccessoryData *data, struct DaiData *daiData); + int32_t AudioUpdateCodecRegBits(struct CodecDevice *codec, const struct AudioMixerControl *mixerControl, uint32_t value); int32_t AudioUpdateAccessoryRegBits(struct AccessoryDevice *accessory, const struct AudioMixerControl *mixerControl, uint32_t value); -int32_t AudioUpdateCodecAiaoRegBits(struct CodecDevice *codec, const struct AudioMixerControl *mixerControl, +int32_t AudioUpdateDaiRegBits(const struct DaiDevice *dai, const struct AudioMixerControl *mixerControl, uint32_t value); -int32_t AudioUpdateAccessoryAiaoRegBits(struct AccessoryDevice *accessory, - const struct AudioMixerControl *mixerControl, uint32_t value); + +struct DaiDevice *AudioKcontrolGetCpuDai(const struct AudioKcontrol *kcontrol); struct CodecDevice *AudioKcontrolGetCodec(const struct AudioKcontrol *kcontrol); struct AccessoryDevice *AudioKcontrolGetAccessory(const struct AudioKcontrol *kcontrol); + int32_t AudioAddControls(struct AudioCard *audioCard, const struct AudioKcontrol *controls, int32_t controlMaxNum); struct AudioKcontrol *AudioAddControl(const struct AudioCard *audioCard, const struct AudioKcontrol *ctl); +int32_t AudioGetCtrlOpsRReg(struct AudioCtrlElemValue *elemValue, + const struct AudioMixerControl *mixerCtrl, uint32_t rcurValue); +int32_t AudioGetCtrlOpsReg(struct AudioCtrlElemValue *elemValue, + const struct AudioMixerControl *mixerCtrl, uint32_t curValue); +int32_t AudioSetCtrlOpsReg(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue, + const struct AudioMixerControl *mixerCtrl, uint32_t *value); +int32_t AudioSetCtrlOpsRReg(const struct AudioCtrlElemValue *elemValue, + struct AudioMixerControl *mixerCtrl, uint32_t *rvalue, bool *updateRReg); +int32_t AudioDaiReadReg(const struct DaiDevice *dai, uint32_t reg, uint32_t *val); +int32_t AudioDaiWriteReg(const struct DaiDevice *dai, uint32_t reg, uint32_t val); + int32_t AudioCodecReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val); int32_t AudioCodecWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t val); int32_t AudioAccessoryReadReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t *val); int32_t AudioAccessoryWriteReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t val); -int32_t AudioCodecAiaoReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val); -int32_t AudioCodecAiaoWriteReg(struct CodecDevice *codec, uint32_t reg, uint32_t val); -int32_t AudioAccessoryAiaoReadReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t *val); -int32_t AudioAccessoryAiaoWriteReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t val); int32_t AudioInfoCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemInfo *elemInfo); int32_t AudioCodecGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue); int32_t AudioCodecSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue); int32_t AudioAccessoryGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue); int32_t AudioAccessorySetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue); -int32_t AudioCodecAiaoGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue); -int32_t AudioCodecAiaoSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue); -int32_t AudioAccessoryAiaoGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue); -int32_t AudioAccessoryAiaoSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue); -int32_t AudioRegisterDsp(struct HdfDeviceObject *device, struct DspData *dspData, struct DaiData *DaiData); + +int32_t AudioCpuDaiSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue); +int32_t AudioCpuDaiGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue); + #ifdef __cplusplus #if __cplusplus } diff --git a/model/audio/core/include/audio_host.h b/model/audio/core/include/audio_host.h index afc51ac34af535b9f5d74fa5d9a2dfc5ac63c1f3..58585e2e7dcac7565c2252d487bd2ffc17633a67 100755 --- a/model/audio/core/include/audio_host.h +++ b/model/audio/core/include/audio_host.h @@ -24,29 +24,51 @@ extern "C" { #endif #endif /* __cplusplus */ -#define ADM_LOG_ERR(fmt, arg...) do { \ - HDF_LOGE("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) - -#define ADM_LOG_INFO(fmt, arg...) do { \ - HDF_LOGI("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) - -#define ADM_LOG_WARNING(fmt, arg...) do { \ - HDF_LOGW("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) - -#define ADM_LOG_DEBUG(fmt, arg...) do { \ - HDF_LOGD("[%s][line:%d]: " fmt, __func__, __LINE__, ##arg); \ - } while (0) - -#define BUFF_SIZE_MAX 64 - #define AUDIO_LIST_HEAD_INIT(name) { &(name), &(name) } #define AUDIO_LIST_HEAD(name) \ struct DListHead name = AUDIO_LIST_HEAD_INIT(name) +enum AudioFormat { + AUDIO_FORMAT_PCM_8_BIT = 0x1u, /**< audio 8-bit PCM */ + AUDIO_FORMAT_PCM_16_BIT = 0x2u, /**< audio16-bit PCM */ + AUDIO_FORMAT_PCM_24_BIT = 0x3u, /**< audio 24-bit PCM */ + AUDIO_FORMAT_PCM_32_BIT = 0x4u, /**< audio 32-bit PCM */ + AUDIO_FORMAT_AAC_MAIN = 0x1000001u, /**< audio AAC main */ + AUDIO_FORMAT_AAC_LC = 0x1000002u, /**< audio AAC LC */ + AUDIO_FORMAT_AAC_LD = 0x1000003u, /**< audio AAC LD */ + AUDIO_FORMAT_AAC_ELD = 0x1000004u, /**< audio AAC ELD */ + AUDIO_FORMAT_AAC_HE_V1 = 0x1000005u, /**< audio AAC HE_V1 */ + AUDIO_FORMAT_AAC_HE_V2 = 0x1000006u, /**< audio AAC HE_V2 */ + AUDIO_FORMAT_G711A = 0x2000001u, /**< audio G711A */ + AUDIO_FORMAT_G711U = 0x2000002u, /**< audio G711u */ + AUDIO_FORMAT_G726 = 0x2000003u, /**< audio G726 */ +}; + +typedef enum { + AUDIO_SAMPLE_RATE_8000 = 8000, /* 8kHz sample_rate */ + AUDIO_SAMPLE_RATE_12000 = 12000, /* 12kHz sample_rate */ + AUDIO_SAMPLE_RATE_11025 = 11025, /* 11.025kHz sample_rate */ + AUDIO_SAMPLE_RATE_16000 = 16000, /* 16kHz sample_rate */ + AUDIO_SAMPLE_RATE_22050 = 22050, /* 22.050kHz sample_rate */ + AUDIO_SAMPLE_RATE_24000 = 24000, /* 24kHz sample_rate */ + AUDIO_SAMPLE_RATE_32000 = 32000, /* 32kHz sample_rate */ + AUDIO_SAMPLE_RATE_44100 = 44100, /* 44.1kHz sample_rate */ + AUDIO_SAMPLE_RATE_48000 = 48000, /* 48kHz sample_rate */ + AUDIO_SAMPLE_RATE_64000 = 64000, /* 64kHz sample_rate */ + AUDIO_SAMPLE_RATE_96000 = 96000, /* 96kHz sample_rate */ + AUDIO_SAMPLE_RATE_BUTT, +} AudioSampleRate; + +enum AuidoBitWidth { + BIT_WIDTH8 = 8, /* 8 bit witdth */ + BIT_WIDTH16 = 16, /* 16 bit witdth */ + BIT_WIDTH18 = 18, /* 18 bit witdth */ + BIT_WIDTH20 = 20, /* 20 bit witdth */ + BIT_WIDTH24 = 24, /* 24 bit witdth */ + BIT_WIDTH32 = 32, /* 32 bit witdth */ +}; + struct AudioConfigData { const char *cardServiceName; const char *codecName; @@ -59,20 +81,10 @@ struct AudioConfigData { const char *dspDaiName; }; -enum AudioFormat { - AUDIO_FORMAT_PCM_8_BIT = 0x1u, /**< 8-bit PCM */ - AUDIO_FORMAT_PCM_16_BIT = 0x2u, /**< 16-bit PCM */ - AUDIO_FORMAT_PCM_24_BIT = 0x3u, /**< 24-bit PCM */ - AUDIO_FORMAT_PCM_32_BIT = 0x4u, /**< 32-bit PCM */ - AUDIO_FORMAT_AAC_MAIN = 0x1000001u, /**< AAC main */ - AUDIO_FORMAT_AAC_LC = 0x1000002u, /**< AAC LC */ - AUDIO_FORMAT_AAC_LD = 0x1000003u, /**< AAC LD */ - AUDIO_FORMAT_AAC_ELD = 0x1000004u, /**< AAC ELD */ - AUDIO_FORMAT_AAC_HE_V1 = 0x1000005u, /**< AAC HE_V1 */ - AUDIO_FORMAT_AAC_HE_V2 = 0x1000006u, /**< AAC HE_V2 */ - AUDIO_FORMAT_G711A = 0x2000001u, /**< G711A */ - AUDIO_FORMAT_G711U = 0x2000002u, /**< G711u */ - AUDIO_FORMAT_G726 = 0x2000003u, /**< G726 */ +enum AudioSapmTurnStandbyMode { + AUDIO_SAPM_TURN_STANDBY_LATER = 0, + AUDIO_SAPM_TURN_STANDBY_NOW, + AUDIO_SAPM_TURN_STANDBY_BUTT, }; struct AudioCard { @@ -90,6 +102,7 @@ struct AudioCard { struct DListHead components; /* all components for this card */ struct DListHead paths; /* all paths for this card */ struct DListHead sapmDirty; /* all dirty for this card */ + enum AudioSapmTurnStandbyMode standbyMode; bool sapmSleepState; bool sapmStandbyState; bool sapmMonitorState; @@ -106,6 +119,23 @@ enum AudioStreamType { AUDIO_RENDER_STREAM, }; +struct PcmInfo { + enum AudioStreamType streamType; + /* The number of channels in a frame */ + uint32_t channels; + /* The number of frames per second */ + uint32_t rate; + uint32_t bitWidth; + uint32_t frameSize; + bool isBigEndian; + bool isSignedData; + uint32_t startThreshold; + uint32_t stopThreshold; + uint32_t silenceThreshold; + uint32_t totalStreamSize; + uint32_t interleaved; +}; + struct AudioPcmHwParams { /* The stream type in a frame */ enum AudioStreamType streamType; @@ -148,16 +178,7 @@ struct AudioRxData { unsigned long frames; /* frames number */ }; -struct AudioTxMmapData { - void *memoryAddress; /**< Pointer to the mmap buffer */ - int32_t memoryFd; /**< File descriptor of the mmap buffer */ - int32_t totalBufferFrames; /**< Total size of the mmap buffer (unit: frame )*/ - int32_t transferFrameSize; /**< Transfer size (unit: frame) */ - int32_t isShareable; /**< Whether the mmap buffer can be shared among processes */ - uint32_t offset; -}; - -struct AudioRxMmapData { +struct AudioMmapData { void *memoryAddress; /**< Pointer to the mmap buffer */ int32_t memoryFd; /**< File descriptor of the mmap buffer */ int32_t totalBufferFrames; /**< Total size of the mmap buffer (unit: frame )*/ @@ -184,16 +205,6 @@ struct AudioRuntimeDeivces { struct AudioHost *AudioHostCreateAndBind(struct HdfDeviceObject *device); -static inline struct HdfDeviceObject *AudioHostToDevice(struct AudioHost *host) -{ - return (host == NULL) ? NULL : host->device; -} - -static inline struct AudioHost *AudioHostFromDevice(struct HdfDeviceObject *device) -{ - return (device == NULL) ? NULL : (struct AudioHost *)device->service; -} - /* Get a sound card instance */ struct AudioCard *GetCardInstance(const char *serviceName); diff --git a/model/audio/core/include/audio_parse.h b/model/audio/core/include/audio_parse.h index 9ded34ee9e85c0ed6ebd22d760a2f9c27a9e6a9a..e66b3b7e52536da27bd72820ffe0df7a22a38bd8 100755 --- a/model/audio/core/include/audio_parse.h +++ b/model/audio/core/include/audio_parse.h @@ -10,6 +10,7 @@ #define AUDIO_PARSE_H #include "audio_host.h" +#include "audio_control.h" #ifdef __cplusplus #if __cplusplus @@ -17,8 +18,87 @@ extern "C" { #endif #endif /* __cplusplus */ +#define AUDIO_CONFIG_MAX_ITEM 100 +#define AUDIO_CTRL_LIST_MAX 10 +#define AUDIO_SAPM_COMP_NAME_LIST_MAX 9 +#define AUDIO_SAPM_CFG_NAME_LIST_MAX 4 + +static const char *g_audioControlsList[AUDIO_CTRL_LIST_MAX] = { + "Main Playback Volume", "Main Capture Volume", + "Playback Mute", "Capture Mute", "Mic Left Gain", + "Mic Right Gain", "External Codec Enable", + "Internally Codec Enable", "Render Channel Mode", "Captrue Channel Mode" +}; + +static char *g_audioSapmCompNameList[AUDIO_SAPM_COMP_NAME_LIST_MAX] = { + "ADCL", "ADCR", "DACL", "DACR", "LPGA", "RPGA", "SPKL", "SPKR", "MIC" +}; + +static char *g_audioSapmCfgNameList[AUDIO_SAPM_CFG_NAME_LIST_MAX] = { + "LPGA MIC Switch", "RPGA MIC Switch", "Dacl enable", "Dacr enable" +}; + +enum AudioRegOpsType { + AUDIO_RSET_GROUP = 0, + AUDIO_INIT_GROUP, + AUDIO_CTRL_PATAM_GROUP, + AUDIO_CTRL_SAPM_PATAM_GROUP, + AUDIO_DAI_STARTUP_PATAM_GROUP, + AUDIO_DAI_PATAM_GROUP, + AUDIO_DAI_TRIGGER_GROUP, + AUDIO_CTRL_CFG_GROUP, + AUDIO_SAPM_COMP_GROUP, + AUDIO_SAPM_CFG_GROUP, + AUDIO_GROUP_MAX +}; + +struct AudioIdInfo { + const char *chipName; + uint32_t chipIdRegister; + uint32_t chipIdSize; +}; + +struct AudioControlConfig { + uint8_t arrayIndex; + uint8_t iface; + uint8_t enable; +}; + +struct AudioAddrConfig { + uint32_t addr; + uint32_t value; +}; + +struct AudioSapmCtrlConfig { + uint8_t sapmType; + uint8_t compNameIndex; + uint8_t reg; + uint8_t mask; + uint8_t shift; + uint8_t invert; + uint8_t kcontrolNews; + uint8_t kcontrolsNum; +}; + + +struct AudioRegCfgGroupNode { + uint8_t itemNum; + enum AudioRegOpsType groupIndex; + struct AudioAddrConfig *addrCfgItem; + struct AudioMixerControl *regCfgItem; + struct AudioControlConfig *ctrlCfgItem; + struct AudioSapmCtrlConfig *sapmCompItem; +}; + +struct AudioRegCfgData { + struct AudioIdInfo audioIdInfo; + struct AudioRegCfgGroupNode *audioRegParams[AUDIO_GROUP_MAX]; +}; + int32_t AudioFillConfigData(const struct HdfDeviceObject *device, struct AudioConfigData *configData); +int32_t CodecGetRegConfig(const struct HdfDeviceObject *device, struct AudioRegCfgData *configData); + #ifdef __cplusplus #if __cplusplus } diff --git a/model/audio/core/src/audio_core.c b/model/audio/core/src/audio_core.c index fb3581ed4ec55c6215e50a6c6763301d69f25085..8115d86892fe99adb6c685d894f0269fa197a7bc 100755 --- a/model/audio/core/src/audio_core.c +++ b/model/audio/core/src/audio_core.c @@ -7,45 +7,69 @@ */ #include "audio_core.h" +#include "audio_driver_log.h" +#include "osal_io.h" #define HDF_LOG_TAG audio_core +#define CHANNEL_MAX_NUM 2 +#define CHANNEL_MIN_NUM 1 +#define AUDIO_DAI_LINK_COMPLETE 1 +#define AUDIO_DAI_LINK_UNCOMPLETE 0 + AUDIO_LIST_HEAD(daiController); AUDIO_LIST_HEAD(platformController); AUDIO_LIST_HEAD(codecController); AUDIO_LIST_HEAD(dspController); AUDIO_LIST_HEAD(accessoryController); -int32_t AudioSocRegisterPlatform(struct HdfDeviceObject *device, struct PlatformData *data) +int32_t AudioDeviceReadReg(unsigned long virtualAddress, uint32_t reg, uint32_t *val) { - struct PlatformDevice *platform = NULL; + if (val == NULL) { + AUDIO_DRIVER_LOG_ERR("param val is null."); + return HDF_FAILURE; + } + + *val = OSAL_READL((void *)((uintptr_t)(virtualAddress + reg))); + return HDF_SUCCESS; +} - if ((device == NULL) || (data == NULL)) { - ADM_LOG_ERR("Input params check error: device=%p, data=%p.", device, data); +int32_t AudioDeviceWriteReg(unsigned long virtualAddress, uint32_t reg, uint32_t value) +{ + OSAL_WRITEL(value, (void *)((uintptr_t)(virtualAddress + reg))); + return HDF_SUCCESS; +} + +int32_t AudioSocRegisterPlatform(struct HdfDeviceObject *device, struct PlatformData *platformData) +{ + struct PlatformDevice *platformDevice = NULL; + + if ((device == NULL) || (platformData == NULL)) { + ADM_LOG_ERR("Input params check error: device=%p, platformData=%p.", device, platformData); return HDF_ERR_INVALID_OBJECT; } - platform = (struct PlatformDevice *)OsalMemCalloc(sizeof(*platform)); - if (platform == NULL) { - ADM_LOG_ERR("Malloc platform device fail!"); + platformDevice = (struct PlatformDevice *)OsalMemCalloc(sizeof(*platformDevice)); + if (platformDevice == NULL) { + ADM_LOG_ERR("Malloc platformDevice device fail!"); return HDF_ERR_MALLOC_FAIL; } - platform->devPlatformName = data->drvPlatformName; - platform->devData = data; - platform->device = device; - DListInsertHead(&platform->list, &platformController); - ADM_LOG_INFO("Register [%s] success.", platform->devPlatformName); + platformDevice->devPlatformName = platformData->drvPlatformName; + platformDevice->devData = platformData; + platformDevice->device = device; + DListInsertHead(&platformDevice->list, &platformController); + ADM_LOG_INFO("Register [%s] success.", platformDevice->devPlatformName); return HDF_SUCCESS; } -int32_t AudioSocRegisterDai(struct HdfDeviceObject *device, struct DaiData *data) +int32_t AudioSocRegisterDai(struct HdfDeviceObject *device, struct DaiData *daiData) { struct DaiDevice *dai = NULL; - if ((device == NULL) || (data == NULL)) { - ADM_LOG_ERR("Input params check error: device=%p, data=%p.", device, data); + if ((device == NULL) || (daiData == NULL)) { + ADM_LOG_ERR("Input params check error: device=%p, daiData=%p.", device, daiData); return HDF_ERR_INVALID_OBJECT; } @@ -55,8 +79,8 @@ int32_t AudioSocRegisterDai(struct HdfDeviceObject *device, struct DaiData *data return HDF_ERR_MALLOC_FAIL; } - dai->devDaiName = data->drvDaiName; - dai->devData = data; + dai->devDaiName = daiData->drvDaiName; + dai->devData = daiData; dai->device = device; DListInsertHead(&dai->list, &daiController); ADM_LOG_INFO("Register [%s] success.", dai->devDaiName); @@ -64,13 +88,15 @@ int32_t AudioSocRegisterDai(struct HdfDeviceObject *device, struct DaiData *data return HDF_SUCCESS; } -int32_t AudioRegisterAccessory(struct HdfDeviceObject *device, struct AccessoryData *data, struct DaiData *daiData) +int32_t AudioRegisterAccessory(struct HdfDeviceObject *device, + struct AccessoryData *accessoryData, struct DaiData *daiData) { struct AccessoryDevice *accessory = NULL; int32_t ret; - if (device == NULL || data == NULL || daiData == NULL) { - ADM_LOG_ERR("Input params check error: device=%p, data=%p, daiData=%p.", device, data, daiData); + if (device == NULL || accessoryData == NULL || daiData == NULL) { + ADM_LOG_ERR("Input params check error: device=%p, accessoryData=%p, daiData=%p.", + device, accessoryData, daiData); return HDF_ERR_INVALID_OBJECT; } @@ -81,11 +107,11 @@ int32_t AudioRegisterAccessory(struct HdfDeviceObject *device, struct AccessoryD } OsalMutexInit(&accessory->mutex); - accessory->devAccessoryName = data->drvAccessoryName; - accessory->devData = data; + accessory->devAccessoryName = accessoryData->drvAccessoryName; + accessory->devData = accessoryData; accessory->device = device; - ret = AudioSocDeviceRegister(device, (void *)daiData, AUDIO_DAI_DEVICE); + ret = AudioSocRegisterDai(device, daiData); if (ret != HDF_SUCCESS) { OsalMemFree(accessory); ADM_LOG_ERR("Register accessory device fail ret=%d", ret); @@ -119,8 +145,9 @@ int32_t AudioRegisterCodec(struct HdfDeviceObject *device, struct CodecData *cod codec->devData = codecData; codec->device = device; - ret = AudioSocDeviceRegister(device, (void *)daiData, AUDIO_DAI_DEVICE); + ret = AudioSocRegisterDai(device, daiData); if (ret != HDF_SUCCESS) { + OsalIoUnmap((void *)((uintptr_t)(codec->devData->virtualAddress))); OsalMemFree(codec); ADM_LOG_ERR("Register dai device fail ret=%d", ret); return HDF_ERR_IO; @@ -152,7 +179,7 @@ int32_t AudioRegisterDsp(struct HdfDeviceObject *device, struct DspData *dspData dspDev->devData = dspData; dspDev->device = device; - ret = AudioSocDeviceRegister(device, (void *)DaiData, AUDIO_DAI_DEVICE); + ret = AudioSocRegisterDai(device, DaiData); if (ret != HDF_SUCCESS) { OsalMemFree(dspDev); ADM_LOG_ERR("Register dai device fail ret=%d", ret); @@ -164,47 +191,7 @@ int32_t AudioRegisterDsp(struct HdfDeviceObject *device, struct DspData *dspData return HDF_SUCCESS; } -int32_t AudioSocDeviceRegister(struct HdfDeviceObject *device, void *data, enum AudioDeviceType deviceType) -{ - struct PlatformData *platformData = NULL; - struct DaiData *daiData = NULL; - int32_t ret; - - if ((device == NULL) || (data == NULL) || (deviceType >= AUDIO_DEVICE_BUTT) || (deviceType < 0)) { - ADM_LOG_ERR("Input params check error: device=%p, data=%p, deviceType=%d.", - device, data, deviceType); - return HDF_ERR_INVALID_OBJECT; - } - - switch (deviceType) { - case AUDIO_DAI_DEVICE: { - daiData = (struct DaiData *)data; - ret = AudioSocRegisterDai(device, daiData); - if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Register dai device fail ret=%d", ret); - return HDF_FAILURE; - } - break; - } - case AUDIO_PLATFORM_DEVICE: { - platformData = (struct PlatformData *)data; - ret = AudioSocRegisterPlatform(device, platformData); - if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Register dma device fail ret=%d", ret); - return HDF_FAILURE; - } - break; - } - default: { - ADM_LOG_ERR("Invalid device type."); - return HDF_FAILURE; - } - } - - return HDF_SUCCESS; -} - -int32_t AudioSeekPlatformDevice(struct AudioRuntimeDeivces *rtd, const struct AudioConfigData *configData) +static int32_t AudioSeekPlatformDevice(struct AudioRuntimeDeivces *rtd, const struct AudioConfigData *configData) { struct PlatformDevice *platform = NULL; if (rtd == NULL || configData == NULL) { @@ -217,7 +204,7 @@ int32_t AudioSeekPlatformDevice(struct AudioRuntimeDeivces *rtd, const struct Au } DLIST_FOR_EACH_ENTRY(platform, &platformController, struct PlatformDevice, list) { - if (platform != NULL && platform->devPlatformName != NULL && + if (platform->devPlatformName != NULL && strcmp(platform->devPlatformName, configData->platformName) == 0) { rtd->platform = platform; break; @@ -227,7 +214,7 @@ int32_t AudioSeekPlatformDevice(struct AudioRuntimeDeivces *rtd, const struct Au return HDF_SUCCESS; } -int32_t AudioSeekCpuDaiDevice(struct AudioRuntimeDeivces *rtd, const struct AudioConfigData *configData) +static int32_t AudioSeekCpuDaiDevice(struct AudioRuntimeDeivces *rtd, const struct AudioConfigData *configData) { struct DaiDevice *cpuDai = NULL; if (rtd == NULL || configData == NULL) { @@ -254,7 +241,7 @@ int32_t AudioSeekCpuDaiDevice(struct AudioRuntimeDeivces *rtd, const struct Audi return HDF_SUCCESS; } -int32_t AudioSeekCodecDevice(struct AudioRuntimeDeivces *rtd, const struct AudioConfigData *configData) +static int32_t AudioSeekCodecDevice(struct AudioRuntimeDeivces *rtd, const struct AudioConfigData *configData) { struct CodecDevice *codec = NULL; struct DaiDevice *codecDai = NULL; @@ -269,7 +256,7 @@ int32_t AudioSeekCodecDevice(struct AudioRuntimeDeivces *rtd, const struct Audio } DLIST_FOR_EACH_ENTRY(codec, &codecController, struct CodecDevice, list) { - if (codec != NULL && codec->devCodecName != NULL && strcmp(codec->devCodecName, configData->codecName) == 0) { + if (codec->devCodecName != NULL && strcmp(codec->devCodecName, configData->codecName) == 0) { rtd->codec = codec; DLIST_FOR_EACH_ENTRY(codecDai, &daiController, struct DaiDevice, list) { if (codecDai != NULL && codecDai->device != NULL && codec->device == codecDai->device && @@ -285,7 +272,7 @@ int32_t AudioSeekCodecDevice(struct AudioRuntimeDeivces *rtd, const struct Audio return HDF_SUCCESS; } -int32_t AudioSeekAccessoryDevice(struct AudioRuntimeDeivces *rtd, const struct AudioConfigData *configData) +static int32_t AudioSeekAccessoryDevice(struct AudioRuntimeDeivces *rtd, const struct AudioConfigData *configData) { struct AccessoryDevice *accessory = NULL; struct DaiDevice *accessoryDai = NULL; @@ -318,7 +305,7 @@ int32_t AudioSeekAccessoryDevice(struct AudioRuntimeDeivces *rtd, const struct A return HDF_SUCCESS; } -int32_t AudioSeekDspDevice(struct AudioRuntimeDeivces *rtd, const struct AudioConfigData *configData) +static int32_t AudioSeekDspDevice(struct AudioRuntimeDeivces *rtd, const struct AudioConfigData *configData) { struct DspDevice *dsp = NULL; struct DaiDevice *dspDai = NULL; @@ -388,7 +375,7 @@ int32_t AudioUpdateCodecRegBits(struct CodecDevice *codec, const struct AudioMixerControl *mixerControl, uint32_t value) { int32_t ret; - uint32_t curValue; + uint32_t curValue = 0; uint32_t mixerControlMask; if (codec == NULL || mixerControl == NULL) { ADM_LOG_ERR("Invalid accessory param."); @@ -423,7 +410,7 @@ int32_t AudioUpdateAccessoryRegBits(struct AccessoryDevice *accessory, const struct AudioMixerControl *mixerControl, uint32_t value) { int32_t ret; - uint32_t curValue; + uint32_t curValue = 0; uint32_t mixerControlMask; if (accessory == NULL || mixerControl == NULL) { ADM_LOG_ERR("Invalid accessory param."); @@ -453,78 +440,50 @@ int32_t AudioUpdateAccessoryRegBits(struct AccessoryDevice *accessory, return HDF_SUCCESS; } -int32_t AudioUpdateCodecAiaoRegBits(struct CodecDevice *codec, - const struct AudioMixerControl *mixerControl, uint32_t value) +int32_t AudioUpdateDaiRegBits(const struct DaiDevice *dai, const struct AudioMixerControl *mixerControl, uint32_t value) { int32_t ret; - uint32_t curValue; + uint32_t curValue = 0; uint32_t mixerControlMask; - ADM_LOG_DEBUG("Entry to update AIAO codec reg bits."); + struct DaiData *data = NULL; - if (codec == NULL || mixerControl == NULL) { - ADM_LOG_ERR("Invalid AIAO codec param."); + if (dai == NULL || dai->devData == NULL || mixerControl == NULL) { + ADM_LOG_ERR("Invalid accessory param."); return HDF_ERR_INVALID_OBJECT; } + data = dai->devData; - value = value << mixerControl->shift; - mixerControlMask = mixerControl->mask << mixerControl->shift; - - OsalMutexLock(&codec->mutex); - ret = AudioCodecAiaoReadReg(codec, mixerControl->reg, &curValue); - if (ret != HDF_SUCCESS) { - OsalMutexUnlock(&codec->mutex); - ADM_LOG_ERR("Read AIAO codec reg fail ret=%d.", ret); + if (value > mixerControl->max || value < mixerControl->min) { + ADM_LOG_ERR("value is invalued=%d.", value); return HDF_FAILURE; } - curValue = (curValue & ~mixerControlMask) | (value & mixerControlMask); - ret = AudioCodecAiaoWriteReg(codec, mixerControl->reg, curValue); - if (ret != HDF_SUCCESS) { - OsalMutexUnlock(&codec->mutex); - ADM_LOG_ERR("Write AIAO codec reg fail ret=%d", ret); - return HDF_FAILURE; - } - OsalMutexUnlock(&codec->mutex); - - ADM_LOG_DEBUG("Update AIAO codec reg bits successful."); - return HDF_SUCCESS; -} - -int32_t AudioUpdateAccessoryAiaoRegBits(struct AccessoryDevice *accessory, - const struct AudioMixerControl *mixerControl, uint32_t value) -{ - int32_t ret; - uint32_t curValue; - uint32_t mixerControlMask; - ADM_LOG_DEBUG("Entry to update AIAO accessory reg bits."); - - if (accessory == NULL || mixerControl == NULL) { - ADM_LOG_ERR("Invalid AIAO accessory param."); - return HDF_ERR_INVALID_OBJECT; - } - value = value << mixerControl->shift; mixerControlMask = mixerControl->mask << mixerControl->shift; - OsalMutexLock(&accessory->mutex); - ret = AudioAccessoryAiaoReadReg(accessory, mixerControl->reg, &curValue); + OsalMutexLock(&data->mutex); + ret = AudioDaiReadReg(dai, mixerControl->reg, &curValue); if (ret != HDF_SUCCESS) { - OsalMutexUnlock(&accessory->mutex); - ADM_LOG_ERR("Read AIAO accessory reg fail ret=%d.", ret); + OsalMutexUnlock(&data->mutex); + ADM_LOG_ERR("Read reg fail ret=%d.", ret); return HDF_FAILURE; } + curValue = (curValue & ~mixerControlMask) | (value & mixerControlMask); - ret = AudioAccessoryAiaoWriteReg(accessory, mixerControl->reg, curValue); + + ADM_LOG_DEBUG("reg: 0x%x curValue: 0x%x.", mixerControl->reg, curValue); + ret = AudioDaiWriteReg(dai, mixerControl->reg, curValue); if (ret != HDF_SUCCESS) { - OsalMutexUnlock(&accessory->mutex); - ADM_LOG_ERR("Write AIAO accessory reg fail ret=%d", ret); + OsalMutexUnlock(&data->mutex); + ADM_LOG_ERR("Write reg fail ret=%d", ret); return HDF_FAILURE; } - OsalMutexUnlock(&accessory->mutex); + OsalMutexUnlock(&data->mutex); - ADM_LOG_DEBUG("Update AIAO accessory reg bits successful."); + ADM_LOG_DEBUG("Success."); return HDF_SUCCESS; } + struct CodecDevice *AudioKcontrolGetCodec(const struct AudioKcontrol *kcontrol) { struct AudioCard *audioCard = NULL; @@ -559,6 +518,23 @@ struct AccessoryDevice *AudioKcontrolGetAccessory(const struct AudioKcontrol *kc return audioCard->rtd->accessory; } +struct DaiDevice *AudioKcontrolGetCpuDai(const struct AudioKcontrol *kcontrol) +{ + struct AudioCard *audioCard = NULL; + if (kcontrol == NULL || kcontrol->pri == NULL) { + ADM_LOG_ERR("Input param kcontrol is NULL."); + return NULL; + } + + audioCard = (struct AudioCard *)((volatile uintptr_t)(kcontrol->pri)); + if (audioCard == NULL || audioCard->rtd == NULL) { + ADM_LOG_ERR("Get codec or rtd fail."); + return NULL; + } + + return audioCard->rtd->cpuDai; +} + struct AudioKcontrol *AudioAddControl(const struct AudioCard *audioCard, const struct AudioKcontrol *ctrl) { struct AudioKcontrol *control = NULL; @@ -608,61 +584,67 @@ int32_t AudioAddControls(struct AudioCard *audioCard, const struct AudioKcontrol return HDF_SUCCESS; } -int32_t AudioCodecReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val) +int32_t AudioDaiReadReg(const struct DaiDevice *dai, uint32_t reg, uint32_t *val) { int32_t ret; - if (codec == NULL || codec->devData == NULL || codec->devData->Read == NULL || val == NULL) { - ADM_LOG_ERR("Input param codec is NULL."); + unsigned long virtualAddress; + if (dai == NULL || dai->devData == NULL || dai->devData->Read == NULL || val == NULL) { + ADM_LOG_ERR("Input param is NULL."); return HDF_FAILURE; } - ret = codec->devData->Read(codec, reg, val); + virtualAddress = dai->devData->regVirtualAddr; + ret = dai->devData->Read(virtualAddress, reg, val); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Codec device read fail."); + ADM_LOG_ERR("dai device read fail."); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioAccessoryReadReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t *val) +int32_t AudioDaiWriteReg(const struct DaiDevice *dai, uint32_t reg, uint32_t val) { int32_t ret; - if (accessory == NULL || accessory->devData == NULL || accessory->devData->Read == NULL || val == NULL) { - ADM_LOG_ERR("Input param accessory is NULL."); + unsigned long virtualAddress; + if (dai == NULL || dai->devData == NULL || dai->devData->Write == NULL) { + ADM_LOG_ERR("Input param codec is NULL."); return HDF_FAILURE; } - ret = accessory->devData->Read(accessory, reg, val); + virtualAddress = dai->devData->regVirtualAddr; + ret = dai->devData->Write(virtualAddress, reg, val); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Accessory device read fail."); + ADM_LOG_ERR("dai device write fail."); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioCodecAiaoReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val) +int32_t AudioCodecReadReg(const struct CodecDevice *codec, uint32_t reg, uint32_t *val) { int32_t ret; - if (codec == NULL || codec->devData == NULL || codec->devData->AiaoRead == NULL || val == NULL) { + unsigned long virtualAddress; + if (codec == NULL || codec->devData == NULL || codec->devData->Read == NULL || val == NULL) { ADM_LOG_ERR("Input param codec is NULL."); return HDF_FAILURE; } - ret = codec->devData->AiaoRead(codec, reg, val); + virtualAddress = codec->devData->virtualAddress; + ret = codec->devData->Read(virtualAddress, reg, val); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Device read fail."); + ADM_LOG_ERR("Codec device read fail."); return HDF_FAILURE; } return HDF_SUCCESS; } -int32_t AudioAccessoryAiaoReadReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t *val) +int32_t AudioAccessoryReadReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t *val) { int32_t ret; - if (accessory == NULL || accessory->devData == NULL || accessory->devData->AiaoRead == NULL || val == NULL) { + if (accessory == NULL || accessory->devData == NULL || accessory->devData->Read == NULL || val == NULL) { ADM_LOG_ERR("Input param accessory is NULL."); return HDF_FAILURE; } - ret = accessory->devData->AiaoRead(accessory, reg, val); + ret = accessory->devData->Read(accessory, reg, val); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Device read fail."); + ADM_LOG_ERR("Accessory device read fail."); return HDF_FAILURE; } return HDF_SUCCESS; @@ -671,11 +653,13 @@ int32_t AudioAccessoryAiaoReadReg(const struct AccessoryDevice *accessory, uint3 int32_t AudioCodecWriteReg(const struct CodecDevice *codec, uint32_t reg, uint32_t val) { int32_t ret; + unsigned long virtualAddress; if (codec == NULL || codec->devData == NULL || codec->devData->Write == NULL) { ADM_LOG_ERR("Input param codec is NULL."); return HDF_FAILURE; } - ret = codec->devData->Write(codec, reg, val); + virtualAddress = codec->devData->virtualAddress; + ret = codec->devData->Write(virtualAddress, reg, val); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("Codec device write fail."); return HDF_FAILURE; @@ -698,36 +682,6 @@ int32_t AudioAccessoryWriteReg(const struct AccessoryDevice *accessory, uint32_t return HDF_SUCCESS; } -int32_t AudioCodecAiaoWriteReg(struct CodecDevice *codec, uint32_t reg, uint32_t val) -{ - int32_t ret; - if (codec == NULL || codec->devData == NULL || codec->devData->AiaoWrite == NULL) { - ADM_LOG_ERR("Input param codec aiao is NULL."); - return HDF_FAILURE; - } - ret = codec->devData->AiaoWrite(codec, reg, val); - if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Codec aiao device write fail."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -int32_t AudioAccessoryAiaoWriteReg(const struct AccessoryDevice *accessory, uint32_t reg, uint32_t val) -{ - int32_t ret; - if (accessory == NULL || accessory->devData == NULL || accessory->devData->AiaoWrite == NULL) { - ADM_LOG_ERR("Input param accessory aiao is NULL."); - return HDF_FAILURE; - } - ret = accessory->devData->AiaoWrite(accessory, reg, val); - if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Accessory aiao device write fail."); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - int32_t AudioInfoCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemInfo *elemInfo) { struct AudioMixerControl *mixerCtrl = NULL; @@ -750,7 +704,7 @@ int32_t AudioInfoCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlE return HDF_SUCCESS; } -static int32_t AudioGetCtrlOpsRReg(struct AudioCtrlElemValue *elemValue, +int32_t AudioGetCtrlOpsRReg(struct AudioCtrlElemValue *elemValue, const struct AudioMixerControl *mixerCtrl, uint32_t rcurValue) { if (elemValue == NULL || mixerCtrl == NULL) { @@ -777,7 +731,7 @@ static int32_t AudioGetCtrlOpsRReg(struct AudioCtrlElemValue *elemValue, return HDF_SUCCESS; } -static int32_t AudioGetCtrlOpsReg(struct AudioCtrlElemValue *elemValue, +int32_t AudioGetCtrlOpsReg(struct AudioCtrlElemValue *elemValue, const struct AudioMixerControl *mixerCtrl, uint32_t curValue) { if (elemValue == NULL || mixerCtrl == NULL) { @@ -800,8 +754,8 @@ static int32_t AudioGetCtrlOpsReg(struct AudioCtrlElemValue *elemValue, int32_t AudioCodecGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue) { - uint32_t curValue; - uint32_t rcurValue; + uint32_t curValue = 0; + uint32_t rcurValue = 0; struct AudioMixerControl *mixerCtrl = NULL; struct CodecDevice *codec = NULL; if (kcontrol == NULL || kcontrol->privateValue <= 0 || elemValue == NULL) { @@ -830,8 +784,8 @@ int32_t AudioCodecGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioC int32_t AudioAccessoryGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue) { - uint32_t curValue; - uint32_t rcurValue; + uint32_t curValue = 0; + uint32_t rcurValue = 0; struct AudioMixerControl *mixerCtrl = NULL; struct AccessoryDevice *accessory = NULL; if (kcontrol == NULL || kcontrol->privateValue <= 0 || elemValue == NULL) { @@ -859,71 +813,7 @@ int32_t AudioAccessoryGetCtrlOps(const struct AudioKcontrol *kcontrol, struct Au return HDF_SUCCESS; } -int32_t AudioCodecAiaoGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue) -{ - uint32_t curValue; - uint32_t rcurValue; - struct CodecDevice *codec = NULL; - struct AudioMixerControl *mixerCtrl = NULL; - if (kcontrol == NULL || kcontrol->privateValue <= 0 || elemValue == NULL) { - ADM_LOG_ERR("CODECAIAO input param is NULL."); - return HDF_ERR_INVALID_OBJECT; - } - - codec = AudioKcontrolGetCodec(kcontrol); - mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)kcontrol->privateValue); - if (mixerCtrl == NULL || codec == NULL) { - ADM_LOG_ERR("mixerCtrl and codec is NULL."); - return HDF_FAILURE; - } - if (AudioCodecAiaoReadReg(codec, mixerCtrl->reg, &curValue) != HDF_SUCCESS || - AudioCodecAiaoReadReg(codec, mixerCtrl->rreg, &rcurValue) != HDF_SUCCESS) { - ADM_LOG_ERR("Read Reg fail."); - return HDF_FAILURE; - } - if (AudioGetCtrlOpsReg(elemValue, mixerCtrl, curValue) != HDF_SUCCESS || - AudioGetCtrlOpsRReg(elemValue, mixerCtrl, rcurValue) != HDF_SUCCESS) { - ADM_LOG_ERR("Audio CODECAIAO get kcontrol reg and rreg fail."); - return HDF_FAILURE; - } - - ADM_LOG_DEBUG("Get CODECAIAO ctrl switch successful."); - return HDF_SUCCESS; -} - -int32_t AudioAccessoryAiaoGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue) -{ - uint32_t curValue; - uint32_t rcurValue; - struct AccessoryDevice *accessory = NULL; - struct AudioMixerControl *mixerCtrl = NULL; - if (kcontrol == NULL || kcontrol->privateValue <= 0 || elemValue == NULL) { - ADM_LOG_ERR("ACCESSORYCAIAO input param is NULL."); - return HDF_ERR_INVALID_OBJECT; - } - - accessory = AudioKcontrolGetAccessory(kcontrol); - mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)kcontrol->privateValue); - if (mixerCtrl == NULL || accessory == NULL) { - ADM_LOG_ERR("mixerCtrl and accessory is NULL."); - return HDF_FAILURE; - } - if (AudioAccessoryAiaoReadReg(accessory, mixerCtrl->reg, &curValue) != HDF_SUCCESS || - AudioAccessoryAiaoReadReg(accessory, mixerCtrl->rreg, &rcurValue) != HDF_SUCCESS) { - ADM_LOG_ERR("Read Reg fail."); - return HDF_FAILURE; - } - if (AudioGetCtrlOpsReg(elemValue, mixerCtrl, curValue) != HDF_SUCCESS || - AudioGetCtrlOpsRReg(elemValue, mixerCtrl, rcurValue) != HDF_SUCCESS) { - ADM_LOG_ERR("Audio ACCESSORYCAIAO get kcontrol reg and rreg fail."); - return HDF_FAILURE; - } - - ADM_LOG_DEBUG("Get ACCESSORYCAIAO ctrl switch successful."); - return HDF_SUCCESS; -} - -static int32_t AudioSetCtrlOpsReg(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue, +int32_t AudioSetCtrlOpsReg(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue, const struct AudioMixerControl *mixerCtrl, uint32_t *value) { if (kcontrol == NULL || (kcontrol->privateValue <= 0) || elemValue == NULL || @@ -944,7 +834,7 @@ static int32_t AudioSetCtrlOpsReg(const struct AudioKcontrol *kcontrol, const st return HDF_SUCCESS; } -static int32_t AudioSetCtrlOpsRReg(const struct AudioCtrlElemValue *elemValue, +int32_t AudioSetCtrlOpsRReg(const struct AudioCtrlElemValue *elemValue, struct AudioMixerControl *mixerCtrl, uint32_t *rvalue, bool *updateRReg) { uint32_t rshift; @@ -1054,79 +944,74 @@ int32_t AudioAccessorySetCtrlOps(const struct AudioKcontrol *kcontrol, const str return HDF_SUCCESS; } -int32_t AudioCodecAiaoSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue) +int32_t AudioCpuDaiSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue) { uint32_t value; uint32_t rvalue; bool updateRReg = false; - struct CodecDevice *codec = NULL; + struct DaiDevice *dai = NULL; struct AudioMixerControl *mixerCtrl = NULL; if (kcontrol == NULL || (kcontrol->privateValue <= 0) || elemValue == NULL) { - ADM_LOG_ERR("Audio codec aiao input param is NULL."); + ADM_LOG_ERR("Audio input param is NULL."); return HDF_ERR_INVALID_OBJECT; } mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)kcontrol->privateValue); if (AudioSetCtrlOpsReg(kcontrol, elemValue, mixerCtrl, &value) != HDF_SUCCESS) { - ADM_LOG_ERR("AudioSetCtrlOpsReg fail."); - return HDF_FAILURE; + ADM_LOG_ERR("AudioSetCtrlOpsReg is fail."); + return HDF_ERR_INVALID_OBJECT; } - - codec = AudioKcontrolGetCodec(kcontrol); - if (AudioUpdateCodecAiaoRegBits(codec, mixerCtrl, value) != HDF_SUCCESS) { - ADM_LOG_ERR("Audio codec aiao stereo update reg bits fail."); + dai = AudioKcontrolGetCpuDai(kcontrol); + if (dai == NULL) { + ADM_LOG_ERR("AudioKcontrolGetCodec is fail."); + return HDF_ERR_INVALID_OBJECT; + } + if (AudioUpdateDaiRegBits(dai, mixerCtrl, value) != HDF_SUCCESS) { + ADM_LOG_ERR("Audio codec stereo update reg bits fail."); return HDF_FAILURE; } if (AudioSetCtrlOpsRReg(elemValue, mixerCtrl, &rvalue, &updateRReg) != HDF_SUCCESS) { - ADM_LOG_ERR("AudioSetCtrlOpsRReg fail."); - return HDF_FAILURE; + ADM_LOG_ERR("AudioSetCtrlOpsRReg is fail."); + return HDF_ERR_INVALID_OBJECT; } + if (updateRReg) { - if (AudioUpdateCodecAiaoRegBits(codec, mixerCtrl, rvalue) != HDF_SUCCESS) { - ADM_LOG_ERR("Audio codec aiao stereo update reg bits fail."); + if (AudioUpdateDaiRegBits(dai, mixerCtrl, rvalue) != HDF_SUCCESS) { + ADM_LOG_ERR("Audio codec stereo update reg bits fail."); return HDF_FAILURE; } } - return HDF_SUCCESS; } -int32_t AudioAccessoryAiaoSetCtrlOps(const struct AudioKcontrol *kcontrol, const struct AudioCtrlElemValue *elemValue) +int32_t AudioCpuDaiGetCtrlOps(const struct AudioKcontrol *kcontrol, struct AudioCtrlElemValue *elemValue) { - uint32_t value; - uint32_t rvalue; - bool updateRReg = false; - struct AccessoryDevice *accessory = NULL; + uint32_t curValue = 0; + uint32_t rcurValue = 0; struct AudioMixerControl *mixerCtrl = NULL; - if (kcontrol == NULL || (kcontrol->privateValue <= 0) || elemValue == NULL) { - ADM_LOG_ERR("Audio accessory aiao input param is NULL."); + struct DaiDevice *dai = NULL; + if (kcontrol == NULL || kcontrol->privateValue <= 0 || elemValue == NULL) { + ADM_LOG_ERR("Audio input param is NULL."); return HDF_ERR_INVALID_OBJECT; } - mixerCtrl = (struct AudioMixerControl *)((volatile uintptr_t)kcontrol->privateValue); - if (AudioSetCtrlOpsReg(kcontrol, elemValue, mixerCtrl, &value) != HDF_SUCCESS) { - ADM_LOG_ERR("AudioSetCtrlOpsReg fail."); + dai = AudioKcontrolGetCpuDai(kcontrol); + if (mixerCtrl == NULL || dai == NULL) { + ADM_LOG_ERR("mixerCtrl and codec is NULL."); return HDF_FAILURE; } - - accessory = AudioKcontrolGetAccessory(kcontrol); - if (AudioUpdateAccessoryAiaoRegBits(accessory, mixerCtrl, value) != HDF_SUCCESS) { - ADM_LOG_ERR("Audio accessory aiao stereo update reg bits fail."); + if (AudioDaiReadReg(dai, mixerCtrl->reg, &curValue) != HDF_SUCCESS || + AudioDaiReadReg(dai, mixerCtrl->rreg, &rcurValue) != HDF_SUCCESS) { + ADM_LOG_ERR("Read Reg fail."); return HDF_FAILURE; } - - if (AudioSetCtrlOpsRReg(elemValue, mixerCtrl, &rvalue, &updateRReg) != HDF_SUCCESS) { - ADM_LOG_ERR("AudioSetCtrlOpsRReg fail."); + if (AudioGetCtrlOpsReg(elemValue, mixerCtrl, curValue) != HDF_SUCCESS || + AudioGetCtrlOpsRReg(elemValue, mixerCtrl, rcurValue) != HDF_SUCCESS) { + ADM_LOG_ERR("Audio codec get kcontrol reg and rreg fail."); return HDF_FAILURE; } - if (updateRReg) { - if (AudioUpdateAccessoryAiaoRegBits(accessory, mixerCtrl, rvalue) != HDF_SUCCESS) { - ADM_LOG_ERR("Audio accessory aiao stereo update reg bits fail."); - return HDF_FAILURE; - } - } - return HDF_SUCCESS; } + diff --git a/model/audio/core/src/audio_host.c b/model/audio/core/src/audio_host.c index 61c2434c3cbd7a8619258f2004fb3a340371e5ba..7e426e9727e3a88985bdc3a555c69e19cffd1dc6 100755 --- a/model/audio/core/src/audio_host.c +++ b/model/audio/core/src/audio_host.c @@ -9,6 +9,8 @@ #include "audio_host.h" #include "audio_codec_if.h" #include "audio_core.h" +#include "audio_sapm.h" +#include "audio_driver_log.h" #include "audio_parse.h" #define HDF_LOG_TAG audio_host @@ -40,6 +42,7 @@ struct AudioCard *GetCardInstance(const char *serviceName) return audioCard; } } + ADM_LOG_ERR("serviceName is %s.", serviceName); return NULL; } @@ -162,7 +165,7 @@ static int32_t AudioDspDevInit(const struct AudioCard *audioCard) return HDF_SUCCESS; } -static int32_t AudioCodecDaiDevInit(const struct AudioCard *audioCard) +static int32_t AudioCodecDaiDevInit(struct AudioCard *audioCard) { struct AudioRuntimeDeivces *rtd = NULL; struct DaiDevice *codecDai = NULL; @@ -192,7 +195,7 @@ static int32_t AudioCodecDaiDevInit(const struct AudioCard *audioCard) return HDF_SUCCESS; } -static int32_t AudioAccessoryDaiDevInit(const struct AudioCard *audioCard) +static int32_t AudioAccessoryDaiDevInit(struct AudioCard *audioCard) { struct AudioRuntimeDeivces *rtd = NULL; struct DaiDevice *accessoryDai = NULL; @@ -222,7 +225,7 @@ static int32_t AudioAccessoryDaiDevInit(const struct AudioCard *audioCard) return HDF_SUCCESS; } -static int32_t AudioCpuDaiDevInit(const struct AudioCard *audioCard) +static int32_t AudioCpuDaiDevInit(struct AudioCard *audioCard) { struct AudioRuntimeDeivces *rtd = NULL; struct DaiDevice *cpuDai = NULL; @@ -252,11 +255,11 @@ static int32_t AudioCpuDaiDevInit(const struct AudioCard *audioCard) return HDF_SUCCESS; } -static int32_t AudioDspDaiDevInit(const struct AudioCard *audioCard) +static int32_t AudioDspDaiDevInit(struct AudioCard *audioCard) { struct AudioRuntimeDeivces *rtd = NULL; struct DaiDevice *dspDai = NULL; - int ret; + int ret = HDF_SUCCESS; if (audioCard == NULL) { ADM_LOG_ERR("audioCard is NULL."); @@ -293,22 +296,18 @@ static int32_t AudioInitDaiLink(struct AudioCard *audioCard) if (AudioPlatformDevInit(audioCard) || AudioCpuDaiDevInit(audioCard)) { ADM_LOG_ERR("Platform and CpuDai init fail."); - return HDF_ERR_IO; } if ((AudioCodecDevInit(audioCard) || AudioCodecDaiDevInit(audioCard))) { - ADM_LOG_ERR("codec init fail."); - return HDF_ERR_IO; + ADM_LOG_ERR("codec Device init fail."); } if (AudioAccessoryDevInit(audioCard) || AudioAccessoryDaiDevInit(audioCard)) { - ADM_LOG_ERR("Accessory init fail."); - return HDF_ERR_IO; + ADM_LOG_ERR("Accessory Device init fail."); } if (AudioDspDevInit(audioCard) || AudioDspDaiDevInit(audioCard)) { - ADM_LOG_ERR("Dsp Dai init fail."); - return HDF_ERR_IO; + ADM_LOG_ERR("Dsp Device init fail."); } ADM_LOG_DEBUG("success."); @@ -366,7 +365,7 @@ static int32_t AudioDriverInit(struct HdfDeviceObject *device) ADM_LOG_ERR("device is NULL."); return HDF_ERR_INVALID_OBJECT; } - audioHost = AudioHostFromDevice(device); + audioHost = (struct AudioHost *)device->service; if (audioHost == NULL) { ADM_LOG_ERR("audioHost is NULL."); return HDF_FAILURE; @@ -385,9 +384,15 @@ static int32_t AudioDriverInit(struct HdfDeviceObject *device) return HDF_ERR_IO; } + audioCard->standbyMode = AUDIO_SAPM_TURN_STANDBY_LATER; + /* Bind specific codecã€platform and dai device */ - AudioBindDaiLink(audioCard, &(audioCard->configData)); - if (!audioCard->rtd->complete) { + ret = AudioBindDaiLink(audioCard, &(audioCard->configData)); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("AudioBindDaiLink fail ret=%d", ret); + return HDF_FAILURE; + } + if (audioCard->rtd == NULL || (!audioCard->rtd->complete)) { ADM_LOG_ERR("AudioBindDaiLink fail!"); return HDF_ERR_IO; } @@ -415,13 +420,19 @@ static void AudioDriverRelease(struct HdfDeviceObject *device) { struct AudioHost *audioHost = NULL; struct AudioCard *audioCard = NULL; + struct DListHead *componentHead = NULL; + struct DListHead *controlHead = NULL; + struct AudioSapmComponent *componentReq = NULL; + struct AudioSapmComponent *componentTmp = NULL; + struct AudioKcontrol *ctrlReq = NULL; + struct AudioKcontrol *ctrlTmp = NULL; ADM_LOG_DEBUG("entry."); if (device == NULL) { ADM_LOG_ERR("device is NULL."); return; } - audioHost = AudioHostFromDevice(device); + audioHost = (struct AudioHost *)device->service; if (audioHost == NULL) { ADM_LOG_ERR("audioHost is NULL."); return; @@ -429,9 +440,32 @@ static void AudioDriverRelease(struct HdfDeviceObject *device) if (audioHost->priv != NULL) { audioCard = (struct AudioCard *)audioHost->priv; - if (audioCard->rtd != NULL) { - OsalMemFree(audioCard->rtd); + + componentHead = &audioCard->components; + DLIST_FOR_EACH_ENTRY_SAFE(componentReq, componentTmp, componentHead, struct AudioSapmComponent, list) { + DListRemove(&componentReq->list); + if (componentReq->componentName != NULL) { + OsalMemFree(componentReq->componentName); } + OsalMemFree(componentReq); + } + + controlHead = &audioCard->controls; + DLIST_FOR_EACH_ENTRY_SAFE(ctrlReq, ctrlTmp, controlHead, struct AudioKcontrol, list) { + DListRemove(&ctrlReq->list); + if (ctrlReq->pri != NULL) { + OsalMemFree(ctrlReq->pri); + } + if (ctrlReq->privateData != NULL) { + OsalMemFree(ctrlReq->privateData); + } + OsalMemFree(ctrlReq); + } + + if (audioCard->rtd != NULL) { + OsalMemFree(audioCard->rtd); + } + OsalMemFree(audioHost->priv); } OsalMemFree(audioHost); diff --git a/model/audio/core/src/audio_parse.c b/model/audio/core/src/audio_parse.c index b483b3c0b3fc1f329fb2caab4ed23212e8f8ce82..245140705351d996bc33714dad3eb77ccc0aa087 100755 --- a/model/audio/core/src/audio_parse.c +++ b/model/audio/core/src/audio_parse.c @@ -7,9 +7,62 @@ */ #include "audio_parse.h" +#include "audio_driver_log.h" #define HDF_LOG_TAG audio_parse +enum AudioRegCfgIndex { + AUDIO_REG_CFG_REG_INDEX = 0, + AUDIO_REG_CFG_RREG_INDEX, + AUDIO_REG_CFG_SHIFT_INDEX, + AUDIO_REG_CFG_RSHIFT_INDEX, + AUDIO_REG_CFG_MIN_INDEX, + AUDIO_REG_CFG_MAX_INDEX, + AUDIO_REG_CFG_MASK_INDEX, + AUDIO_REG_CFG_INVERT_INDEX, + AUDIO_REG_CFG_VALUE_INDEX, + AUDIO_REG_CFG_INDEX_MAX +}; + +enum AudioAddrCfgIndex { + AUDIO_ADDR_CFG_REG_INDEX = 0, + AUDIO_ADDR_CFG_VALUE_INDEX, + AUDIO_ADDR_CFG_INDEX_MAX +}; + +enum AudioCrtlCfgIndex { + AUDIO_CTRL_CFG_INDEX_INDEX = 0, + AUDIO_CTRL_CFG_IFACE_INDEX, + AUDIO_CTRL_CFG_ENABLE_INDEX, + AUDIO_CTRL_CFG_INDEX_MAX +}; + +enum AudioSapmComponentIndex { + AUDIO_SAPM_COMP_INDEX_TYPE = 0, + AUDIO_SAPM_COMP_INDEX_NAME, + AUDIO_SAPM_COMP_INDEX_REG, + AUDIO_SAPM_COMP_INDEX_MASK, + AUDIO_SAPM_COMP_INDEX_SHIFT, + AUDIO_SAPM_COMP_INDEX_INVERT, + AUDIO_SAPM_COMP_INDEX_KCTL, + AUDIO_SAPM_COMP_INDEX_KCTLNUM, + AUDIO_SAPM_COMP_INDEX_MAX +}; + + +static char *g_audioRegGroupName[AUDIO_GROUP_MAX] = { + "resetSeqConfig", + "initSeqConfig", + "ctrlParamsSeqConfig", + "ctrlSapmParamsSeqConfig", + "daiStartupSeqConfig", + "daiParamsSeqConfig", + "daiTriggerSeqConfig", + "controlsConfig", + "sapmComponent", + "sapmConfig" +}; + int32_t AudioFillConfigData(const struct HdfDeviceObject *device, struct AudioConfigData *configData) { const struct DeviceResourceNode *node = NULL; @@ -58,3 +111,370 @@ int32_t AudioFillConfigData(const struct HdfDeviceObject *device, struct AudioCo return HDF_SUCCESS; } + +static uint32_t GetAudioRegGroupNameIndex(const char *name) +{ + uint32_t index; + + if (name == NULL) { + return AUDIO_GROUP_MAX; + } + + for (index = 0; index < AUDIO_GROUP_MAX; ++index) { + if ((g_audioRegGroupName[index] != NULL) && (strcmp(name, g_audioRegGroupName[index]) == 0)) { + break; + } + } + + return index; +} + +static uint32_t* GetRegArray(const struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode, + struct AudioRegCfgGroupNode* group, uint32_t indexMax) +{ + int32_t ret; + + if (group == NULL || parser == NULL || regNode == NULL || indexMax == 0) { + ADM_LOG_ERR("Input para check error"); + return NULL; + } + + int32_t index = group->groupIndex; + if (index >= AUDIO_GROUP_MAX) { + ADM_LOG_ERR("Input indexMax=%d error", index); + return NULL; + } + + int32_t num = parser->GetElemNum(regNode, g_audioRegGroupName[index]); + if (num <= 0 || num > AUDIO_CONFIG_MAX_ITEM) { + ADM_LOG_ERR("parser %s element num failed", g_audioRegGroupName[index]); + return NULL; + } + + group->itemNum = num / indexMax; + + uint32_t *buf = (uint32_t *)OsalMemCalloc(sizeof(uint32_t) * num); + if (buf == NULL) { + ADM_LOG_ERR("malloc reg array buf failed!"); + return NULL; + } + + ret = parser->GetUint32Array(regNode, g_audioRegGroupName[index], buf, num, 0); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("parser %s reg array failed", g_audioRegGroupName[index]); + OsalMemFree(buf); + return NULL; + } + return buf; +} + +static int32_t ParseAudioRegItem(const struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode, + struct AudioRegCfgGroupNode* group) +{ + int32_t step; + int32_t index; + + if (group == NULL || parser == NULL || regNode == NULL) { + ADM_LOG_ERR("Input para check error"); + return HDF_FAILURE; + } + + int32_t *buf = GetRegArray(parser, regNode, group, AUDIO_REG_CFG_INDEX_MAX); + if (buf == NULL) { + ADM_LOG_ERR("malloc reg array buf failed!"); + return HDF_FAILURE; + } + + group->regCfgItem = + (struct AudioMixerControl*)OsalMemCalloc(group->itemNum * sizeof(*(group->regCfgItem))); + if (group->regCfgItem == NULL) { + OsalMemFree(buf); + ADM_LOG_ERR("malloc audio reg config item failed!"); + return HDF_ERR_MALLOC_FAIL; + } + + for (index = 0; index < group->itemNum; ++index) { + step = AUDIO_REG_CFG_INDEX_MAX * index; + + group->regCfgItem[index].reg = buf[step + AUDIO_REG_CFG_REG_INDEX]; + group->regCfgItem[index].rreg = buf[step + AUDIO_REG_CFG_RREG_INDEX]; + group->regCfgItem[index].shift = buf[step + AUDIO_REG_CFG_SHIFT_INDEX]; + group->regCfgItem[index].rshift = buf[step + AUDIO_REG_CFG_RSHIFT_INDEX]; + group->regCfgItem[index].min = buf[step + AUDIO_REG_CFG_MIN_INDEX]; + group->regCfgItem[index].max = buf[step + AUDIO_REG_CFG_MAX_INDEX]; + group->regCfgItem[index].mask = buf[step + AUDIO_REG_CFG_MASK_INDEX]; + group->regCfgItem[index].invert = buf[step + AUDIO_REG_CFG_INVERT_INDEX]; + group->regCfgItem[index].value = buf[step + AUDIO_REG_CFG_VALUE_INDEX]; + } + OsalMemFree(buf); + + return HDF_SUCCESS; +} + +static int32_t ParseAudioSapmItem(const struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode, + struct AudioRegCfgGroupNode* group) +{ + int32_t step; + int32_t index; + + if (group == NULL || parser == NULL || regNode == NULL) { + ADM_LOG_ERR("Input para check error"); + return HDF_FAILURE; + } + + uint32_t *buf = GetRegArray(parser, regNode, group, AUDIO_SAPM_COMP_INDEX_MAX); + if (buf == NULL) { + ADM_LOG_ERR("malloc reg array buf failed!"); + return HDF_FAILURE; + } + + group->sapmCompItem = + (struct AudioSapmCtrlConfig*)OsalMemCalloc(group->itemNum * sizeof(*(group->sapmCompItem))); + if (group->sapmCompItem == NULL) { + OsalMemFree(buf); + ADM_LOG_ERR("malloc audio reg config item failed!"); + return HDF_ERR_MALLOC_FAIL; + } + + for (index = 0; index < group->itemNum; ++index) { + step = AUDIO_SAPM_COMP_INDEX_MAX * index; + group->sapmCompItem[index].sapmType = buf[step + AUDIO_SAPM_COMP_INDEX_TYPE]; + group->sapmCompItem[index].compNameIndex = buf[step + AUDIO_SAPM_COMP_INDEX_NAME]; + group->sapmCompItem[index].reg = buf[step + AUDIO_SAPM_COMP_INDEX_REG]; + group->sapmCompItem[index].mask = buf[step + AUDIO_SAPM_COMP_INDEX_MASK]; + group->sapmCompItem[index].shift = buf[step + AUDIO_SAPM_COMP_INDEX_SHIFT]; + group->sapmCompItem[index].invert = buf[step + AUDIO_SAPM_COMP_INDEX_INVERT]; + group->sapmCompItem[index].kcontrolNews = buf[step + AUDIO_SAPM_COMP_INDEX_KCTL]; + group->sapmCompItem[index].kcontrolsNum = buf[step + AUDIO_SAPM_COMP_INDEX_KCTLNUM]; + } + + OsalMemFree(buf); + return HDF_SUCCESS; +} + + +static int32_t ParseAudioCtrlItem(const struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode, + struct AudioRegCfgGroupNode* group) +{ + int32_t step; + int32_t index; + + if (parser == NULL || regNode == NULL || group == NULL) { + ADM_LOG_ERR("Input para check error"); + return HDF_FAILURE; + } + + uint32_t *buf = GetRegArray(parser, regNode, group, AUDIO_CTRL_CFG_INDEX_MAX); + if (buf == NULL) { + ADM_LOG_ERR("malloc reg array buf failed!"); + return HDF_FAILURE; + } + + group->ctrlCfgItem = + (struct AudioControlConfig*)OsalMemCalloc(group->itemNum * sizeof(*(group->ctrlCfgItem))); + if (group->ctrlCfgItem == NULL) { + OsalMemFree(buf); + ADM_LOG_ERR("malloc audio ctrl config item failed!"); + return HDF_ERR_MALLOC_FAIL; + } + + for (index = 0; index < group->itemNum; ++index) { + step = AUDIO_CTRL_CFG_INDEX_MAX * index; + + group->ctrlCfgItem[index].arrayIndex = buf[step + AUDIO_CTRL_CFG_INDEX_INDEX]; + group->ctrlCfgItem[index].iface = buf[step + AUDIO_CTRL_CFG_IFACE_INDEX]; + group->ctrlCfgItem[index].enable = buf[step + AUDIO_CTRL_CFG_ENABLE_INDEX]; + } + OsalMemFree(buf); + return HDF_SUCCESS; +} + +static int32_t ParseAudioAddrItem(const struct DeviceResourceIface *parser, const struct DeviceResourceNode *regNode, + struct AudioRegCfgGroupNode* group) +{ + int32_t step; + int32_t index; + + if (parser == NULL || regNode == NULL || group == NULL) { + ADM_LOG_ERR("Input para check error."); + return HDF_FAILURE; + } + + uint32_t *buf = GetRegArray(parser, regNode, group, AUDIO_ADDR_CFG_INDEX_MAX); + if (buf == NULL) { + ADM_LOG_ERR("malloc reg array buf failed!"); + return HDF_FAILURE; + } + + group->addrCfgItem = (struct AudioAddrConfig*)OsalMemCalloc(group->itemNum * sizeof(*(group->addrCfgItem))); + if (group->addrCfgItem == NULL) { + OsalMemFree(buf); + ADM_LOG_ERR("malloc audio addr config item failed!"); + return HDF_ERR_MALLOC_FAIL; + } + + for (index = 0; index < group->itemNum; ++index) { + step = AUDIO_ADDR_CFG_INDEX_MAX * index; + group->addrCfgItem[index].addr = buf[step + AUDIO_ADDR_CFG_REG_INDEX]; + group->addrCfgItem[index].value = buf[step + AUDIO_ADDR_CFG_VALUE_INDEX]; + } + OsalMemFree(buf); + return HDF_SUCCESS; +} + +static int32_t ParseAudioRegGroup(const struct DeviceResourceIface *parser, + const struct DeviceResourceNode *regCfgNode, struct AudioRegCfgGroupNode **groupNode, uint32_t index) +{ + int32_t ret = HDF_FAILURE; + struct AudioRegCfgGroupNode *group = NULL; + + if (parser == NULL || regCfgNode == NULL || groupNode == NULL) { + ADM_LOG_ERR("Input para check error: parser=%p, regCfgNode=%p, groupNode=%p.", + parser, regCfgNode, groupNode); + return HDF_FAILURE; + } + + group = (struct AudioRegCfgGroupNode*)OsalMemCalloc(sizeof(*group)); + if (group == NULL) { + ADM_LOG_ERR("malloc audio reg config group failed"); + return HDF_ERR_MALLOC_FAIL; + } + *groupNode = group; + (*groupNode)->groupIndex = index; + + switch (index) { + case AUDIO_CTRL_CFG_GROUP: + case AUDIO_SAPM_CFG_GROUP: + ret = ParseAudioCtrlItem(parser, regCfgNode, group); + break; + case AUDIO_RSET_GROUP: + case AUDIO_INIT_GROUP: + ret = ParseAudioAddrItem(parser, regCfgNode, group); + break; + case AUDIO_DAI_PATAM_GROUP: + case AUDIO_DAI_TRIGGER_GROUP: + case AUDIO_CTRL_PATAM_GROUP: + case AUDIO_CTRL_SAPM_PATAM_GROUP: + case AUDIO_DAI_STARTUP_PATAM_GROUP: + ret = ParseAudioRegItem(parser, regCfgNode, group); + break; + case AUDIO_SAPM_COMP_GROUP: + ret = ParseAudioSapmItem(parser, regCfgNode, group); + break; + default: + ADM_LOG_ERR("parse audio config index = %d not found!", index); + return HDF_FAILURE; + } + + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("parse audio config item failed!"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static void ReleaseAudioAllRegConfig(struct AudioRegCfgData *config) +{ + int32_t index; + + if (config == NULL) { + return; + } + + for (index = 0; index < AUDIO_GROUP_MAX; ++index) { + if (config->audioRegParams[index] != NULL) { + if (config->audioRegParams[index]->regCfgItem != NULL) { + OsalMemFree(config->audioRegParams[index]->regCfgItem); + config->audioRegParams[index]->regCfgItem = NULL; + } + OsalMemFree(config->audioRegParams[index]); + config->audioRegParams[index] = NULL; + } + } +} + +static int32_t ParseAudioAttr(const struct DeviceResourceIface *parser, const struct DeviceResourceNode *attrNode, + struct AudioIdInfo *config) +{ + int32_t ret; + ret = parser->GetString(attrNode, "chipName", &config->chipName, NULL); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("parser chipName reg audioIdInfo failed!"); + return HDF_SUCCESS; + } + + ret = parser->GetUint32(attrNode, "chipIdRegister", &config->chipIdRegister, 0); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("parser chipIdRegister reg audioIdInfo failed!"); + return HDF_SUCCESS; + } + + ret = parser->GetUint32(attrNode, "chipIdSize", &config->chipIdSize, 0); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("parser chipIdSize reg audioIdInfo failed!"); + return HDF_SUCCESS; + } + return ret; +} + +int32_t CodecGetRegConfig(const struct HdfDeviceObject *device, struct AudioRegCfgData *configData) +{ + uint16_t index; + const struct DeviceResourceNode *root = NULL; + const struct DeviceResourceNode *regCfgNode = NULL; + const struct DeviceResourceAttr *regAttr = NULL; + const struct DeviceResourceNode *idNode = NULL; + struct DeviceResourceIface *drsOps = NULL; + + ADM_LOG_DEBUG("Entry."); + + if (device == NULL || configData == NULL) { + ADM_LOG_ERR("Input para check error: device=%p, configData=%p.", device, configData); + return HDF_FAILURE; + } + + root = device->property; + if (root == NULL) { + ADM_LOG_ERR("drs node is NULL."); + return HDF_FAILURE; + } + + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + ADM_LOG_ERR("AudioFillConfigData: invalid drs ops fail!"); + return HDF_FAILURE; + } + + idNode = drsOps->GetChildNode(root, "idInfo"); + if (idNode != NULL) { + if (ParseAudioAttr(drsOps, idNode, &configData->audioIdInfo) != HDF_SUCCESS) { + ADM_LOG_ERR("audio reg node attr is null"); + return HDF_FAILURE; + } + } + + regCfgNode = drsOps->GetChildNode(root, "regConfig"); + if (regCfgNode == NULL) { + ADM_LOG_ERR("CodecGetRegConfig: Read audioRegConfig fail!"); + return HDF_FAILURE; + } + + DEV_RES_NODE_FOR_EACH_ATTR(regCfgNode, regAttr) { + if (regAttr == NULL || regAttr->name == NULL) { + ADM_LOG_ERR("audio reg node attr is null"); + return HDF_FAILURE; + } + + index = GetAudioRegGroupNameIndex(regAttr->name); + if (index >= AUDIO_GROUP_MAX) { + continue; + } + + if (ParseAudioRegGroup(drsOps, regCfgNode, &configData->audioRegParams[index], index) != HDF_SUCCESS) { + ADM_LOG_ERR("parse audio register group failed"); + ReleaseAudioAllRegConfig(configData); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} diff --git a/model/audio/core/test/unittest/common/audio_common_test.h b/model/audio/core/test/unittest/common/audio_common_test.h index 74f213f15efc9be3adc311d3a2d6dc6d6d4f48c3..8b88a63ab99255e17eb827098800ce08e236d41f 100755 --- a/model/audio/core/test/unittest/common/audio_common_test.h +++ b/model/audio/core/test/unittest/common/audio_common_test.h @@ -14,49 +14,56 @@ const int32_t g_testAudioType = 701; // 701 is TEST_AUDIO_TYPE enum { - TESTGETCODEC, - TESTGETCARDINSTANCE, - TESTGETCCNFIGDATA, - - TESTREGISTERPLATFORM, - TESTREGISTERDAI, - TESTREGISTERACCESSORY, - TESTREGISTERCODEC, - TESTREGISTERDSP, - TESTSOCDEVICEREGISTER, - TESTBINDDAILINK, - TESTUPDATECODECREGBITS, - TESTUPDATEACCESSORYREGBITS, - TESTUPDATECODECAIAOREGBITS, - TESTUPDATEACCESSORYAIAOREGBITS, - TESTKCONTROLGETCODEC, - TESTKCONTROLGETACCESSORY, - TESTADDCONTROL, - TESTADDCONTROLS, - TESTCODECREADREG, - TESTACCESSORYREADREG, - TESTCODECAIAOREADREG, - TESTACCESSORYAIAOREADREG, - TESTCODECWRITEREG, - TESTACCESSORYWRITEREG, - TESTCODECAIAOWRITEREG, - TESTACCESSORYAIAOWRITEREG, - TESTINFOCTRLOPS, - TESTCODECGETCTRLOPS, - TESTACCESSORYGETCTRLOPS, - TESTCODECAIAOGETCTRLOPS, - TESTACCESSORYAIAOGETCTRLOPS, - TESTCODECSETCTRLOPS, - TESTACCESSORYSETCTRLOPS, - TESTCODECAIAOSETCTRLOPS, - TESTACCESSORYAIAOSETCTRLOPS, - - TESTNEWCOMPONENT, - TESTADDROUTES, - TESTNEWCONTROLS, - TESTPOWERCOMPONET, - TESTREFRESHTIME, - TESTSTREAMDISPATCH, + TEST_AUDIOHOSTCREATEANDBIND = 1, // audio ADM audio_host + TEST_GETCARDINSTANCE = 2, // audio ADM audio_host + + TEST_AUDIOFILLCONFIGDATA = 3, // audio ADM audio_parse + TEST_CODECGETREGCONFIG = 4, // audio ADM audio_parse + + TEST_AUDIODEVICEREADREG = 5, // audio ADM audio_core + TEST_AUDIODEVICEWRITEREG, // audio ADM audio_core + TEST_AUDIOSOCREGISTERPLATFORM, // audio ADM audio_core + TEST_AUDIOSOCREGISTERDAI, // audio ADM audio_core + TEST_AUDIOREGISTERDSP, // audio ADM audio_core + TEST_AUDIOREGISTERCODEC, // audio ADM audio_core + TEST_AUDIOREGISTERACCESSORY, // audio ADM audio_core + TEST_AUDIOBINDDAILINK, // audio ADM audio_core + TEST_AUDIOUPDATECODECREGBITS, // audio ADM audio_core + TEST_AUDIOUPDATEACCESSORYREGBITS, // audio ADM audio_core + TEST_AUDIOUPDATEDAIREGBITS, // audio ADM audio_core + TEST_AUDIOKCONTROLGETCPUDAI, // audio ADM audio_core + TEST_AUDIOKCONTROLGETCODEC, // audio ADM audio_core + TEST_AUDIOKCONTROLGETACCESSORY, // audio ADM audio_core + TEST_AUDIOADDCONTROLS, // audio ADM audio_core + TEST_AUDIOADDCONTROL, // audio ADM audio_core + TEST_AUDIOGETCTRLOPSRREG, // audio ADM audio_core + TEST_AUDIOGETCTRLOPSREG, // audio ADM audio_core + TEST_AUDIOSETCTRLOPSREG, // audio ADM audio_core + TEST_AUDIOSETCTRLOPSRREG, // audio ADM audio_core + TEST_AUDIODAIREADREG, // audio ADM audio_core + TEST_AUDIODAIWRITEREG, // audio ADM audio_core + TEST_AUDIOCODECREADREG, // audio ADM audio_core + TEST_AUDIOCODECWRITEREG, // audio ADM audio_core + TEST_AUDIOACCESSORYREADREG, // audio ADM audio_core + TEST_AUDIOACCESSORYWRITEREG, // audio ADM audio_core + TEST_AUDIOINFOCTRLOPS, // audio ADM audio_core + TEST_AUDIOCODECGETCTRLOPS, // audio ADM audio_core + TEST_AUDIOCODECSETCTRLOPS, // audio ADM audio_core + TEST_AUDIOACCESSORYGETCTRLOPS, // audio ADM audio_core + TEST_AUDIOACCESSORYSETCTRLOPS, // audio ADM audio_core + TEST_AUDIOCPUDAISETCTRLOPS, // audio ADM audio_core + TEST_AUDIOCPUDAIGETCTRLOPS = 37, // audio ADM audio_core + + TEST_AUDIOSAPMNEWCOMPONENTS = 38, // audio ADM audio_sapm + TEST_AUDIOSAPMADDROUTES, // audio ADM audio_sapm + TEST_AUDIOSAPMNEWCONTROLS, // audio ADM audio_sapm + TEST_AUDIOSAPMSLEEP, // audio ADM audio_sapm + TEST_AUDIOSAMPPOWERUP, // audio ADM audio_sapm + TEST_AUDIOSAMPSETPOWERMONITOR, // audio ADM audio_sapm + TEST_AUDIOCODECSAPMSETCTRLOPS, // audio ADM audio_sapm + TEST_AUDIOCODECSAPMGETCTRLOPS, // audio ADM audio_sapm + TEST_AUDIOACCESSORYSAPMSETCTRLOPS, // audio ADM audio_sapm + TEST_AUDIOACCESSORYSAPMGETCTRLOPS = 47, // audio ADM audio_sapm }; #endif /* AUDIO_COMMON_TEST_H */ diff --git a/model/audio/core/test/unittest/common/audio_core_test.cpp b/model/audio/core/test/unittest/common/audio_core_test.cpp index 91f8f7900a11b3e70f40f53bb33a25e6333f0059..349feaeb20425069e5f0c6780a54dd32a6446a84 100755 --- a/model/audio/core/test/unittest/common/audio_core_test.cpp +++ b/model/audio/core/test/unittest/common/audio_core_test.cpp @@ -38,195 +38,201 @@ void AudioCoreTest::TearDown() { } -HWTEST_F(AudioCoreTest, AudioCoreTest_RegisterPlatform, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioDeviceReadReg, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTREGISTERPLATFORM, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIODEVICEREADREG, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_RegisterDai, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioDeviceWriteReg, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTREGISTERDAI, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIODEVICEWRITEREG, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_RegisterAccessory, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioSocRegisterPlatform, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTREGISTERACCESSORY, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOSOCREGISTERPLATFORM, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_RegisterCodec, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioSocRegisterDai, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTREGISTERCODEC, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOSOCREGISTERDAI, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_SocRegisterDsp, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioRegisterDsp, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTREGISTERDSP, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOREGISTERDSP, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_SocDeviceRegister, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioRegisterCodec, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTSOCDEVICEREGISTER, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOREGISTERCODEC, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_BindDaiLink, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioRegisterAccessory, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTBINDDAILINK, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOREGISTERACCESSORY, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_UpdateCodecRegBits, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioBindDaiLink, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTUPDATECODECREGBITS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOBINDDAILINK, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_UpdateAccessoryRegBits, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioUpdateCodecRegBits, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTUPDATEACCESSORYREGBITS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOUPDATECODECREGBITS, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_UpdateCodecAiaoRegBits, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioUpdateAccessoryRegBits, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTUPDATECODECAIAOREGBITS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOUPDATEACCESSORYREGBITS, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_UpdateAccessoryAiaoRegBits, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioUpdateDaiRegBits, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTUPDATEACCESSORYAIAOREGBITS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOUPDATEDAIREGBITS, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_KcontrolGetCodec, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioKcontrolGetCpuDai, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTKCONTROLGETCODEC, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOKCONTROLGETCPUDAI, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_KcontrolGetAccessory, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioKcontrolGetCodec, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTKCONTROLGETACCESSORY, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOKCONTROLGETCODEC, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_AddControl, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioKcontrolGetAccessory, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTADDCONTROL, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOKCONTROLGETACCESSORY, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_AddControls, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioAddControls, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTADDCONTROLS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOADDCONTROLS, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_CodecReadReg, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioAddControl, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTCODECREADREG, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOADDCONTROL, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_AccessoryReadReg, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioGetCtrlOpsRReg, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTACCESSORYREADREG, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOGETCTRLOPSRREG, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_CodecAiaoReadReg, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioGetCtrlOpsReg, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTCODECAIAOREADREG, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOGETCTRLOPSREG, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_AccessoryAiaoReadReg, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioSetCtrlOpsReg, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTACCESSORYAIAOREADREG, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOSETCTRLOPSREG, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_CodecWriteReg, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioSetCtrlOpsRReg, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTCODECWRITEREG, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOSETCTRLOPSRREG, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_AccessoryWriteReg, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioDaiReadReg, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTACCESSORYWRITEREG, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIODAIREADREG, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_CodecAiaoWriteReg, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioDaiWriteReg, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTCODECAIAOWRITEREG, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIODAIWRITEREG, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_AccessoryAiaoWriteReg, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioCodecReadReg, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTACCESSORYAIAOWRITEREG, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOCODECREADREG, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_InfoCtrlOps, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioCodecWriteReg, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTINFOCTRLOPS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOCODECWRITEREG, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_CodecGetCtrlOps, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioAccessoryReadReg, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTCODECGETCTRLOPS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOACCESSORYREADREG, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_AccessoryGetCtrlOps, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioAccessoryWriteReg, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTACCESSORYGETCTRLOPS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOACCESSORYWRITEREG, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_CodecAiaoGetCtrlOps, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioInfoCtrlOps, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTCODECAIAOGETCTRLOPS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOINFOCTRLOPS, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_AccessoryAiaoGetCtrlOps, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioCodecGetCtrlOps, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTACCESSORYAIAOGETCTRLOPS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOCODECGETCTRLOPS, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_CodecSetCtrlOps, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioCodecSetCtrlOps, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTCODECSETCTRLOPS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOCODECSETCTRLOPS, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_AccessorySetCtrlOps, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioAccessoryGetCtrlOps, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTACCESSORYSETCTRLOPS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOACCESSORYGETCTRLOPS, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_CodecAiaoSetCtrlOps, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioAccessorySetCtrlOpsTset, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTCODECAIAOSETCTRLOPS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOACCESSORYSETCTRLOPS, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioCoreTest, AudioCoreTest_AccessoryAiaoSetCtrlOps, TestSize.Level0) +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioCpuDaiSetCtrlOps, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTACCESSORYAIAOSETCTRLOPS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOCPUDAISETCTRLOPS, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioCoreTest, AudioCoreTest_AudioCpuDaiGetCtrlOps, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOCPUDAIGETCTRLOPS, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } } diff --git a/model/audio/core/test/unittest/common/audio_host_test.cpp b/model/audio/core/test/unittest/common/audio_host_test.cpp index 6632edb9a58cdf3e970428e231f97aa59db8e79b..56b405a1ec0118eb4f915e1ec07dec0527ad98cd 100755 --- a/model/audio/core/test/unittest/common/audio_host_test.cpp +++ b/model/audio/core/test/unittest/common/audio_host_test.cpp @@ -39,15 +39,15 @@ void AudioHostTest::TearDown() { } -HWTEST_F(AudioHostTest, AudioHostTest_GetCodec, TestSize.Level0) +HWTEST_F(AudioHostTest, AudioHostTest_AudioHostCreateAndBind, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTGETCODEC, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOHOSTCREATEANDBIND, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioHostTest, AudioHostTest_GetAudioServiceName, TestSize.Level0) +HWTEST_F(AudioHostTest, AudioHostTest_GetCardInstance, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTGETCARDINSTANCE, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_GETCARDINSTANCE, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } } diff --git a/model/audio/core/test/unittest/common/audio_parse_test.cpp b/model/audio/core/test/unittest/common/audio_parse_test.cpp index 6b612d03a797fdd6e9103be128b94b2df82c223d..2df866aac4c85745fe43956a82935fa276a81092 100755 --- a/model/audio/core/test/unittest/common/audio_parse_test.cpp +++ b/model/audio/core/test/unittest/common/audio_parse_test.cpp @@ -39,9 +39,15 @@ void AudioParseTest::TearDown() { } -HWTEST_F(AudioParseTest, AudioParseTest_GetConfigData, TestSize.Level0) +HWTEST_F(AudioParseTest, AudioParseTest_AudioFillConfigData, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTGETCCNFIGDATA, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOFILLCONFIGDATA, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioParseTest, AudioParseTest_CodecGetRegConfig, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TEST_CODECGETREGCONFIG, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } } diff --git a/model/audio/dispatch/include/audio_control_dispatch.h b/model/audio/dispatch/include/audio_control_dispatch.h index 2d3959316440652bb4535aceb4148b08efbd817b..ec979a667ad78335e252fd8034b5f7fe6eff09ea 100755 --- a/model/audio/dispatch/include/audio_control_dispatch.h +++ b/model/audio/dispatch/include/audio_control_dispatch.h @@ -17,9 +17,6 @@ extern "C" { #endif #endif /* __cplusplus */ - -#define AUDIODRV_CTRL_ELEM_TYPE_INTEGER 2 /* integer type */ - enum ControlDispMethodCmd { AUDIODRV_CTRL_IOCTRL_ELEM_INFO, AUDIODRV_CTRL_IOCTRL_ELEM_READ, @@ -27,12 +24,9 @@ enum ControlDispMethodCmd { AUDIODRV_CTRL_IOCTRL_ELEM_BUTT, }; -typedef int32_t (*ControlDispCmdHandle)(const struct HdfDeviceIoClient *client, - struct HdfSBuf *data, struct HdfSBuf *reply); - struct ControlDispCmdHandleList { enum ControlDispMethodCmd cmd; - ControlDispCmdHandle func; + int32_t (*func)(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply); }; struct ControlHost { @@ -41,11 +35,6 @@ struct ControlHost { void *priv; }; -static inline struct ControlHost *ControlHostFromDevice(struct HdfDeviceObject *device) -{ - return (device == NULL) ? NULL : (struct ControlHost *)device->service; -} - #ifdef __cplusplus #if __cplusplus } diff --git a/model/audio/dispatch/include/audio_stream_dispatch.h b/model/audio/dispatch/include/audio_stream_dispatch.h index b1d4c75298ce9c17b8c283327d1a278eab08c955..b586e1c7299af73024c0ed5ba2bd2b865595ae5b 100755 --- a/model/audio/dispatch/include/audio_stream_dispatch.h +++ b/model/audio/dispatch/include/audio_stream_dispatch.h @@ -21,38 +21,37 @@ extern "C" { #endif #endif /* __cplusplus */ -#define AUDIO_SERVICE_NAME_MAX_LEN 32 - enum StreamDispMethodCmd { - AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, - AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, - AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, - AUDIO_DRV_PCM_IOCTRL_WRITE, - AUDIO_DRV_PCM_IOCTRL_READ, - AUDIO_DRV_PCM_IOCTRL_RENDER_START, - AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, - AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, - AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, - AUDIO_DRV_PCM_IOCTRL_RENDER_PAUSE, - AUDIO_DRV_PCM_IOCTRL_CAPTURE_PAUSE, - AUDIO_DRV_PCM_IOCTRL_RENDER_RESUME, - AUDIO_DRV_PCM_IOCTRL_CAPTURE_RESUME, + AUDIO_DRV_PCM_IOCTL_HW_PARAMS, + AUDIO_DRV_PCM_IOCTL_RENDER_PREPARE, + AUDIO_DRV_PCM_IOCTL_CAPTURE_PREPARE, + AUDIO_DRV_PCM_IOCTL_WRITE, + AUDIO_DRV_PCM_IOCTL_READ, + AUDIO_DRV_PCM_IOCTL_RENDER_START, + AUDIO_DRV_PCM_IOCTL_RENDER_STOP, + AUDIO_DRV_PCM_IOCTL_CAPTURE_START, + AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP, + AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE, + AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE, + AUDIO_DRV_PCM_IOCTL_RENDER_RESUME, + AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME, AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER, AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE, AUDIO_DRV_PCM_IOCTL_MMAP_POSITION, AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE, - AUDIO_DRV_PCM_IOCTRL_DSP_DECODE, - AUDIO_DRV_PCM_IOCTRL_DSP_ENCODE, - AUDIO_DRV_PCM_IOCTRL_DSP_EQUALIZER, - AUDIO_DRV_PCM_IOCTRL_BUTT, + AUDIO_DRV_PCM_IOCTL_RENDER_OPEN, + AUDIO_DRV_PCM_IOCTL_RENDER_CLOSE, + AUDIO_DRV_PCM_IOCTL_CAPTURE_OPEN, + AUDIO_DRV_PCM_IOCTL_CAPTURE_CLOSE, + AUDIO_DRV_PCM_IOCTL_DSPDECODE, + AUDIO_DRV_PCM_IOCTL_DSPENCODE, + AUDIO_DRV_PCM_IOCTL_DSPEQUALIZER, + AUDIO_DRV_PCM_IOCTL_BUTT, }; -typedef int32_t (*StreamDispCmdHandle)(const struct HdfDeviceIoClient *client, - struct HdfSBuf *data, struct HdfSBuf *reply); - struct StreamDispCmdHandleList { enum StreamDispMethodCmd cmd; - StreamDispCmdHandle func; + int32_t (*func)(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply); }; struct StreamHost { @@ -61,14 +60,6 @@ struct StreamHost { void *priv; }; -static inline struct StreamHost *StreamHostFromDevice(struct HdfDeviceObject *device) -{ - return (device == NULL) ? NULL : (struct StreamHost *)device->service; -} - -int32_t StreamDispatch(struct HdfDeviceIoClient *client, int cmdId, - struct HdfSBuf *data, struct HdfSBuf *reply); - #ifdef __cplusplus #if __cplusplus } diff --git a/model/audio/dispatch/src/audio_control_dispatch.c b/model/audio/dispatch/src/audio_control_dispatch.c index 082e66a35ae88f92ddd44a396ea079d8ba27ce12..075641041b2550e011f1b6cc7a5b329ebb03a0c5 100755 --- a/model/audio/dispatch/src/audio_control_dispatch.c +++ b/model/audio/dispatch/src/audio_control_dispatch.c @@ -8,6 +8,7 @@ #include "audio_control_dispatch.h" #include "audio_control.h" +#include "audio_driver_log.h" #define HDF_LOG_TAG audio_control_dispatch @@ -126,7 +127,6 @@ static int32_t ControlHostElemRead(const struct HdfDeviceIoClient *client, struc struct AudioCtrlElemValue elemValue; struct AudioCtrlElemId id; int32_t result; - ADM_LOG_DEBUG("entry."); if ((client == NULL) || (reqData == NULL) || (rspData == NULL)) { ADM_LOG_ERR("Input ElemRead params check error: client=%p, reqData=%p, rspData=%p.", client, reqData, rspData); @@ -148,6 +148,7 @@ static int32_t ControlHostElemRead(const struct HdfDeviceIoClient *client, struc ADM_LOG_ERR("ElemRead request itemName failed!"); return HDF_FAILURE; } + ADM_LOG_DEBUG("itemName: %s cardServiceName: %s iface: %d ", id.itemName, id.cardServiceName, id.iface); kctrl = AudioGetKctrlInstance(&id); if (kctrl == NULL || kctrl->Get == NULL) { @@ -170,7 +171,6 @@ static int32_t ControlHostElemRead(const struct HdfDeviceIoClient *client, struc ADM_LOG_ERR("Write response data value[1]=%d failed!", elemValue.value[1]); return HDF_FAILURE; } - ADM_LOG_DEBUG("success."); return HDF_SUCCESS; } @@ -180,7 +180,6 @@ static int32_t ControlHostElemWrite(const struct HdfDeviceIoClient *client, struct AudioKcontrol *kctrl = NULL; struct AudioCtrlElemValue elemValue; int32_t result; - ADM_LOG_DEBUG("entry."); if ((client == NULL) || (reqData == NULL)) { ADM_LOG_ERR("Input params check error: client=%p, reqData=%p.", client, reqData); @@ -209,6 +208,10 @@ static int32_t ControlHostElemWrite(const struct HdfDeviceIoClient *client, return HDF_FAILURE; } + ADM_LOG_DEBUG("itemName: %s cardServiceName: %s iface: %d value: %d ", elemValue.id.itemName, + elemValue.id.cardServiceName, + elemValue.id.iface, elemValue.value[0]); + kctrl = AudioGetKctrlInstance(&elemValue.id); if (kctrl == NULL || kctrl->Set == NULL) { ADM_LOG_ERR("Find kctrl or Set fail!"); @@ -220,7 +223,6 @@ static int32_t ControlHostElemWrite(const struct HdfDeviceIoClient *client, ADM_LOG_ERR("Get control value fail result=%d", result); return HDF_FAILURE; } - ADM_LOG_DEBUG("success."); return HDF_SUCCESS; } @@ -310,7 +312,7 @@ static void AudioControlRelease(struct HdfDeviceObject *device) return; } - controlHost = ControlHostFromDevice(device); + controlHost = (struct ControlHost *)device->service; if (controlHost == NULL) { ADM_LOG_ERR("controlHost is NULL."); return; diff --git a/model/audio/dispatch/src/audio_stream_dispatch.c b/model/audio/dispatch/src/audio_stream_dispatch.c index 70e26609a2d607fd7bac995cefe7010d6b6830ef..b871ecccb9416014dc0574f5175d7467403e4065 100755 --- a/model/audio/dispatch/src/audio_stream_dispatch.c +++ b/model/audio/dispatch/src/audio_stream_dispatch.c @@ -7,10 +7,19 @@ */ #include "audio_stream_dispatch.h" +#include "audio_driver_log.h" +#include "audio_platform_base.h" #define HDF_LOG_TAG audio_stream_dispatch -int32_t HwCpuDaiDispatch(const struct AudioCard *audioCard, const struct AudioPcmHwParams *params) +#define BUFF_SIZE_MAX 64 + +static inline struct StreamHost *StreamHostFromDevice(const struct HdfDeviceObject *device) +{ + return (device == NULL) ? NULL : (struct StreamHost *)device->service; +} + +static int32_t HwCpuDaiDispatch(const struct AudioCard *audioCard, const struct AudioPcmHwParams *params) { if ((audioCard == NULL) || (params == NULL)) { ADM_LOG_ERR("CpuDai input param is NULL."); @@ -33,9 +42,9 @@ int32_t HwCpuDaiDispatch(const struct AudioCard *audioCard, const struct AudioPc * If not, skip the if statement and execute in sequence. */ if (cpuDai->devData->ops->HwParams != NULL) { - int ret = cpuDai->devData->ops->HwParams(audioCard, params, cpuDai); + int ret = cpuDai->devData->ops->HwParams(audioCard, params); if (ret < 0) { - ADM_LOG_ERR("cpuDai hardware params fail ret=%d", ret); + ADM_LOG_ERR("cpuDai hardware params failed ret=%d", ret); return HDF_ERR_IO; } } @@ -43,7 +52,7 @@ int32_t HwCpuDaiDispatch(const struct AudioCard *audioCard, const struct AudioPc return HDF_SUCCESS; } -int32_t HwCodecDaiDispatch(const struct AudioCard *audioCard, const struct AudioPcmHwParams *params) +static int32_t HwCodecDaiDispatch(const struct AudioCard *audioCard, const struct AudioPcmHwParams *params) { if ((audioCard == NULL) || (params == NULL)) { ADM_LOG_ERR("CodecDai input param is NULL."); @@ -68,9 +77,9 @@ int32_t HwCodecDaiDispatch(const struct AudioCard *audioCard, const struct Audio * If not, skip the if statement and execute in sequence. */ if (codecDai->devData->ops->HwParams != NULL) { - int ret = codecDai->devData->ops->HwParams(audioCard, params, codecDai); + int ret = codecDai->devData->ops->HwParams(audioCard, params); if (ret < 0) { - ADM_LOG_ERR("codecDai hardware params fail ret=%d", ret); + ADM_LOG_ERR("codecDai hardware params failed ret=%d", ret); return HDF_ERR_IO; } } @@ -78,40 +87,58 @@ int32_t HwCodecDaiDispatch(const struct AudioCard *audioCard, const struct Audio return HDF_SUCCESS; } -int32_t HwPlatfromDispatch(const struct AudioCard *audioCard, const struct AudioPcmHwParams *params) +static int32_t HwDspDaiDispatch(const struct AudioCard *audioCard, const struct AudioPcmHwParams *params) { if ((audioCard == NULL) || (params == NULL)) { - ADM_LOG_ERR("Platfrom input param is NULL."); + ADM_LOG_ERR("DspDai input param is NULL."); return HDF_FAILURE; } - struct AudioRuntimeDeivces *rtd = audioCard->rtd; if (rtd == NULL) { - ADM_LOG_ERR("audioCard rtd is NULL."); + ADM_LOG_ERR("DspDai audioCard rtd is NULL."); + return HDF_FAILURE; + } + struct DaiDevice *dspDai = rtd->dspDai; + if (dspDai == NULL || dspDai->devData == NULL || dspDai->devData->ops == NULL) { + ADM_LOG_ERR("dspDai param is NULL."); + return HDF_FAILURE; + } + if (dspDai->devData->ops->HwParams != NULL) { + int ret = dspDai->devData->ops->HwParams(audioCard, params); + if (ret < 0) { + ADM_LOG_ERR("dspDai hardware params failed ret=%d", ret); + return HDF_ERR_IO; + } + } + return HDF_SUCCESS; +} + +static int32_t HwPlatfromDispatch(const struct AudioCard *audioCard, const struct AudioPcmHwParams *params) +{ + if ((audioCard == NULL) || (params == NULL)) { + ADM_LOG_ERR("Platfrom input param is NULL."); return HDF_FAILURE; } - struct PlatformDevice *platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL) { - ADM_LOG_ERR("platform param is NULL."); + struct AudioRuntimeDeivces *rtd = audioCard->rtd; + if (rtd == NULL) { + ADM_LOG_ERR("audioCard rtd is NULL."); return HDF_FAILURE; } /* If there are HwParams function, it will be executed directly. * If not, skip the if statement and execute in sequence. */ - if (platform->devData->ops->HwParams != NULL) { - int ret = platform->devData->ops->HwParams(audioCard, params); - if (ret < 0) { - ADM_LOG_ERR("platform hardware params fail ret=%d", ret); - return HDF_ERR_IO; - } + int ret = AudioHwParams(audioCard, params); + if (ret < 0) { + ADM_LOG_ERR("platform hardware params failed ret=%d", ret); + return HDF_ERR_IO; } return HDF_SUCCESS; } -int32_t HwParamsDispatch(const struct AudioCard *audioCard, const struct AudioPcmHwParams *params) +static int32_t HwParamsDispatch(const struct AudioCard *audioCard, const struct AudioPcmHwParams *params) { if ((audioCard == NULL) || (params == NULL)) { ADM_LOG_ERR("input param is NULL."); @@ -119,10 +146,144 @@ int32_t HwParamsDispatch(const struct AudioCard *audioCard, const struct AudioPc } /* Traverse through each driver method; Enter if you have, if not, exectue in order */ - if (HwCodecDaiDispatch(audioCard, params) || - HwCpuDaiDispatch(audioCard, params) || - HwPlatfromDispatch(audioCard, params)) { - ADM_LOG_ERR("hardware params fail."); + if (HwCodecDaiDispatch(audioCard, params) != HDF_SUCCESS) { + ADM_LOG_ERR("codec dai hardware params failed."); + return HDF_FAILURE; + } + + if (HwCpuDaiDispatch(audioCard, params) != HDF_SUCCESS) { + ADM_LOG_ERR("cpu dai hardware params failed."); + return HDF_FAILURE; + } + + if (HwPlatfromDispatch(audioCard, params) != HDF_SUCCESS) { + ADM_LOG_ERR("platform dai hardware params failed."); + return HDF_FAILURE; + } + + if (HwDspDaiDispatch(audioCard, params) != HDF_SUCCESS) { + ADM_LOG_ERR("dsp dai hardware params failed."); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t CpuDaiDevStartup(const struct AudioCard *audioCard, const struct DaiDevice *cpuDai) +{ + int32_t ret; + if (audioCard == NULL || audioCard->rtd == NULL) { + ADM_LOG_ERR("audioCard is null."); + return HDF_FAILURE; + } + if (cpuDai != NULL && cpuDai->devData != NULL && cpuDai->devData->ops != NULL && + cpuDai->devData->ops->Startup != NULL) { + ret = cpuDai->devData->ops->Startup(audioCard, cpuDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("cpuDai Startup failed."); + return HDF_FAILURE; + } + } else { + ADM_LOG_DEBUG("cpu dai startup is null."); + } + return HDF_SUCCESS; +} + +static int32_t CodecDaiDevStartup(const struct AudioCard *audioCard, const struct DaiDevice *codecDai) +{ + int32_t ret; + if (audioCard == NULL || audioCard->rtd == NULL) { + ADM_LOG_ERR("audioCard is null."); + return HDF_FAILURE; + } + if (codecDai != NULL && codecDai->devData != NULL && codecDai->devData->ops != NULL && + codecDai->devData->ops->Startup != NULL) { + ret = codecDai->devData->ops->Startup(audioCard, codecDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("codecDai Startup failed."); + return HDF_FAILURE; + } + } else { + ADM_LOG_DEBUG("codec dai startup is null."); + } + + return HDF_SUCCESS; +} + +static int32_t DspDaiDevStartup(const struct AudioCard *audioCard, const struct DaiDevice *dspDai) +{ + int32_t ret; + if (audioCard == NULL || audioCard->rtd == NULL) { + ADM_LOG_ERR("audioCard is null."); + return HDF_FAILURE; + } + if (dspDai != NULL && dspDai->devData != NULL && dspDai->devData->ops != NULL && + dspDai->devData->ops->Startup != NULL) { + ret = dspDai->devData->ops->Startup(audioCard, dspDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("dspDai Startup failed."); + return HDF_FAILURE; + } + } else { + ADM_LOG_DEBUG("dsp dai startup is null."); + } + return HDF_SUCCESS; +} + +static int32_t AccessoryDaiDevStartup(const struct AudioCard *audioCard, const struct DaiDevice *accessoryDai) +{ + int32_t ret; + if (audioCard == NULL || audioCard->rtd == NULL) { + ADM_LOG_ERR("audioCard is null."); + return HDF_FAILURE; + } + if (accessoryDai != NULL && accessoryDai->devData != NULL && accessoryDai->devData->ops != NULL && + accessoryDai->devData->ops->Startup != NULL) { + ret = accessoryDai->devData->ops->Startup(audioCard, accessoryDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("accessoryDai Startup failed."); + return HDF_FAILURE; + } + } else { + ADM_LOG_DEBUG("accessory dai startup is null."); + } + return HDF_SUCCESS; +} + +static int32_t AudioDaiDeviceStartup(const struct AudioCard *audioCard) +{ + struct DaiDevice *cpuDai = NULL; + struct DaiDevice *codecDai = NULL; + struct DaiDevice *dspDai = NULL; + struct DaiDevice *accessoryDai = NULL; + int32_t ret; + + if (audioCard == NULL || audioCard->rtd == NULL) { + ADM_LOG_ERR("audioCard is null."); + return HDF_FAILURE; + } + cpuDai = audioCard->rtd->cpuDai; + ret = CpuDaiDevStartup(audioCard, cpuDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("CpuDaiDevStartup failed."); + return HDF_FAILURE; + } + codecDai = audioCard->rtd->codecDai; + ret = CodecDaiDevStartup(audioCard, codecDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("CodecDaiDevStartup failed."); + return HDF_FAILURE; + } + dspDai = audioCard->rtd->dspDai; + ret = DspDaiDevStartup(audioCard, dspDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("DspDaiDevStartup failed."); + return HDF_FAILURE; + } + accessoryDai = audioCard->rtd->accessoryDai; + ret = AccessoryDaiDevStartup(audioCard, accessoryDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("AccessoryDaiDevStartup failed."); return HDF_FAILURE; } return HDF_SUCCESS; @@ -201,13 +362,11 @@ static int32_t HwParamsDataAnalysis(struct HdfSBuf *reqData, struct AudioPcmHwPa return HDF_SUCCESS; } -int32_t StreamHostHwParams(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, +static int32_t StreamHostHwParams(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioPcmHwParams params; - struct StreamHost *streamHost = NULL; struct AudioCard *audioCard = NULL; - char *cardName = NULL; int ret; ADM_LOG_DEBUG("entry."); @@ -217,37 +376,18 @@ int32_t StreamHostHwParams(const struct HdfDeviceIoClient *client, struct HdfSBu } (void)reply; - streamHost = StreamHostFromDevice(client->device); - if (streamHost == NULL) { - ADM_LOG_ERR("renderHost is NULL"); - return HDF_FAILURE; - } - - cardName = (char *)OsalMemCalloc(sizeof(char) * BUFF_SIZE_MAX); - if (cardName == NULL) { - ADM_LOG_ERR("malloc cardServiceName fail!"); - return HDF_FAILURE; - } - streamHost->priv = cardName; - (void)memset_s(¶ms, sizeof(struct AudioPcmHwParams), 0, sizeof(struct AudioPcmHwParams)); + ret = HwParamsDataAnalysis(data, ¶ms); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("hwparams data analysis failed ret=%d", ret); return HDF_FAILURE; } - - if (memcpy_s(cardName, BUFF_SIZE_MAX, params.cardServiceName, BUFF_SIZE_MAX) != EOK) { - ADM_LOG_ERR("memcpy cardName failed."); - return HDF_FAILURE; - } - audioCard = GetCardInstance(params.cardServiceName); if (audioCard == NULL) { - ADM_LOG_ERR("get card instance fail."); + ADM_LOG_ERR("get card instance failed."); return HDF_FAILURE; } - ret = HwParamsDispatch(audioCard, ¶ms); if (ret != HDF_SUCCESS) { ADM_LOG_ERR("hwparams dispatch failed ret=%d", ret); @@ -282,20 +422,18 @@ static struct AudioCard *StreamHostGetCardInstance(const struct HdfDeviceIoClien audioCard = GetCardInstance(cardName); if (audioCard == NULL) { - ADM_LOG_ERR("get card instance fail."); + ADM_LOG_ERR("get card instance failed."); return NULL; } return audioCard; } -int32_t StreamHostCapturePrepare(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, +static int32_t StreamHostCapturePrepare(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; - int ret; + int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); if (client == NULL) { @@ -307,36 +445,90 @@ int32_t StreamHostCapturePrepare(const struct HdfDeviceIoClient *client, struct (void)reply; audioCard = StreamHostGetCardInstance(client); - if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("CapturePrepare get card instance or rtd fail."); + if (audioCard == NULL) { + ADM_LOG_ERR("CapturePrepare get card instance or rtd failed."); return HDF_FAILURE; } - rtd = audioCard->rtd; - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->CapturePrepare == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); + ret = AudioCapturePrepare(audioCard); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("platform CapturePrepare failed ret=%d", ret); + return HDF_ERR_IO; + } + + ADM_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +static int32_t StreamHostCaptureOpen(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, + struct HdfSBuf *reply) +{ + char *cardName = NULL; + const char *carNameTemp = NULL; + struct StreamHost *streamHost = NULL; + struct AudioCard *audioCard = NULL; + + ADM_LOG_DEBUG("entry."); + + if (client == NULL) { + ADM_LOG_ERR("StreamHostCaptureOpen input param is NULL."); return HDF_FAILURE; } - ret = platform->devData->ops->CapturePrepare(audioCard); - if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform CapturePrepare fail ret=%d", ret); + (void)reply; + + cardName = (char *)OsalMemCalloc(sizeof(char) * BUFF_SIZE_MAX); + if (cardName == NULL) { + ADM_LOG_ERR("malloc cardServiceName failed!"); + return HDF_FAILURE; + } + + streamHost = StreamHostFromDevice(client->device); + if (streamHost == NULL) { + OsalMemFree(cardName); + ADM_LOG_ERR("renderHost is NULL"); + return HDF_FAILURE; + } + + if (!(carNameTemp = HdfSbufReadString(data))) { + OsalMemFree(cardName); + ADM_LOG_ERR("read request cardServiceName failed!"); + return HDF_FAILURE; + } + + if (strncpy_s(cardName, BUFF_SIZE_MAX - 1, carNameTemp, strlen(carNameTemp) + 1) != EOK) { + ADM_LOG_ERR("memcpy cardName failed."); + OsalMemFree(cardName); + return HDF_FAILURE; + } + ADM_LOG_DEBUG("card name: %s.", cardName); + streamHost->priv = cardName; + + audioCard = StreamHostGetCardInstance(client); + if (audioCard == NULL) { + ADM_LOG_ERR("StreamHostCaptureOpen get card instance or rtd failed."); + return HDF_FAILURE; + } + + if (AudioCaptureOpen(audioCard) != HDF_SUCCESS) { + ADM_LOG_ERR("platform CaptureOpen failed"); return HDF_ERR_IO; } + if (AudioDaiDeviceStartup(audioCard) != HDF_SUCCESS) { + ADM_LOG_ERR("Dai Device Startup failed."); + return HDF_FAILURE; + } + ADM_LOG_DEBUG("success."); return HDF_SUCCESS; } -int32_t StreamHostRenderPrepare(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, +static int32_t StreamHostRenderPrepare(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; - int ret; + int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); if (client == NULL) { @@ -349,21 +541,13 @@ int32_t StreamHostRenderPrepare(const struct HdfDeviceIoClient *client, struct H audioCard = StreamHostGetCardInstance(client); if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("RenderPrepare get card instance or rtd fail."); + ADM_LOG_ERR("RenderPrepare get card instance or rtd failed."); return HDF_FAILURE; } - rtd = audioCard->rtd; - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->RenderPrepare == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); - return HDF_FAILURE; - } - - ret = platform->devData->ops->RenderPrepare(audioCard); + ret = AudioRenderPrepare(audioCard); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform RenderPrepare fail ret=%d", ret); + ADM_LOG_ERR("platform RenderPrepare failed ret=%d", ret); return HDF_ERR_IO; } @@ -371,53 +555,103 @@ int32_t StreamHostRenderPrepare(const struct HdfDeviceIoClient *client, struct H return HDF_SUCCESS; } -static int32_t StreamTransferWrite(const struct AudioCard *audioCard, struct AudioTxData *transfer) +static int32_t StreamHostRenderOpen(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, + struct HdfSBuf *reply) { - struct PlatformDevice *platform = NULL; - int32_t ret; + char *cardName = NULL; + const char *carNameTemp = NULL; + struct StreamHost *streamHost = NULL; + struct AudioCard *audioCard = NULL; - if (audioCard == NULL || audioCard->rtd == NULL || transfer == NULL) { - ADM_LOG_ERR("input param is NULL."); + ADM_LOG_DEBUG("entry."); + + if (client == NULL) { + ADM_LOG_ERR("StreamHostRenderOpen input param is NULL."); return HDF_FAILURE; } - platform = audioCard->rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->Write == NULL) { - ADM_LOG_ERR("audioCard platform is NULL."); + (void)reply; + + cardName = (char *)OsalMemCalloc(sizeof(char) * BUFF_SIZE_MAX); + if (cardName == NULL) { + ADM_LOG_ERR("malloc cardServiceName failed!"); return HDF_FAILURE; } - ret = platform->devData->ops->Write(audioCard, transfer); - if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform write fail ret=%d", ret); + streamHost = StreamHostFromDevice(client->device); + if (streamHost == NULL) { + ADM_LOG_ERR("renderHost is NULL"); + OsalMemFree(cardName); + return HDF_FAILURE; + } + + if (!(carNameTemp = HdfSbufReadString(data))) { + ADM_LOG_ERR("read request cardServiceName failed!"); + OsalMemFree(cardName); + return HDF_FAILURE; + } + + if (strncpy_s(cardName, BUFF_SIZE_MAX - 1, carNameTemp, strlen(carNameTemp) + 1) != EOK) { + ADM_LOG_ERR("memcpy cardName failed."); + OsalMemFree(cardName); + return HDF_FAILURE; + } + + ADM_LOG_DEBUG("card name: %s.", cardName); + + streamHost->priv = cardName; + + audioCard = StreamHostGetCardInstance(client); + if (audioCard == NULL || audioCard->rtd == NULL) { + ADM_LOG_ERR("StreamHostRenderOpen get card instance or rtd failed."); return HDF_FAILURE; } + if (AudioRenderOpen(audioCard) != HDF_SUCCESS) { + ADM_LOG_ERR("platform RenderOpen failed."); + return HDF_FAILURE; + } + + if (AudioDaiDeviceStartup(audioCard) != HDF_SUCCESS) { + ADM_LOG_ERR("Dai Device Startup failed."); + return HDF_FAILURE; + } + + ADM_LOG_DEBUG("success."); return HDF_SUCCESS; } -static int32_t StreamTransferMmapWrite(const struct AudioCard *audioCard, struct AudioTxMmapData *txMmapData) +static int32_t StreamTransferWrite(const struct AudioCard *audioCard, struct AudioTxData *transfer) { - struct PlatformDevice *platform = NULL; int32_t ret; - ADM_LOG_DEBUG("entry."); - if (audioCard == NULL || audioCard->rtd == NULL || txMmapData == NULL) { + if (audioCard == NULL || transfer == NULL) { ADM_LOG_ERR("input param is NULL."); return HDF_FAILURE; } - platform = audioCard->rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->Write == NULL) { - ADM_LOG_ERR("audioCard platform is NULL."); + ret = AudioPcmWrite(audioCard, transfer); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("pcm write failed ret=%d", ret); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t StreamTransferMmapWrite(const struct AudioCard *audioCard, const struct AudioMmapData *txMmapData) +{ + int32_t ret; + ADM_LOG_DEBUG("entry."); + + if (audioCard == NULL || txMmapData == NULL) { + ADM_LOG_ERR("input param is NULL."); return HDF_FAILURE; } - ret = platform->devData->ops->MmapWrite(audioCard, txMmapData); + ret = AudioPcmMmapWrite(audioCard, txMmapData); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform write fail ret=%d", ret); + ADM_LOG_ERR("platform write failed ret=%d", ret); return HDF_FAILURE; } @@ -425,27 +659,19 @@ static int32_t StreamTransferMmapWrite(const struct AudioCard *audioCard, struct return HDF_SUCCESS; } -static int32_t StreamTransferMmapRead(const struct AudioCard *audioCard, struct AudioRxMmapData *rxMmapData) +static int32_t StreamTransferMmapRead(const struct AudioCard *audioCard, const struct AudioMmapData *rxMmapData) { - struct PlatformDevice *platform = NULL; int32_t ret; ADM_LOG_DEBUG("entry."); - if (audioCard == NULL || audioCard->rtd == NULL || rxMmapData == NULL) { + if (audioCard == NULL || rxMmapData == NULL) { ADM_LOG_ERR("input param is NULL."); return HDF_FAILURE; } - platform = audioCard->rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->MmapRead == NULL) { - ADM_LOG_ERR("audioCard platform is NULL."); - return HDF_FAILURE; - } - - ret = platform->devData->ops->MmapRead(audioCard, rxMmapData); + ret = AudioPcmMmapRead(audioCard, rxMmapData); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform read fail ret=%d", ret); + ADM_LOG_ERR("platform read failed ret=%d", ret); return HDF_FAILURE; } @@ -453,11 +679,11 @@ static int32_t StreamTransferMmapRead(const struct AudioCard *audioCard, struct return HDF_SUCCESS; } -int32_t StreamHostWrite(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +static int32_t StreamHostWrite(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioTxData transfer; struct AudioCard *audioCard = NULL; - int32_t ret; + int32_t ret = HDF_SUCCESS; uint32_t dataSize = 0; ADM_LOG_DEBUG("entry."); @@ -465,7 +691,7 @@ int32_t StreamHostWrite(const struct HdfDeviceIoClient *client, struct HdfSBuf * ADM_LOG_ERR("input param is NULL."); return HDF_FAILURE; } - + (void)memset_s(&transfer, sizeof(struct AudioTxData), 0, sizeof(struct AudioTxData)); if (!HdfSbufReadUint32(data, (uint32_t *)&(transfer.frames))) { ADM_LOG_ERR("read request frames failed!"); return HDF_FAILURE; @@ -477,13 +703,13 @@ int32_t StreamHostWrite(const struct HdfDeviceIoClient *client, struct HdfSBuf * audioCard = StreamHostGetCardInstance(client); if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("get card instance or rtd fail."); + ADM_LOG_ERR("get card instance or rtd failed."); return HDF_FAILURE; } ret = StreamTransferWrite(audioCard, &transfer); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("write reg value fail ret=%d", ret); + ADM_LOG_ERR("write reg value failed ret=%d", ret); return HDF_FAILURE; } @@ -495,13 +721,11 @@ int32_t StreamHostWrite(const struct HdfDeviceIoClient *client, struct HdfSBuf * return HDF_SUCCESS; } -int32_t StreamHostRead(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +static int32_t StreamHostRead(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; struct AudioRxData rxData; - int ret; + int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); if (client == NULL || reply == NULL) { @@ -511,22 +735,14 @@ int32_t StreamHostRead(const struct HdfDeviceIoClient *client, struct HdfSBuf *d (void)data; audioCard = StreamHostGetCardInstance(client); - if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("get card instance or rtd fail."); - return HDF_FAILURE; - } - rtd = audioCard->rtd; - - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || - platform->devData->ops == NULL || platform->devData->ops->Read == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); + if (audioCard == NULL) { + ADM_LOG_ERR("get card instance or rtd failed."); return HDF_FAILURE; } - ret = platform->devData->ops->Read(audioCard, &rxData); + ret = AudioPcmRead(audioCard, &rxData); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform read fail ret=%d", ret); + ADM_LOG_ERR("pcm read failed ret=%d", ret); return HDF_FAILURE; } @@ -535,23 +751,25 @@ int32_t StreamHostRead(const struct HdfDeviceIoClient *client, struct HdfSBuf *d return HDF_FAILURE; } - if (!HdfSbufWriteBuffer(reply, rxData.buf, (uint32_t)(rxData.bufSize))) { - ADM_LOG_ERR("write request data buf failed!"); - return HDF_FAILURE; - } + if (rxData.bufSize != 0) { + if (!HdfSbufWriteBuffer(reply, rxData.buf, (uint32_t)(rxData.bufSize))) { + ADM_LOG_ERR("write request data buf failed!"); + return HDF_FAILURE; + } - if (!HdfSbufWriteUint32(reply, (uint32_t)(rxData.frames))) { - ADM_LOG_ERR("write frames failed!"); - return HDF_FAILURE; + if (!HdfSbufWriteUint32(reply, (uint32_t)(rxData.frames))) { + ADM_LOG_ERR("write frames failed!"); + return HDF_FAILURE; + } } ADM_LOG_DEBUG("success."); return HDF_SUCCESS; } -int32_t StreamHostMmapWrite(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +static int32_t StreamHostMmapWrite(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { - struct AudioTxMmapData txMmapData; + struct AudioMmapData txMmapData; struct AudioCard *audioCard = NULL; uint64_t mAddress = 0; ADM_LOG_DEBUG("entry."); @@ -564,7 +782,12 @@ int32_t StreamHostMmapWrite(const struct HdfDeviceIoClient *client, struct HdfSB return HDF_FAILURE; } + (void)memset_s(&txMmapData, sizeof(struct AudioMmapData), 0, sizeof(struct AudioMmapData)); txMmapData.memoryAddress = (void *)((uintptr_t)mAddress); + if (txMmapData.memoryAddress == NULL) { + ADM_LOG_ERR("txMmapData.memoryAddress is NULL."); + return HDF_FAILURE; + } if (!HdfSbufReadInt32(data, (uint32_t *)&(txMmapData.memoryFd))) { ADM_LOG_ERR("render mmap read request memory fd failed!"); @@ -588,13 +811,14 @@ int32_t StreamHostMmapWrite(const struct HdfDeviceIoClient *client, struct HdfSB } audioCard = StreamHostGetCardInstance(client); if (StreamTransferMmapWrite(audioCard, &txMmapData) != HDF_SUCCESS) { - ADM_LOG_ERR("render mmap write reg value fail!"); + ADM_LOG_ERR("render mmap write reg value failed!"); return HDF_FAILURE; } ADM_LOG_DEBUG("success."); return HDF_SUCCESS; } -int32_t StreamHostMmapPositionWrite(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +static int32_t StreamHostMmapPositionWrite(const struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioCard *audioCard = NULL; ADM_LOG_DEBUG("entry."); @@ -603,28 +827,28 @@ int32_t StreamHostMmapPositionWrite(const struct HdfDeviceIoClient *client, stru return HDF_FAILURE; } audioCard = StreamHostGetCardInstance(client); - if (audioCard == NULL || audioCard->rtd == NULL || audioCard->rtd->platform == NULL) { + if (audioCard == NULL) { ADM_LOG_ERR("audioCard instance is NULL."); return HDF_FAILURE; } - struct PlatformHost *platformHost = PlatformHostFromDevice(audioCard->rtd->platform->device); - if (platformHost == NULL) { + struct PlatformData *platformData = PlatformDataFromCard(audioCard); + if (platformData == NULL) { ADM_LOG_ERR("platformHost instance is NULL."); return HDF_FAILURE; } - if (!HdfSbufWriteUint64(reply, platformHost->renderBufInfo.framesPosition)) { - ADM_LOG_ERR("render mmap write position fail!"); + if (!HdfSbufWriteUint64(reply, platformData->renderBufInfo.framesPosition)) { + ADM_LOG_ERR("render mmap write position failed!"); return HDF_FAILURE; } ADM_LOG_DEBUG("success."); return HDF_SUCCESS; } -int32_t StreamHostMmapRead(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +static int32_t StreamHostMmapRead(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { uint64_t mAddress = 0; struct AudioCard *audioCard = NULL; - struct AudioRxMmapData rxMmapData; + struct AudioMmapData rxMmapData; ADM_LOG_DEBUG("entry."); if (client == NULL || reply == NULL) { ADM_LOG_ERR("input param is NULL."); @@ -634,7 +858,13 @@ int32_t StreamHostMmapRead(const struct HdfDeviceIoClient *client, struct HdfSBu ADM_LOG_ERR("capture mmap read request memory address failed!"); return HDF_FAILURE; } + + (void)memset_s(&rxMmapData, sizeof(struct AudioMmapData), 0, sizeof(struct AudioMmapData)); rxMmapData.memoryAddress = (void *)((uintptr_t)mAddress); + if (rxMmapData.memoryAddress == NULL) { + ADM_LOG_ERR("rxMmapData.memoryAddress is NULL."); + return HDF_FAILURE; + } if (!HdfSbufReadInt32(data, (uint32_t *)&(rxMmapData.memoryFd))) { ADM_LOG_ERR("capture mmap read request memory fd failed!"); @@ -658,14 +888,15 @@ int32_t StreamHostMmapRead(const struct HdfDeviceIoClient *client, struct HdfSBu } audioCard = StreamHostGetCardInstance(client); if (StreamTransferMmapRead(audioCard, &rxMmapData) != HDF_SUCCESS) { - ADM_LOG_ERR("capture mmap read reg value fail!"); + ADM_LOG_ERR("capture mmap read reg value failed!"); return HDF_FAILURE; } ADM_LOG_DEBUG("success."); return HDF_SUCCESS; } -int32_t StreamHostMmapPositionRead(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +static int32_t StreamHostMmapPositionRead(const struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioCard *audioCard = NULL; ADM_LOG_DEBUG("entry."); @@ -674,96 +905,136 @@ int32_t StreamHostMmapPositionRead(const struct HdfDeviceIoClient *client, struc return HDF_FAILURE; } audioCard = StreamHostGetCardInstance(client); - if (audioCard == NULL || audioCard->rtd == NULL || audioCard->rtd->platform == NULL) { + if (audioCard == NULL) { ADM_LOG_ERR("audioCard is NULL."); return HDF_FAILURE; } - struct PlatformHost *platformHost = PlatformHostFromDevice(audioCard->rtd->platform->device); - if (platformHost == NULL) { + struct PlatformData *platformData = PlatformDataFromCard(audioCard); + if (platformData == NULL) { ADM_LOG_ERR("platformHost is NULL."); return HDF_FAILURE; } - if (!HdfSbufWriteUint64(reply, platformHost->captureBufInfo.framesPosition)) { - ADM_LOG_ERR("render mmap write position fail!"); + if (!HdfSbufWriteUint64(reply, platformData->captureBufInfo.framesPosition)) { + ADM_LOG_ERR("render mmap write position failed!"); return HDF_FAILURE; } ADM_LOG_DEBUG("success."); return HDF_SUCCESS; } -int32_t StreamHostRenderStart(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +static int32_t StreamTriggerRouteImpl(const struct AudioCard *audioCard, const struct AudioRuntimeDeivces *rtd, + enum StreamDispMethodCmd methodCmd) +{ + int32_t ret = HDF_SUCCESS; + struct DaiDevice *cpuDai = NULL; + struct DaiDevice *codecDai = NULL; + struct DaiDevice *accessoryDai = NULL; + struct DaiDevice *dspDai = NULL; + if (audioCard == NULL || rtd == NULL) { + ADM_LOG_ERR("input param is NULL."); + return HDF_FAILURE; + } + cpuDai = rtd->cpuDai; + if (cpuDai != NULL && cpuDai->devData != NULL && cpuDai->devData->ops != NULL && + cpuDai->devData->ops->Trigger != NULL) { + ret = cpuDai->devData->ops->Trigger(audioCard, methodCmd, cpuDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("cpuDai Trigger failed."); + return HDF_FAILURE; + } + } + codecDai = rtd->codecDai; + if (codecDai != NULL && codecDai->devData != NULL && codecDai->devData->ops != NULL && + codecDai->devData->ops->Trigger != NULL) { + ret = codecDai->devData->ops->Trigger(audioCard, methodCmd, codecDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("codecDai Trigger failed."); + return HDF_FAILURE; + } + } + accessoryDai = rtd->accessoryDai; + if (accessoryDai != NULL && accessoryDai->devData != NULL && accessoryDai->devData->ops != NULL && + accessoryDai->devData->ops->Trigger != NULL) { + ret = accessoryDai->devData->ops->Trigger(audioCard, methodCmd, accessoryDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("accessoryDai Trigger failed."); + return HDF_FAILURE; + } + } + dspDai = rtd->dspDai; + if (dspDai != NULL && dspDai->devData != NULL && dspDai->devData->ops != NULL && + dspDai->devData->ops->Trigger != NULL) { + ret = dspDai->devData->ops->Trigger(audioCard, methodCmd, dspDai); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("dspDai Trigger failed."); + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +static int32_t StreamHostRenderStart(const struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; - int ret; + int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); - if (client == NULL) { ADM_LOG_ERR("RenderStart input param is NULL."); return HDF_FAILURE; } - (void)data; (void)reply; - audioCard = StreamHostGetCardInstance(client); if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("RenderStart get card instance or rtd fail."); + ADM_LOG_ERR("RenderStart get card instance or rtd failed."); return HDF_FAILURE; } rtd = audioCard->rtd; - - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->RenderStart == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); + audioCard->standbyMode = AUDIO_SAPM_TURN_STANDBY_LATER; + ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_RENDER_START); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("StreamTriggerRouteImpl failed"); return HDF_FAILURE; } - - ret = platform->devData->ops->RenderStart(audioCard); + ret = AudioRenderTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_RENDER_START); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform render start fail ret=%d", ret); + ADM_LOG_ERR("platform render start failed ret=%d", ret); return HDF_ERR_IO; } - ADM_LOG_DEBUG("success."); return HDF_SUCCESS; } -int32_t StreamHostCaptureStart(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) +static int32_t StreamHostCaptureStart(const struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; - int ret; + int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); - if (client == NULL) { ADM_LOG_ERR("CaptureStart input param is NULL."); return HDF_FAILURE; } - (void)data; (void)reply; - audioCard = StreamHostGetCardInstance(client); if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("CaptureStart get card instance or rtd fail."); + ADM_LOG_ERR("CaptureStart get card instance or rtd failed."); return HDF_FAILURE; } + audioCard->standbyMode = AUDIO_SAPM_TURN_STANDBY_LATER; rtd = audioCard->rtd; - - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->CaptureStart == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); + ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_CAPTURE_START); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("StreamTriggerRouteImpl failed"); return HDF_FAILURE; } - - ret = platform->devData->ops->CaptureStart(audioCard); + ret = AudioCaptureTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_CAPTURE_START); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform capture start fail ret=%d", ret); + ADM_LOG_ERR("platform capture start failed ret=%d", ret); return HDF_ERR_IO; } @@ -771,40 +1042,67 @@ int32_t StreamHostCaptureStart(const struct HdfDeviceIoClient *client, struct Hd return HDF_SUCCESS; } -int32_t StreamHostRenderStop(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, +static int32_t StreamHostRenderStop(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; - int ret; + int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); - if (client == NULL) { ADM_LOG_ERR("RenderStop input param is NULL."); return HDF_FAILURE; } - - (void)data; (void)reply; - audioCard = StreamHostGetCardInstance(client); if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("RenderStop get card instance or rtd fail."); + ADM_LOG_ERR("RenderStop get card instance or rtd failed."); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(data, &audioCard->standbyMode)) { + ADM_LOG_ERR("read request streamType failed!"); return HDF_FAILURE; } rtd = audioCard->rtd; + ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_RENDER_STOP); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("StreamTriggerRouteImpl failed"); + return HDF_FAILURE; + } + ret = AudioRenderTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_RENDER_STOP); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("platform render stop failed ret=%d", ret); + return HDF_ERR_IO; + } + + ADM_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +static int32_t StreamHostRenderClose(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, + struct HdfSBuf *reply) +{ + struct AudioCard *audioCard = NULL; + int ret; + ADM_LOG_DEBUG("entry."); + + if (client == NULL) { + ADM_LOG_ERR("RenderClose input param is NULL."); + return HDF_FAILURE; + } + + (void)data; + (void)reply; - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->RenderStop == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); + audioCard = StreamHostGetCardInstance(client); + if (audioCard == NULL || audioCard->rtd == NULL) { + ADM_LOG_ERR("RenderStop get card instance or rtd failed."); return HDF_FAILURE; } - ret = platform->devData->ops->RenderStop(audioCard); + ret = AudioRenderClose(audioCard); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform render stop fail ret=%d", ret); + ADM_LOG_ERR("platform RenderClose failed ret=%d", ret); return HDF_ERR_IO; } @@ -812,12 +1110,13 @@ int32_t StreamHostRenderStop(const struct HdfDeviceIoClient *client, struct HdfS return HDF_SUCCESS; } -int32_t StreamHostCaptureStop(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) + +static int32_t StreamHostCaptureStop(const struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; - int ret; + int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); if (client == NULL) { @@ -825,26 +1124,58 @@ int32_t StreamHostCaptureStop(const struct HdfDeviceIoClient *client, struct Hdf return HDF_FAILURE; } - (void)data; (void)reply; audioCard = StreamHostGetCardInstance(client); if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("CaptureStop get card instance or rtd fail."); + ADM_LOG_ERR("CaptureStop get card instance or rtd failed."); + return HDF_FAILURE; + } + + if (!HdfSbufReadUint32(data, &audioCard->standbyMode)) { + ADM_LOG_ERR("read request streamType failed!"); return HDF_FAILURE; } rtd = audioCard->rtd; + ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("StreamTriggerRouteImpl failed"); + return HDF_FAILURE; + } + ret = AudioCaptureTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("platform capture stop failed ret=%d", ret); + return HDF_ERR_IO; + } + + ADM_LOG_DEBUG("success."); + return HDF_SUCCESS; +} + +static int32_t StreamHostCaptureClose(const struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + struct AudioCard *audioCard = NULL; + int ret; + ADM_LOG_DEBUG("entry."); - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->CaptureStop == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); + if (client == NULL) { + ADM_LOG_ERR("CaptureClose input param is NULL."); + return HDF_FAILURE; + } + + (void)data; + (void)reply; + + audioCard = StreamHostGetCardInstance(client); + if (audioCard == NULL || audioCard->rtd == NULL) { + ADM_LOG_ERR("CaptureStop get card instance or rtd failed."); return HDF_FAILURE; } - ret = platform->devData->ops->CaptureStop(audioCard); + ret = AudioCaptureClose(audioCard); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform capture stop fail ret=%d", ret); + ADM_LOG_ERR("platform capture close failed ret=%d", ret); return HDF_ERR_IO; } @@ -852,12 +1183,13 @@ int32_t StreamHostCaptureStop(const struct HdfDeviceIoClient *client, struct Hdf return HDF_SUCCESS; } -int32_t StreamHostRenderPause(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) + +static int32_t StreamHostRenderPause(const struct HdfDeviceIoClient *client, + struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; - int ret; + int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); if (client == NULL) { @@ -870,21 +1202,18 @@ int32_t StreamHostRenderPause(const struct HdfDeviceIoClient *client, struct Hdf audioCard = StreamHostGetCardInstance(client); if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("RenderPause get card instance or rtd fail."); + ADM_LOG_ERR("RenderPause get card instance or rtd failed."); return HDF_FAILURE; } rtd = audioCard->rtd; - - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->RenderPause == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); + ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("StreamTriggerRouteImpl failed"); return HDF_FAILURE; } - - ret = platform->devData->ops->RenderPause(audioCard); + ret = AudioRenderTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform render pause fail ret=%d", ret); + ADM_LOG_ERR("platform render pause failed ret=%d", ret); return HDF_ERR_IO; } @@ -892,13 +1221,12 @@ int32_t StreamHostRenderPause(const struct HdfDeviceIoClient *client, struct Hdf return HDF_SUCCESS; } -int32_t StreamHostCapturePause(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, +static int32_t StreamHostCapturePause(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; - int ret; + int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); if (client == NULL) { @@ -911,21 +1239,18 @@ int32_t StreamHostCapturePause(const struct HdfDeviceIoClient *client, struct Hd audioCard = StreamHostGetCardInstance(client); if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("CapturePause get card instance or rtd fail."); + ADM_LOG_ERR("CapturePause get card instance or rtd failed."); return HDF_FAILURE; } rtd = audioCard->rtd; - - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->CapturePause == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); + ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("StreamTriggerRouteImpl failed"); return HDF_FAILURE; } - - ret = platform->devData->ops->CapturePause(audioCard); + ret = AudioCaptureTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform captur pause fail ret=%d", ret); + ADM_LOG_ERR("platform captur pause failed ret=%d", ret); return HDF_ERR_IO; } @@ -933,11 +1258,10 @@ int32_t StreamHostCapturePause(const struct HdfDeviceIoClient *client, struct Hd return HDF_SUCCESS; } -int32_t StreamHostRenderResume(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, +static int32_t StreamHostRenderResume(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; int ret; ADM_LOG_DEBUG("entry."); @@ -952,21 +1276,18 @@ int32_t StreamHostRenderResume(const struct HdfDeviceIoClient *client, struct Hd audioCard = StreamHostGetCardInstance(client); if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("RenderResume get card instance or rtd fail."); + ADM_LOG_ERR("RenderResume get card instance or rtd failed."); return HDF_FAILURE; } rtd = audioCard->rtd; - - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->RenderResume == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); + ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_RENDER_RESUME); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("StreamTriggerRouteImpl failed"); return HDF_FAILURE; } - - ret = platform->devData->ops->RenderResume(audioCard); + ret = AudioRenderTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_RENDER_RESUME); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform RenderResume fail ret=%d", ret); + ADM_LOG_ERR("platform RenderResume failed ret=%d", ret); return HDF_ERR_IO; } @@ -974,13 +1295,12 @@ int32_t StreamHostRenderResume(const struct HdfDeviceIoClient *client, struct Hd return HDF_SUCCESS; } -int32_t StreamHostCaptureResume(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, +static int32_t StreamHostCaptureResume(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioRuntimeDeivces *rtd = NULL; - struct PlatformDevice *platform = NULL; struct AudioCard *audioCard = NULL; - int ret; + int ret = HDF_SUCCESS; ADM_LOG_DEBUG("entry."); if (client == NULL) { @@ -993,21 +1313,18 @@ int32_t StreamHostCaptureResume(const struct HdfDeviceIoClient *client, struct H audioCard = StreamHostGetCardInstance(client); if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("CaptureResume get card instance or rtd fail."); + ADM_LOG_ERR("CaptureResume get card instance or rtd failed."); return HDF_FAILURE; } rtd = audioCard->rtd; - - platform = rtd->platform; - if (platform == NULL || platform->devData == NULL || platform->devData->ops == NULL || - platform->devData->ops->CaptureResume == NULL) { - ADM_LOG_ERR("audioCard rtd platform is NULL."); + ret = StreamTriggerRouteImpl(audioCard, rtd, AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("StreamTriggerRouteImpl failed"); return HDF_FAILURE; } - - ret = platform->devData->ops->CaptureResume(audioCard); + ret = AudioCaptureTrigger(audioCard, AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("platform CaptureResume fail ret=%d", ret); + ADM_LOG_ERR("platform CaptureResume failed ret=%d", ret); return HDF_ERR_IO; } @@ -1015,13 +1332,13 @@ int32_t StreamHostCaptureResume(const struct HdfDeviceIoClient *client, struct H return HDF_SUCCESS; } -int32_t StreamHostDspDecode(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, +static int32_t StreamHostDspDecode(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioRuntimeDeivces *rtd = NULL; struct DspDevice *dspDev = NULL; struct AudioCard *audioCard = NULL; - int ret; + int ret = HDF_SUCCESS; ADM_LOG_DEBUG("Dsp Decode Entry."); if (client == NULL) { @@ -1033,20 +1350,20 @@ int32_t StreamHostDspDecode(const struct HdfDeviceIoClient *client, struct HdfSB audioCard = StreamHostGetCardInstance(client); if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("DspDecode get card instance or rtd fail."); + ADM_LOG_ERR("DspDecode get card instance or rtd failed."); return HDF_FAILURE; } rtd = audioCard->rtd; dspDev = rtd->dsp; - if (dspDev == NULL || dspDev->devData == NULL || dspDev->devData->decode == NULL) { + if (dspDev == NULL || dspDev->devData == NULL || dspDev->devData->Decode == NULL) { ADM_LOG_ERR("audioCard rtd dsp is NULL."); return HDF_FAILURE; } - ret = dspDev->devData->decode(audioCard, (void*)data, dspDev); + ret = dspDev->devData->Decode(audioCard, (void*)data, dspDev); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("DeCode render pause fail ret=%d", ret); + ADM_LOG_ERR("DeCode render pause failed ret=%d", ret); return HDF_ERR_IO; } @@ -1054,13 +1371,13 @@ int32_t StreamHostDspDecode(const struct HdfDeviceIoClient *client, struct HdfSB return HDF_SUCCESS; } -int32_t StreamHostDspEncode(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, +static int32_t StreamHostDspEncode(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioRuntimeDeivces *rtd = NULL; struct DspDevice *dspDev = NULL; struct AudioCard *audioCard = NULL; - int ret; + int ret = HDF_SUCCESS; ADM_LOG_DEBUG("Dsp Encode Entry."); if (client == NULL) { @@ -1072,20 +1389,20 @@ int32_t StreamHostDspEncode(const struct HdfDeviceIoClient *client, struct HdfSB audioCard = StreamHostGetCardInstance(client); if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("DspEncode get card instance or rtd fail."); + ADM_LOG_ERR("DspEncode get card instance or rtd failed."); return HDF_FAILURE; } rtd = audioCard->rtd; dspDev = rtd->dsp; - if (dspDev == NULL || dspDev->devData == NULL || dspDev->devData->encode == NULL) { + if (dspDev == NULL || dspDev->devData == NULL || dspDev->devData->Encode == NULL) { ADM_LOG_ERR("audioCard rtd dsp is NULL."); return HDF_FAILURE; } - ret = dspDev->devData->encode(audioCard, (void*)data, dspDev); + ret = dspDev->devData->Encode(audioCard, (void*)data, dspDev); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("EnCode render pause fail ret=%d", ret); + ADM_LOG_ERR("EnCode render pause failed ret=%d", ret); return HDF_ERR_IO; } @@ -1093,13 +1410,13 @@ int32_t StreamHostDspEncode(const struct HdfDeviceIoClient *client, struct HdfSB return HDF_SUCCESS; } -int32_t StreamHostDspEqualizer(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, +static int32_t StreamHostDspEqualizer(const struct HdfDeviceIoClient *client, struct HdfSBuf *data, struct HdfSBuf *reply) { struct AudioRuntimeDeivces *rtd = NULL; struct DspDevice *dspDev = NULL; struct AudioCard *audioCard = NULL; - int ret; + int ret = HDF_SUCCESS; ADM_LOG_DEBUG("Dsp Equalizer Entry."); if (client == NULL) { @@ -1111,7 +1428,7 @@ int32_t StreamHostDspEqualizer(const struct HdfDeviceIoClient *client, struct Hd audioCard = StreamHostGetCardInstance(client); if (audioCard == NULL || audioCard->rtd == NULL) { - ADM_LOG_ERR("DspEqualizer get card instance or rtd fail."); + ADM_LOG_ERR("DspEqualizer get card instance or rtd failed."); return HDF_FAILURE; } rtd = audioCard->rtd; @@ -1124,7 +1441,7 @@ int32_t StreamHostDspEqualizer(const struct HdfDeviceIoClient *client, struct Hd ret = dspDev->devData->Equalizer(audioCard, (void*)data, dspDev); if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("Equalizer render pause fail ret=%d", ret); + ADM_LOG_ERR("Equalizer render pause failed ret=%d", ret); return HDF_ERR_IO; } @@ -1133,47 +1450,42 @@ int32_t StreamHostDspEqualizer(const struct HdfDeviceIoClient *client, struct Hd } static struct StreamDispCmdHandleList g_streamDispCmdHandle[] = { - {AUDIO_DRV_PCM_IOCTRL_HW_PARAMS, StreamHostHwParams}, - {AUDIO_DRV_PCM_IOCTRL_RENDER_PREPARE, StreamHostRenderPrepare}, - {AUDIO_DRV_PCM_IOCTRL_CAPTURE_PREPARE, StreamHostCapturePrepare}, - {AUDIO_DRV_PCM_IOCTRL_WRITE, StreamHostWrite}, - {AUDIO_DRV_PCM_IOCTRL_READ, StreamHostRead}, - {AUDIO_DRV_PCM_IOCTRL_RENDER_START, StreamHostRenderStart}, - {AUDIO_DRV_PCM_IOCTRL_RENDER_STOP, StreamHostRenderStop}, - {AUDIO_DRV_PCM_IOCTRL_CAPTURE_START, StreamHostCaptureStart}, - {AUDIO_DRV_PCM_IOCTRL_CAPTURE_STOP, StreamHostCaptureStop}, - {AUDIO_DRV_PCM_IOCTRL_RENDER_PAUSE, StreamHostRenderPause}, - {AUDIO_DRV_PCM_IOCTRL_CAPTURE_PAUSE, StreamHostCapturePause}, - {AUDIO_DRV_PCM_IOCTRL_RENDER_RESUME, StreamHostRenderResume}, - {AUDIO_DRV_PCM_IOCTRL_CAPTURE_RESUME, StreamHostCaptureResume}, + {AUDIO_DRV_PCM_IOCTL_WRITE, StreamHostWrite}, + {AUDIO_DRV_PCM_IOCTL_READ, StreamHostRead}, + {AUDIO_DRV_PCM_IOCTL_HW_PARAMS, StreamHostHwParams}, + {AUDIO_DRV_PCM_IOCTL_RENDER_PREPARE, StreamHostRenderPrepare}, + {AUDIO_DRV_PCM_IOCTL_CAPTURE_PREPARE, StreamHostCapturePrepare}, + {AUDIO_DRV_PCM_IOCTL_RENDER_OPEN, StreamHostRenderOpen}, + {AUDIO_DRV_PCM_IOCTL_RENDER_CLOSE, StreamHostRenderClose}, + {AUDIO_DRV_PCM_IOCTL_RENDER_START, StreamHostRenderStart}, + {AUDIO_DRV_PCM_IOCTL_RENDER_STOP, StreamHostRenderStop}, + {AUDIO_DRV_PCM_IOCTL_CAPTURE_OPEN, StreamHostCaptureOpen}, + {AUDIO_DRV_PCM_IOCTL_CAPTURE_CLOSE, StreamHostCaptureClose}, + {AUDIO_DRV_PCM_IOCTL_CAPTURE_START, StreamHostCaptureStart}, + {AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP, StreamHostCaptureStop}, + {AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE, StreamHostRenderPause}, + {AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE, StreamHostCapturePause}, + {AUDIO_DRV_PCM_IOCTL_RENDER_RESUME, StreamHostRenderResume}, + {AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME, StreamHostCaptureResume}, {AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER, StreamHostMmapWrite}, {AUDIO_DRV_PCM_IOCTL_MMAP_BUFFER_CAPTURE, StreamHostMmapRead}, {AUDIO_DRV_PCM_IOCTL_MMAP_POSITION, StreamHostMmapPositionWrite}, {AUDIO_DRV_PCM_IOCTL_MMAP_POSITION_CAPTURE, StreamHostMmapPositionRead}, - {AUDIO_DRV_PCM_IOCTRL_DSP_DECODE, StreamHostDspDecode}, - {AUDIO_DRV_PCM_IOCTRL_DSP_ENCODE, StreamHostDspEncode}, - {AUDIO_DRV_PCM_IOCTRL_DSP_EQUALIZER, StreamHostDspEqualizer}, + {AUDIO_DRV_PCM_IOCTL_DSPDECODE, StreamHostDspDecode}, + {AUDIO_DRV_PCM_IOCTL_DSPENCODE, StreamHostDspEncode}, + {AUDIO_DRV_PCM_IOCTL_DSPEQUALIZER, StreamHostDspEqualizer}, }; -int32_t StreamDispatch(struct HdfDeviceIoClient *client, int cmdId, - struct HdfSBuf *data, struct HdfSBuf *reply) +static int32_t StreamDispatch(struct HdfDeviceIoClient *client, int cmdId, + struct HdfSBuf *data, struct HdfSBuf *reply) { - unsigned int i; - - if ((client == NULL) || (data == NULL) || (reply == NULL)) { - return HDF_ERR_INVALID_PARAM; - } - - if (cmdId >= AUDIO_DRV_PCM_IOCTRL_BUTT || cmdId < 0) { - ADM_LOG_ERR("invalid [cmdId=%d]", cmdId); - return HDF_FAILURE; - } - - for (i = 0; i < sizeof(g_streamDispCmdHandle) / sizeof(g_streamDispCmdHandle[0]); ++i) { + unsigned int count = sizeof(g_streamDispCmdHandle) / sizeof(g_streamDispCmdHandle[0]); + for (unsigned int i = 0; i < count; ++i) { if ((cmdId == (int)(g_streamDispCmdHandle[i].cmd)) && (g_streamDispCmdHandle[i].func != NULL)) { return g_streamDispCmdHandle[i].func(client, data, reply); } } + ADM_LOG_ERR("invalid [cmdId=%d]", cmdId); return HDF_FAILURE; } @@ -1185,7 +1497,7 @@ static struct StreamHost *StreamHostCreateAndBind(struct HdfDeviceObject *device struct StreamHost *streamHost = (struct StreamHost *)OsalMemCalloc(sizeof(*streamHost)); if (streamHost == NULL) { - ADM_LOG_ERR("malloc host fail!"); + ADM_LOG_ERR("malloc host failed!"); return NULL; } streamHost->device = device; diff --git a/model/audio/sapm/include/audio_sapm.h b/model/audio/sapm/include/audio_sapm.h index 0eaa935cbdd0e776d4d93294158cb72dc3ac1578..20c0f6568a3752ea942221271c8d476ac3804c79 100755 --- a/model/audio/sapm/include/audio_sapm.h +++ b/model/audio/sapm/include/audio_sapm.h @@ -17,28 +17,12 @@ extern "C" { #endif #endif /* __cplusplus */ -#define SAPM_POLL_TIME 10000 /* 10s */ -#define SAPM_SLEEP_TIME (3 * 60000) /* 3min */ - -#define MIXER_REG_ADDR 10 /* mixer address -- Temporarily defined as this value */ - -#define SAPM_POWER_DOWN 0 -#define SAPM_POWER_UP 1 - -#define CONNECT_CODEC_PIN 1 -#define UNCONNECT_CODEC_PIN 0 - -#define EXIST_EXTERNAL_WIDGET 1 -#define UNEXIST_EXTERNAL_WIDGET 1 - -#define CONNECT_SINK_AND_SOURCE 1 -#define UNCONNECT_SINK_AND_SOURCE 0 - /* sapm widget types */ enum AudioSapmType { AUDIO_SAPM_INPUT = 0, /* input pin */ AUDIO_SAPM_OUTPUT, /* output pin */ AUDIO_SAPM_MUX, /* selects 1 analog signal from many inputs */ + AUDIO_SAPM_DEMUX, /* connects the input to one of multiple outputs */ AUDIO_SAPM_VIRT_MUX, /* virtual version of snd_soc_dapm_mux */ AUDIO_SAPM_VALUE_MUX, /* selects 1 analog signal from many inputs */ AUDIO_SAPM_MIXER, /* mixes several analog signals together */ @@ -57,31 +41,14 @@ enum AudioSapmType { AUDIO_SAPM_PRE, /* machine specific pre component - exec first */ AUDIO_SAPM_POST, /* machine specific post component - exec last */ AUDIO_SAPM_SUPPLY, /* power/clock supply */ + AUDIO_SAPM_REGULATOR_SUPPLY, /* external regulator */ + AUDIO_SAPM_CLOCK_SUPPLY, /* external clock */ AUDIO_SAPM_AIF_IN, /* audio interface input */ AUDIO_SAPM_AIF_OUT, /* audio interface output */ + AUDIO_SAPM_SIGGEN, /* signal generator */ + AUDIO_SAPM_SINK, }; -/* component has no PM register bit */ -#define AUDIO_SAPM_NOPM (-1) - -/* dapm stream operations */ -#define AUDIO_SAPM_STREAM_NOP 0x0 -#define AUDIO_SAPM_STREAM_START 0x1 -#define AUDIO_SAPM_STREAM_STOP 0x2 -#define AUDIO_SAPM_STREAM_SUSPEND 0x4 -#define AUDIO_SAPM_STREAM_RESUME 0x8 -#define AUDIO_SAPM_STREAM_PAUSE_PUSH 0x10 -#define AUDIO_SAPM_STREAM_PAUSE_RELEASE 0x20 - -/* sapm event types */ -#define AUDIO_SAPM_PRE_PMU 0x1 /* before component power up */ -#define AUDIO_SAPM_POST_PMU 0x2 /* after component power up */ -#define AUDIO_SAPM_PRE_PMD 0x4 /* before component power down */ -#define AUDIO_SAPM_POST_PMD 0x8 /* after component power down */ -#define AUDIO_SAPM_PRE_REG 0x10 /* before audio path setup */ -#define AUDIO_SAPM_POST_REG 0x20 /* after audio path setup */ -#define AUDIO_SAPM_PRE_POST_PMD (AUDIO_SAPM_PRE_PMD | AUDIO_SAPM_POST_PMD) - enum AudioBiasLevel { AUDIO_BIAS_OFF = 0, AUDIO_BIAS_STANDBY = 1, @@ -201,9 +168,7 @@ int32_t AudioSapmNewComponents(struct AudioCard *audioCard, int32_t AudioSapmAddRoutes(struct AudioCard *audioCard, const struct AudioSapmRoute *route, int32_t routeMaxNum); int32_t AudioSapmNewControls(struct AudioCard *audioCard); -int AudioSapmPowerComponents(struct AudioCard *audioCard); int32_t AudioSapmSleep(const struct AudioCard *audioCard); -uint64_t AudioSapmRefreshTime(bool bRefresh); int32_t AudioSampPowerUp(const struct AudioCard *card); int32_t AudioSampSetPowerMonitor(struct AudioCard *card, bool powerMonitorState); diff --git a/model/audio/sapm/src/audio_sapm.c b/model/audio/sapm/src/audio_sapm.c index b3d60c0176ecbe15b578b331e1d0416eac428b77..605123d1f9ba55d6a5f32d3681297f2f1824e71d 100755 --- a/model/audio/sapm/src/audio_sapm.c +++ b/model/audio/sapm/src/audio_sapm.c @@ -7,13 +7,30 @@ */ #include "audio_sapm.h" +#include "audio_driver_log.h" #include "osal_io.h" #include "osal_time.h" #include "osal_timer.h" #define HDF_LOG_TAG audio_sapm +#define SAPM_POLL_TIME 10000 /* 10s */ +#define SAPM_SLEEP_TIME (3 * 60000) /* 3min */ + +#define SAPM_POWER_DOWN 0 +#define SAPM_POWER_UP 1 + +#define CONNECT_CODEC_PIN 1 +#define UNCONNECT_CODEC_PIN 0 + +#define EXIST_EXTERNAL_WIDGET 1 +#define UNEXIST_EXTERNAL_WIDGET 1 + +#define CONNECT_SINK_AND_SOURCE 1 +#define UNCONNECT_SINK_AND_SOURCE 0 + static void AudioSapmEnterSleep(uintptr_t para); +static uint64_t AudioSapmRefreshTime(bool bRefresh); /* power up sequences */ static int32_t g_audioSapmPowerUpSeq[] = { @@ -67,7 +84,7 @@ static int32_t ConnectedInputEndPoint(const struct AudioSapmComponent *sapmCompo { struct AudioSapmpath *path = NULL; int32_t count = 0; - int32_t endPointVal = 1; + const int32_t endPointVal = 1; if (sapmComponent == NULL) { ADM_LOG_ERR("input param sapmComponent is NULL."); @@ -97,7 +114,7 @@ static int32_t ConnectedOutputEndPoint(const struct AudioSapmComponent *sapmComp { struct AudioSapmpath *path = NULL; int32_t count = 0; - int32_t endPointVal = 1; + const int32_t endPointVal = 1; if (sapmComponent == NULL) { ADM_LOG_ERR("input param sapmComponent is NULL."); @@ -152,6 +169,21 @@ static int32_t AudioSapmGenericCheckPower(const struct AudioSapmComponent *sapmC return SAPM_POWER_UP; } +static int32_t AudioSapmAdcPowerClock(struct AudioSapmComponent *sapmComponent) +{ + (void)sapmComponent; + ADM_LOG_INFO("Adc standby mode entry!"); + return HDF_SUCCESS; +} + +static int32_t AudioSapmDdcPowerClock(struct AudioSapmComponent *sapmComponent) +{ + (void)sapmComponent; + ADM_LOG_INFO("Ddc standby mode entry!"); + return HDF_SUCCESS; +} + + static int32_t AudioSapmAdcCheckPower(const struct AudioSapmComponent *sapmComponent) { int32_t input; @@ -239,11 +271,56 @@ static void AudioSampCheckPowerCallback(struct AudioSapmComponent *sapmComponent return; } +static void AudioSampPowerClockCallback(struct AudioSapmComponent *sapmComponent) +{ + if (sapmComponent == NULL) { + ADM_LOG_ERR("input param cpt is NULL."); + return; + } + + switch (sapmComponent->sapmType) { + case AUDIO_SAPM_ANALOG_SWITCH: + case AUDIO_SAPM_MIXER: + case AUDIO_SAPM_MIXER_NAMED_CTRL: + sapmComponent->PowerClockOp = NULL; + break; + case AUDIO_SAPM_MUX: + case AUDIO_SAPM_VIRT_MUX: + case AUDIO_SAPM_VALUE_MUX: + sapmComponent->PowerClockOp = NULL; + break; + case AUDIO_SAPM_ADC: + case AUDIO_SAPM_AIF_OUT: + sapmComponent->PowerClockOp = AudioSapmAdcPowerClock; + break; + case AUDIO_SAPM_DAC: + case AUDIO_SAPM_AIF_IN: + sapmComponent->PowerClockOp = AudioSapmDdcPowerClock; + break; + case AUDIO_SAPM_PGA: + case AUDIO_SAPM_OUT_DRV: + case AUDIO_SAPM_INPUT: + case AUDIO_SAPM_OUTPUT: + case AUDIO_SAPM_MICBIAS: + case AUDIO_SAPM_SPK: + case AUDIO_SAPM_HP: + case AUDIO_SAPM_MIC: + case AUDIO_SAPM_LINE: + sapmComponent->PowerClockOp = NULL; + break; + default: + sapmComponent->PowerClockOp = NULL; + break; + } + + return; +} + int32_t AudioSapmNewComponent(struct AudioCard *audioCard, const struct AudioSapmComponent *component) { struct AudioSapmComponent *sapmComponent = NULL; - if ((audioCard == NULL || audioCard->rtd == NULL || audioCard->rtd->codec == NULL) || (component == NULL)) { + if ((audioCard == NULL || audioCard->rtd == NULL) || (component == NULL)) { ADM_LOG_ERR("input params check error: audioCard=%p, component=%p.", audioCard, component); return HDF_FAILURE; } @@ -279,11 +356,13 @@ int32_t AudioSapmNewComponent(struct AudioCard *audioCard, const struct AudioSap OsalMemFree(sapmComponent); return HDF_FAILURE; } + sapmComponent->codec = audioCard->rtd->codec; + sapmComponent->accessory = audioCard->rtd->accessory; sapmComponent->kcontrolsNum = component->kcontrolsNum; sapmComponent->active = 0; AudioSampCheckPowerCallback(sapmComponent); - sapmComponent->PowerClockOp = NULL; + AudioSampPowerClockCallback(sapmComponent); DListHeadInit(&sapmComponent->sources); DListHeadInit(&sapmComponent->sinks); @@ -325,7 +404,7 @@ static void MuxSetPathStatus(const struct AudioSapmComponent *sapmComponent, str int32_t ret; uint32_t val = 0; int32_t item; - uint32_t reg = 0; + const uint32_t reg = 0; uint32_t shift; if ((sapmComponent == NULL || sapmComponent->codec == NULL) || (path == NULL || path->name == NULL) || @@ -364,7 +443,7 @@ static void MuxValueSetPathStatus(const struct AudioSapmComponent *sapmComponent int32_t ret; uint32_t val = 0; uint32_t item; - uint32_t reg = 0; + const uint32_t reg = 0; uint32_t shift; if ((sapmComponent == NULL || sapmComponent->codec == NULL) || (path == NULL || path->name == NULL) || (enumKtl == NULL || enumKtl->texts == NULL)) { @@ -383,8 +462,9 @@ static void MuxValueSetPathStatus(const struct AudioSapmComponent *sapmComponent val = val >> shift; for (item = 0; item < enumKtl->max; item++) { - if (val == enumKtl->values[item]) + if (val == enumKtl->values[item]) { break; + } } path->connect = UNCONNECT_SINK_AND_SOURCE; @@ -408,9 +488,9 @@ static void MixerSetPathStatus(const struct AudioSapmComponent *sapmComponent, s uint32_t mask; uint32_t shift; uint32_t invert; - uint32_t curValue; + uint32_t curValue = 0; - if ((sapmComponent == NULL || sapmComponent->codec == NULL) || (path == NULL) || (mixerCtrl == NULL)) { + if ((sapmComponent == NULL) || (path == NULL) || (mixerCtrl == NULL)) { ADM_LOG_ERR("input params check error: sapmComponent=%p, path=%p, mixerCtrl=%p.", sapmComponent, path, mixerCtrl); return; @@ -421,9 +501,20 @@ static void MixerSetPathStatus(const struct AudioSapmComponent *sapmComponent, s mask = mixerCtrl->mask; invert = mixerCtrl->invert; - ret = AudioCodecReadReg(sapmComponent->codec, reg, &curValue); - if (ret != HDF_SUCCESS) { - ADM_LOG_ERR("read reg fail!"); + if (sapmComponent->codec != NULL) { + ret = AudioCodecReadReg(sapmComponent->codec, reg, &curValue); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("read reg fail!"); + return; + } + } else if (sapmComponent->accessory != NULL) { + ret = AudioAccessoryReadReg(sapmComponent->accessory, reg, &curValue); + if (ret != HDF_SUCCESS) { + ADM_LOG_ERR("read reg fail!"); + return; + } + } else { + ADM_LOG_ERR("accessory and codec is null!"); return; } @@ -447,25 +538,21 @@ static int32_t AudioSapmSetPathStatus(const struct AudioSapmComponent *sapmCompo switch (sapmComponent->sapmType) { case AUDIO_SAPM_MIXER: case AUDIO_SAPM_ANALOG_SWITCH: - case AUDIO_SAPM_MIXER_NAMED_CTRL: { + case AUDIO_SAPM_MIXER_NAMED_CTRL: MixerSetPathStatus(sapmComponent, path, (struct AudioMixerControl *)((volatile uintptr_t)sapmComponent->kcontrolNews[i].privateValue)); - } - break; - case AUDIO_SAPM_MUX: { + break; + case AUDIO_SAPM_MUX: MuxSetPathStatus(sapmComponent, path, (struct AudioEnumKcontrol *)((volatile uintptr_t)sapmComponent->kcontrolNews[i].privateValue), i); - } - break; - case AUDIO_SAPM_VALUE_MUX: { + break; + case AUDIO_SAPM_VALUE_MUX: MuxValueSetPathStatus(sapmComponent, path, (struct AudioEnumKcontrol *)((volatile uintptr_t)sapmComponent->kcontrolNews[i].privateValue), i); - } - break; - default: { + break; + default: path->connect = CONNECT_SINK_AND_SOURCE; break; - } } return HDF_SUCCESS; @@ -475,7 +562,7 @@ static int32_t AudioSapmConnectMixer(struct AudioCard *audioCard, struct AudioSapmComponent *source, struct AudioSapmComponent *sink, struct AudioSapmpath *path, const char *controlName) { - int i; + int i = 0; if ((audioCard == NULL) || (source == NULL) || (sink == NULL) || (path == NULL) || (controlName == NULL)) { @@ -579,13 +666,15 @@ static void AudioSampExtComponentsCheck(struct AudioSapmComponent *cptSource, st /* check for external components */ if (cptSink->sapmType == AUDIO_SAPM_INPUT) { if (cptSource->sapmType == AUDIO_SAPM_MICBIAS || cptSource->sapmType == AUDIO_SAPM_MIC || - cptSource->sapmType == AUDIO_SAPM_LINE || cptSource->sapmType == AUDIO_SAPM_OUTPUT) + cptSource->sapmType == AUDIO_SAPM_LINE || cptSource->sapmType == AUDIO_SAPM_OUTPUT) { cptSink->external = EXIST_EXTERNAL_WIDGET; + } } if (cptSource->sapmType == AUDIO_SAPM_OUTPUT) { if (cptSink->sapmType == AUDIO_SAPM_SPK || cptSink->sapmType == AUDIO_SAPM_HP || - cptSink->sapmType == AUDIO_SAPM_LINE || cptSink->sapmType == AUDIO_SAPM_INPUT) + cptSink->sapmType == AUDIO_SAPM_LINE || cptSink->sapmType == AUDIO_SAPM_INPUT) { cptSource->external = EXIST_EXTERNAL_WIDGET; + } } return; @@ -598,13 +687,13 @@ static int32_t AudioSapmAddRoute(struct AudioCard *audioCard, const struct Audio struct AudioSapmComponent *sapmComponent = NULL; int32_t ret; - if ((audioCard == NULL) || (route == NULL || route->source == NULL || route->sink == NULL)) { + if (audioCard == NULL || route == NULL || route->source == NULL || route->sink == NULL) { ADM_LOG_ERR("input params check error: audioCard=%p, route=%p.", audioCard, route); return HDF_FAILURE; } DLIST_FOR_EACH_ENTRY(sapmComponent, &audioCard->components, struct AudioSapmComponent, list) { - if (sapmComponent == NULL || sapmComponent->componentName == NULL) { + if (sapmComponent->componentName == NULL) { continue; } if ((cptSource == NULL) && (strcmp(sapmComponent->componentName, route->source) == 0)) { @@ -667,19 +756,20 @@ int32_t AudioSapmAddRoutes(struct AudioCard *audioCard, const struct AudioSapmRo return HDF_SUCCESS; } -int32_t AudioSapmNewMixerControls(struct AudioSapmComponent *sapmComponent, struct AudioCard *audioCard) +int32_t AudioSapmNewMixerControls(const struct AudioSapmComponent *sapmComponent, struct AudioCard *audioCard) { struct AudioSapmpath *path = NULL; int32_t i; - if (sapmComponent == NULL || audioCard == NULL) { + if (sapmComponent == NULL || sapmComponent->kcontrols == NULL || audioCard == NULL) { ADM_LOG_ERR("input params check error: sapmComponent=%p, audioCard=%p.", sapmComponent, audioCard); return HDF_FAILURE; } for (i = 0; i < sapmComponent->kcontrolsNum; i++) { DLIST_FOR_EACH_ENTRY(path, &sapmComponent->sources, struct AudioSapmpath, listSink) { - if (path == NULL || path->name == NULL || sapmComponent->kcontrolNews[i].name == NULL) { + if (path->name == NULL || sapmComponent->kcontrolNews == NULL + || sapmComponent->kcontrolNews[i].name == NULL) { continue; } @@ -719,6 +809,11 @@ int AudioSapmNewMuxControls(struct AudioSapmComponent *sapmComponent, struct Aud ADM_LOG_ERR("add control fail!"); return HDF_FAILURE; } + + if (sapmComponent->kcontrols == NULL) { + ADM_LOG_ERR("sapmComponent->kcontrols is NULL!"); + return HDF_FAILURE; + } sapmComponent->kcontrols[0] = kctrl; DListInsertHead(&sapmComponent->kcontrols[0]->list, &audioCard->controls); @@ -862,8 +957,9 @@ static void AudioSapmPowerDownSeqRun(const struct DListHead *list) return; } -int AudioSapmPowerComponents(struct AudioCard *audioCard) +static int AudioSapmPowerComponents(struct AudioCard *audioCard) { + int32_t ret; struct AudioSapmComponent *sapmComponent = NULL; struct DListHead upList; struct DListHead downList; @@ -884,7 +980,10 @@ int AudioSapmPowerComponents(struct AudioCard *audioCard) } if (g_audioSapmIsStandby && sapmComponent->PowerClockOp != NULL) { - sapmComponent->PowerClockOp(sapmComponent); + ret = sapmComponent->PowerClockOp(sapmComponent); + if (ret != HDF_SUCCESS) { + continue; + } } AudioSapmSetPower(audioCard, sapmComponent, sapmComponent->newPower, &upList, &downList); @@ -953,7 +1052,7 @@ int32_t AudioSapmSleep(const struct AudioCard *audioCard) int32_t AudioSapmNewControls(struct AudioCard *audioCard) { struct AudioSapmComponent *sapmComponent = NULL; - int ret; + int ret = HDF_SUCCESS; if (audioCard == NULL) { ADM_LOG_ERR("input param audioCard is NULL."); @@ -983,7 +1082,7 @@ int32_t AudioSapmNewControls(struct AudioCard *audioCard) case AUDIO_SAPM_MUX: case AUDIO_SAPM_VIRT_MUX: case AUDIO_SAPM_VALUE_MUX: - ret =AudioSapmNewMuxControls(sapmComponent, audioCard); + ret = AudioSapmNewMuxControls(sapmComponent, audioCard); break; default: ret = HDF_SUCCESS; @@ -1013,7 +1112,7 @@ static int32_t MixerUpdatePowerStatus(const struct AudioKcontrol *kcontrol, uint { struct AudioCard *audioCard = NULL; struct AudioSapmpath *path = NULL; - int ret; + int ret = HDF_SUCCESS; if (kcontrol == NULL || kcontrol->pri == NULL) { ADM_LOG_ERR("input param kcontrol is NULL."); @@ -1123,13 +1222,13 @@ int32_t AudioCodecSapmSetCtrlOps(const struct AudioKcontrol *kcontrol, const str ADM_LOG_ERR("Device read register is failure!"); return HDF_FAILURE; } - if (MixerUpdatePowerStatus(kcontrol, pathStatus) != HDF_SUCCESS) { - ADM_LOG_ERR("update power status is failure!"); - return HDF_FAILURE; - } curValue &= mixerCtrl->mask << mixerCtrl->shift; value = (value & mixerCtrl->mask) << mixerCtrl->shift; - if (curValue != value) { + if (curValue != value || g_audioSapmIsSleep == true) { + if (MixerUpdatePowerStatus(kcontrol, pathStatus) != HDF_SUCCESS) { + ADM_LOG_ERR("update power status is failure!"); + return HDF_FAILURE; + } if (AudioUpdateCodecRegBits(codec, mixerCtrl, elemValue->value[0]) != HDF_SUCCESS) { ADM_LOG_ERR("update reg bits fail!"); return HDF_FAILURE; @@ -1162,7 +1261,7 @@ int32_t AudioAccessorySapmSetCtrlOps(const struct AudioKcontrol *kcontrol, const } curValue &= mixerCtrl->mask << mixerCtrl->shift; value = (value & mixerCtrl->mask) << mixerCtrl->shift; - if (curValue != value) { + if (curValue != value || g_audioSapmIsSleep == true) { if (MixerUpdatePowerStatus(kcontrol, pathStatus) != HDF_SUCCESS) { ADM_LOG_ERR("update power status fail!"); return HDF_FAILURE; @@ -1176,13 +1275,14 @@ int32_t AudioAccessorySapmSetCtrlOps(const struct AudioKcontrol *kcontrol, const return HDF_SUCCESS; } -uint64_t AudioSapmRefreshTime(bool bRefresh) +static uint64_t AudioSapmRefreshTime(bool bRefresh) { static uint64_t time = 0; if (bRefresh) { time = OsalGetSysTimeMs(); g_audioSapmIsSleep = false; + g_audioSapmIsStandby = false; } return time; } @@ -1232,7 +1332,7 @@ int32_t AudioSampSetPowerMonitor(struct AudioCard *card, bool powerMonitorState) return HDF_SUCCESS; } -static void AudioSapmEnterSleepSub(uintptr_t para, struct AudioSapmComponent *sapmComponent) +static void AudioSapmEnterSleepSub(const uintptr_t para, struct AudioSapmComponent *sapmComponent) { struct DListHead downList; struct AudioCard *audioCard = (struct AudioCard *)para; @@ -1274,19 +1374,22 @@ static void AudioSapmEnterSleep(uintptr_t para) return; } - if (!AudioSapmCheckTime()) { - return; + if (audioCard->standbyMode != AUDIO_SAPM_TURN_STANDBY_NOW) { + if (!AudioSapmCheckTime()) { + return; + } } - DLIST_FOR_EACH_ENTRY(sapmComponent, &audioCard->components, struct AudioSapmComponent, list) { - if (sapmComponent->PowerClockOp != NULL) { - if (g_audioSapmIsStandby == false) { - sapmComponent->PowerClockOp(sapmComponent); - g_audioSapmIsStandby = true; - AudioSapmRefreshTime(true); - } + if (g_audioSapmIsStandby == false) { + DLIST_FOR_EACH_ENTRY(sapmComponent, &audioCard->components, struct AudioSapmComponent, list) { + if (sapmComponent->PowerClockOp != NULL) { + sapmComponent->PowerClockOp(sapmComponent); + AudioSapmRefreshTime(true); + } } + g_audioSapmIsStandby = true; } + if (g_audioSapmIsStandby == true) { if (!AudioSapmCheckTime()) { return; diff --git a/model/audio/sapm/test/unittest/common/audio_sapm_test.cpp b/model/audio/sapm/test/unittest/common/audio_sapm_test.cpp index 7d700a9daad2029db9bf27da8cd7f4659d900f27..2dcd590d3ebbd950e7f122abc5835a7345b46b35 100755 --- a/model/audio/sapm/test/unittest/common/audio_sapm_test.cpp +++ b/model/audio/sapm/test/unittest/common/audio_sapm_test.cpp @@ -11,7 +11,7 @@ #include "hdf_uhdf_test.h" using namespace testing::ext; - +namespace { class AudioSapmTest : public testing::Test { public: static void SetUpTestCase(); @@ -38,32 +38,63 @@ void AudioSapmTest::TearDown() { } -HWTEST_F(AudioSapmTest, AudioSapmTest001, TestSize.Level0) +HWTEST_F(AudioSapmTest, AudioSapmTest_AudioSapmNewComponents, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOSAPMNEWCOMPONENTS, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioSapmTest, AudioSapmTest_AudioSapmAddRoutes, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOSAPMADDROUTES, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioSapmTest, AudioSapmTest_AudioSapmNewControls, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOSAPMNEWCONTROLS, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioSapmTest, AudioSapmTest_AudioSapmSleep, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOSAPMSLEEP, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +HWTEST_F(AudioSapmTest, AudioSapmTest_AudioSampPowerUp, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTNEWCOMPONENT, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOSAMPPOWERUP, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioSapmTest, AudioSapmTest002, TestSize.Level0) +HWTEST_F(AudioSapmTest, AudioSapmTest_AudioSampSetPowerMonitor, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTADDROUTES, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOSAMPSETPOWERMONITOR, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioSapmTest, AudioSapmTest003, TestSize.Level0) +HWTEST_F(AudioSapmTest, AudioSapmTest_AudioCodecSapmSetCtrlOps, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTNEWCONTROLS, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOCODECSAPMSETCTRLOPS, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioSapmTest, AudioSapmTest004, TestSize.Level0) +HWTEST_F(AudioSapmTest, AudioSapmTest_AudioCodecSapmGetCtrlOps, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTPOWERCOMPONET, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOCODECSAPMGETCTRLOPS, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } -HWTEST_F(AudioSapmTest, AudioSapmTest005, TestSize.Level0) +HWTEST_F(AudioSapmTest, AudioSapmTest_AudioAccessorySapmSetCtrlOps, TestSize.Level1) { - struct HdfTestMsg msg = {g_testAudioType, TESTREFRESHTIME, -1}; + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOACCESSORYSAPMSETCTRLOPS, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } + +HWTEST_F(AudioSapmTest, AudioSapmTest_AudioAccessorySapmGetCtrlOps, TestSize.Level1) +{ + struct HdfTestMsg msg = {g_testAudioType, TEST_AUDIOACCESSORYSAPMGETCTRLOPS, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +} diff --git a/model/display/driver/backlight/hdf_bl.c b/model/display/driver/backlight/hdf_bl.c index 1f0743961a1944d4fac2476ebf1fbcdc75aca80d..8caa4f59bc8cdce5a3f251591ae1a483c3090383 100644 --- a/model/display/driver/backlight/hdf_bl.c +++ b/model/display/driver/backlight/hdf_bl.c @@ -9,7 +9,6 @@ #include "hdf_bl.h" #include #include "hdf_base.h" -#include "hdf_disp.h" #include "hdf_log.h" #include "osal.h" diff --git a/model/display/driver/backlight/pwm_bl.c b/model/display/driver/backlight/pwm_bl.c index c3710b4ffa994f424d4eabf2fec620648e686211..f2dc3ac7aecabfb6e86fafe4df6057dea2d2373d 100644 --- a/model/display/driver/backlight/pwm_bl.c +++ b/model/display/driver/backlight/pwm_bl.c @@ -48,18 +48,16 @@ static int32_t BlPwmUpdateBrightness(struct BacklightDev *blDev, uint32_t bright HDF_LOGE("%s maxBrightness is 0", __func__); return HDF_FAILURE; } + if (brightness == 0) { + return PwmDisable(blPwmDev->pwmHandle); + } duty = (brightness * blPwmDev->config.period) / blPwmDev->props.maxBrightness; ret = PwmSetDuty(blPwmDev->pwmHandle, duty); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: PwmSetDutyCycle failed, ret %d", __func__, ret); + HDF_LOGE("%s: PwmSetDuty failed, ret %d", __func__, ret); return HDF_FAILURE; } - if (brightness != 0) { - ret = PwmEnable(blPwmDev->pwmHandle); - } else { - ret = PwmDisable(blPwmDev->pwmHandle); - } - return ret; + return PwmEnable(blPwmDev->pwmHandle); } static struct BacklightOps g_blDevOps = { @@ -183,4 +181,4 @@ struct HdfDriverEntry g_pwmBlDevEntry = { .Init = BlPwmEntryInit, }; -HDF_INIT(g_pwmBlDevEntry); \ No newline at end of file +HDF_INIT(g_pwmBlDevEntry); diff --git a/model/display/driver/hdf_disp.c b/model/display/driver/hdf_disp.c index 8d7d2603a0c6382144d80a2801294a02b030d326..c599bc17d20dd406adaed55c3111cd116cb3f772 100644 --- a/model/display/driver/hdf_disp.c +++ b/model/display/driver/hdf_disp.c @@ -9,6 +9,7 @@ #include "hdf_disp.h" #include #include "hdf_base.h" +#include "hdf_bl.h" #include "hdf_log.h" #include "osal.h" @@ -109,8 +110,8 @@ static int32_t SetDispBacklight(uint32_t devId, uint32_t level) if (disp && disp->panelManager && devId < disp->panelManager->panelNum) { panel = disp->panelManager->panel[devId]; } - if (UpdateBrightness(panel->blDev, level) != HDF_SUCCESS) { - HDF_LOGE("%s:UpdateBrightness failed", __func__); + if ((panel == NULL) || (UpdateBrightness(panel->blDev, level) != HDF_SUCCESS)) { + HDF_LOGE("%s:panel is null or UpdateBrightness failed", __func__); return HDF_FAILURE; } HDF_LOGI("%s:level = %u", __func__, level); @@ -172,7 +173,7 @@ static int32_t SetDispPower(uint32_t devId, uint32_t powerStatus) OsalMutexLock(&disp->dispMutex); if (panel->powerStatus == powerStatus) { OsalMutexUnlock(&disp->dispMutex); - HDF_LOGE("%s:devId[%d] already in mode = %d", __func__, devId, powerStatus); + HDF_LOGE("%s: panel already in mode = %d", __func__, powerStatus); return HDF_SUCCESS; } switch (powerStatus) { @@ -289,6 +290,7 @@ static int32_t GetBacklight(struct HdfDeviceObject *device, struct HdfSBuf *reqD HDF_LOGE("%s: get panel failed", __func__); return HDF_FAILURE; } + panel = disp->panelManager->panel[devId]; if (GetCurrBrightness(panel->blDev, &currLevel) != HDF_SUCCESS) { HDF_LOGE("%s: GetCurrBrightness failed", __func__); return HDF_FAILURE; @@ -393,6 +395,10 @@ static void EsdTimerHandler(uintptr_t arg) struct DispManager *disp = NULL; disp = GetDispManager(); + if ((disp == NULL) || (disp->esd == NULL)) { + HDF_LOGE("%s: disp or esd is null", __func__); + return; + } if (devId >= disp->esd->panelNum) { HDF_LOGE("%s: esd is null", __func__); return; @@ -409,14 +415,20 @@ static void EsdWorkHandler(void *arg) struct DispManager *disp = NULL; disp = GetDispManager(); + if ((disp == NULL) || (disp->panelManager == NULL)) { + HDF_LOGE("%s: disp or panelManager is null", __func__); + return; + } if (devId >= disp->panelManager->panelNum) { HDF_LOGE("%s: dispCtrl is null or panel is null", __func__); return; } panel = disp->panelManager->panel[devId]; - if ((panel->esd != NULL) && (panel->esd->checkFunc != NULL)) { - ret = panel->esd->checkFunc(panel); + if ((panel->esd == NULL) || (panel->esd->checkFunc == NULL)) { + HDF_LOGE("%s: esd or checkFunc is null", __func__); + return; } + ret = panel->esd->checkFunc(panel); if (ret != HDF_SUCCESS) { OsalMutexLock(&disp->dispMutex); if (panel->esd->state == ESD_RUNNING) { @@ -429,7 +441,7 @@ static void EsdWorkHandler(void *arg) OsalMutexUnlock(&disp->dispMutex); panel->esd->recoveryNum++; } - HDF_LOGD("%s devId[%d] recoveryNum = %d", __func__, devId, panel->esd->recoveryNum); + HDF_LOGD("%s recoveryNum = %d", __func__, panel->esd->recoveryNum); if (panel->esd->recoveryNum >= ESD_MAX_RECOVERY) { panel->esd->recoveryNum = 0; OsalMutexLock(&disp->dispMutex); @@ -459,7 +471,7 @@ static void EsdCheckStartUp(struct DispEsd *esd, uint32_t devId) EsdTimerHandler, (uintptr_t)devId); OsalTimerStartLoop(esd->timer[devId]); esd->panelEsd[devId]->state = ESD_RUNNING; - HDF_LOGI("%s devId[%d] enable esd check", __func__, devId); + HDF_LOGI("%s panel enable esd check", __func__); } } } @@ -476,7 +488,7 @@ static void EsdCheckEnd(struct DispEsd *esd, uint32_t devId) if (esd->panelEsd[devId]->state == ESD_RUNNING) { OsalTimerDelete(esd->timer[devId]); esd->panelEsd[devId]->state = ESD_READY; - HDF_LOGI("%s devId[%d], disable esd check", __func__, devId); + HDF_LOGI("%s panel disable esd check", __func__); } } } diff --git a/model/display/driver/hdf_disp.h b/model/display/driver/hdf_disp.h index d9c6d9de18f0cb962a5fb8aa5cb76df80d37ba86..8f497d59634da7e43f19c63ba2b49476cab7e47a 100644 --- a/model/display/driver/hdf_disp.h +++ b/model/display/driver/hdf_disp.h @@ -10,7 +10,6 @@ #define HDF_DISP_H #include "hdf_base.h" -#include "hdf_bl.h" #include "hdf_device_desc.h" #include "hdf_log.h" #include "hdf_sbuf.h" diff --git a/model/display/driver/lcdkit/lite_lcdkit.c b/model/display/driver/lcdkit/lite_lcdkit.c index 7fdf1fb02372e76a12d823710df43edaf4a51959..b7b3cd4bca4b2f4b305b69b71b1f678f3df219c5 100644 --- a/model/display/driver/lcdkit/lite_lcdkit.c +++ b/model/display/driver/lcdkit/lite_lcdkit.c @@ -205,9 +205,9 @@ static int32_t SetBacklightByPwm(uint32_t level) return HDF_FAILURE; } duty = (level * panelCfg->info.pwm.period) / panelCfg->info.blk.maxLevel; - ret = PwmSetDutyCycle(panelCfg->pwmHandle, duty); + ret = PwmSetDuty(panelCfg->pwmHandle, duty); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: PwmSetDutyCycle failed", __func__); + HDF_LOGE("%s: PwmSetDuty failed", __func__); return HDF_FAILURE; } static uint32_t lastLevel = 0; diff --git a/model/display/driver/panel/ili9881c_boe.c b/model/display/driver/panel/ili9881c_boe.c index 96945d70ffa0fbf94c2f1b561cd370e59ae8d298..00a8e47885b0faee21d5edf52c93e4e1e86c7bcc 100644 --- a/model/display/driver/panel/ili9881c_boe.c +++ b/model/display/driver/panel/ili9881c_boe.c @@ -8,6 +8,7 @@ #include "ili9881c_boe.h" #include "gpio_if.h" +#include "hdf_bl.h" #include "hdf_disp.h" #include "osal.h" diff --git a/model/display/driver/panel/mipi_icn9700.c b/model/display/driver/panel/mipi_icn9700.c index 59654c6bf9469751f2db0fcd9d335c2a2b8670db..99c1d49d5758bd026713505c3ee40a8170a3a68f 100644 --- a/model/display/driver/panel/mipi_icn9700.c +++ b/model/display/driver/panel/mipi_icn9700.c @@ -7,6 +7,7 @@ */ #include "gpio_if.h" +#include "hdf_bl.h" #include "hdf_disp.h" #include "hdf_log.h" #include "mipi_dsi_if.h" @@ -192,6 +193,8 @@ static int32_t Icn9700On(struct PanelData *panel) /* send mipi init code */ int32_t count = sizeof(g_OnCmd) / sizeof(g_OnCmd[0]); int32_t i; + /* set mipi to lp mode */ + MipiDsiSetLpMode(icn9700->mipiHandle); for (i = 0; i < count; i++) { ret = MipiDsiTx(icn9700->mipiHandle, &(g_OnCmd[i])); if (ret != HDF_SUCCESS) { @@ -221,6 +224,8 @@ static int32_t Icn9700Off(struct PanelData *panel) /* send mipi init code */ int32_t count = sizeof(g_offCmd) / sizeof(g_offCmd[0]); int32_t i; + /* set mipi to lp mode */ + MipiDsiSetLpMode(icn9700->mipiHandle); for (i = 0; i < count; i++) { ret = MipiDsiTx(icn9700->mipiHandle, &(g_offCmd[i])); if (ret != HDF_SUCCESS) { @@ -228,8 +233,6 @@ static int32_t Icn9700Off(struct PanelData *panel) return HDF_FAILURE; } } - /* set mipi to lp mode */ - MipiDsiSetLpMode(icn9700->mipiHandle); /* lcd reset power off */ ret = LcdResetOff(icn9700); if (ret != HDF_SUCCESS) { diff --git a/model/input/driver/event_hub.c b/model/input/driver/event_hub.c index 3055b95e169a59e6395838d46ca006d2295c07fb..dc2f52a6d19b3ce7a2d0aaf9001d6cd31cc0797a 100644 --- a/model/input/driver/event_hub.c +++ b/model/input/driver/event_hub.c @@ -26,12 +26,13 @@ void PushOnePackage(InputDevice *inputDev, uint32_t type, uint32_t code, int32_t { OsalTimespec time; EventPackage package = {0}; + InputManager *inputManager = GetInputManager(); if (inputDev == NULL) { HDF_LOGE("%s: parm is null", __func__); return; } - OsalMutexLock(&inputDev->mutex); + OsalMutexLock(&inputManager->mutex); package.type = type; package.code = code; package.value = value; @@ -65,5 +66,5 @@ void PushOnePackage(InputDevice *inputDev, uint32_t type, uint32_t code, int32_t HdfSbufFlush(inputDev->pkgBuf); inputDev->errFrameFlag = false; } - OsalMutexUnlock(&inputDev->mutex); + OsalMutexUnlock(&inputManager->mutex); } \ No newline at end of file diff --git a/model/input/driver/hdf_encoder.c b/model/input/driver/hdf_encoder.c new file mode 100644 index 0000000000000000000000000000000000000000..2185d5c1dff3555553bb08a28d5e5a5a5e52c189 --- /dev/null +++ b/model/input/driver/hdf_encoder.c @@ -0,0 +1,297 @@ +/* + * Copyright (c) 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_encoder.h" +#include "event_hub.h" +#include "gpio_if.h" +#include "hdf_device_desc.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "osal_timer.h" + +#define TIMER_INTERVAL_ENCODER 5 + +static void EncoderTimerFunc(uintptr_t arg) +{ + int32_t ret; + EncoderDriver *encoderDrv = (EncoderDriver *)arg; + uint16_t gpioClk = encoderDrv->encoderCfg->gpioClk; + uint16_t gpioData = encoderDrv->encoderCfg->gpioData; + uint16_t gpioSW = encoderDrv->encoderCfg->gpioSW; + + ret = GpioRead(gpioClk, &encoderDrv->encoderClkNowSta); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret); + return; + } + ret = GpioRead(gpioData, &encoderDrv->encoderDataNowSta); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret); + return; + } + ret = GpioRead(gpioSW, &encoderDrv->encoderSWNowSta); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret); + return; + } + + if (encoderDrv->encoderClkNowSta != encoderDrv->encoderClkPreSta) { + if (encoderDrv->encoderClkNowSta == 0) { + if (encoderDrv->encoderDataNowSta == 1) { + input_report_rel(encoderDrv->inputDev, REL_WHEEL, 1); + } else { + input_report_rel(encoderDrv->inputDev, REL_WHEEL, -1); + } + input_sync(encoderDrv->inputDev); + } + encoderDrv->encoderClkPreSta = encoderDrv->encoderClkNowSta; + encoderDrv->encoderDataPreSta = encoderDrv->encoderDataNowSta; + } + if (encoderDrv->encoderSWPreSta != encoderDrv->encoderSWNowSta) { + if (encoderDrv->encoderSWNowSta == 0) { + input_report_key(encoderDrv->inputDev, KEY_OK, 0); + } else { + input_report_key(encoderDrv->inputDev, KEY_OK, 1); + } + encoderDrv->encoderSWPreSta = encoderDrv->encoderSWNowSta; + input_sync(encoderDrv->inputDev); + } +} + +static EncoderCfg *EncoderConfigInstance(struct HdfDeviceObject *device) +{ + int32_t ret; + EncoderCfg *encoderCfg = (EncoderCfg *)OsalMemAlloc(sizeof(EncoderCfg)); + if (encoderCfg == NULL) { + HDF_LOGE("%s: malloc encoder config failed", __func__); + return NULL; + } + ret = memset_s(encoderCfg, sizeof(EncoderCfg), 0, sizeof(EncoderCfg)); + if (ret != 0) { + HDF_LOGE("%s: memset_s encoder config failed", __func__); + OsalMemFree(encoderCfg); + return NULL; + } + encoderCfg->hdfEncoderDev = device; + + if (ParseEncoderConfig(device->property, encoderCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: parse encoder config failed", __func__); + OsalMemFree(encoderCfg); + return NULL; + } + return encoderCfg; +} + +static EncoderDriver *EncoderDriverInstance(EncoderCfg *encoderCfg) +{ + int32_t ret; + EncoderDriver *encoderDrv = (EncoderDriver *)OsalMemAlloc(sizeof(EncoderDriver)); + if (encoderDrv == NULL) { + HDF_LOGE("%s: malloc key driver failed", __func__); + return NULL; + } + ret = memset_s(encoderDrv, sizeof(EncoderDriver), 0, sizeof(EncoderDriver)); + if (ret != 0) { + HDF_LOGE("%s: memset encoder driver failed", __func__); + OsalMemFree(encoderDrv); + return NULL; + } + + encoderDrv->devType = encoderCfg->devType; + encoderDrv->encoderCfg = encoderCfg; + + return encoderDrv; +} + +static int32_t EncoderInit(EncoderDriver *EncoderDrv) +{ + int32_t ret; + uint16_t gpioClk = EncoderDrv->encoderCfg->gpioClk; + uint16_t gpioData = EncoderDrv->encoderCfg->gpioData; + uint16_t gpioSW = EncoderDrv->encoderCfg->gpioSW; + GpioSetDir(gpioClk, GPIO_DIR_IN); + GpioSetDir(gpioData, GPIO_DIR_IN); + GpioSetDir(gpioSW, GPIO_DIR_IN); + + ret = OsalTimerCreate(&EncoderDrv->timer, TIMER_INTERVAL_ENCODER, EncoderTimerFunc, EncoderDrv); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: create timer failed, ret = %d\n", __func__, ret); + return HDF_FAILURE; + } + ret = OsalTimerStartLoop(&EncoderDrv->timer); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: start timer failed, ret = %d\n", __func__, ret); + return HDF_FAILURE; + } + + ret = GpioRead(gpioClk, &EncoderDrv->encoderClkNowSta); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret); + return HDF_FAILURE; + } + ret = GpioRead(gpioData, &EncoderDrv->encoderDataNowSta); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret); + return HDF_FAILURE; + } + ret = GpioRead(gpioSW, &EncoderDrv->encoderSWNowSta); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret); + return HDF_FAILURE; + } + + EncoderDrv->encoderClkPreSta = EncoderDrv->encoderClkNowSta; + EncoderDrv->encoderDataPreSta = EncoderDrv->encoderDataNowSta; + + return HDF_SUCCESS; +} + +static InputDevice *InputDeviceInstance(EncoderDriver *encoderDrv) +{ + int32_t ret; + InputDevice *inputDev = (InputDevice *)OsalMemAlloc(sizeof(InputDevice)); + if (inputDev == NULL) { + HDF_LOGE("%s: malloc input device failed", __func__); + return NULL; + } + ret = memset_s(inputDev, sizeof(InputDevice), 0, sizeof(InputDevice)); + if (ret != 0) { + HDF_LOGE("%s: memset encoder driver failed", __func__); + OsalMemFree(inputDev); + return NULL; + } + + ret = OsalMutexInit(&inputDev->mutex); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Init mutex error", __func__); + OsalMemFree(inputDev); + return NULL; + } + + inputDev->pvtData = (void *)encoderDrv; + inputDev->devType = encoderDrv->devType; + inputDev->hdfDevObj = encoderDrv->encoderCfg->hdfEncoderDev; + encoderDrv->inputDev = inputDev; + + return inputDev; +} + +static int32_t RegisterEncoderDevice(EncoderCfg *encoderCfg, struct HdfDeviceObject *device) +{ + int32_t ret; + EncoderDriver *encoderDrv = EncoderDriverInstance(encoderCfg); + if (encoderDrv == NULL) { + HDF_LOGE("%s: instance encoder driver failed", __func__); + return HDF_ERR_MALLOC_FAIL; + } + device->priv = (void *)encoderDrv; + + ret = EncoderInit(encoderDrv); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: key driver init failed, ret %d", __func__, ret); + goto EXIT; + } + + InputDevice *inputDev = InputDeviceInstance(encoderDrv); + if (inputDev == NULL) { + HDF_LOGE("%s: instance input device failed", __func__); + goto EXIT; + } + + ret = RegisterInputDevice(inputDev); + if (ret != HDF_SUCCESS) { + goto EXIT1; + } + return HDF_SUCCESS; + +EXIT1: + OsalMemFree(inputDev->pkgBuf); + OsalMemFree(inputDev); +EXIT: + OsalMemFree(encoderDrv); + return HDF_FAILURE; +} + +static int32_t HdfEnCoderDriverInit(struct HdfDeviceObject *device) +{ + int32_t ret; + if (device == NULL) { + HDF_LOGE("%s: param is null", __func__); + return HDF_ERR_INVALID_PARAM; + } + + EncoderCfg *encoderCfg = EncoderConfigInstance(device); + if (encoderCfg == NULL) { + HDF_LOGE("%s: instance encoder config failed", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + ret = RegisterEncoderDevice(encoderCfg, device); + if (ret != HDF_SUCCESS) { + goto EXIT; + } + + HDF_LOGI("%s: exit succ!", __func__); + return HDF_SUCCESS; + +EXIT: + OsalMemFree(encoderCfg); + return HDF_FAILURE; +} + +static int32_t HdfEnCoderDispatch(struct HdfDeviceIoClient *client, int cmd, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)cmd; + if (client == NULL || data == NULL || reply == NULL) { + HDF_LOGE("%s: param is null", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static void HdfEncoderDriverRelease(struct HdfDeviceObject *device) +{ + EncoderDriver *driver = NULL; + InputDevice *inputDev = NULL; + + if (device == NULL || device->priv == NULL) { + HDF_LOGE("%s: param is null", __func__); + return; + } + driver = (EncoderDriver *)device->priv; + inputDev = driver->inputDev; + if (inputDev != NULL) { + UnregisterInputDevice(inputDev); + driver->inputDev = NULL; + } + OsalMemFree(driver); +} + +static int32_t HdfEnCoderDriverBind(struct HdfDeviceObject *device) +{ + if (device == NULL) { + return HDF_ERR_INVALID_PARAM; + } + static struct IDeviceIoService enCoderService = { + .object.objectId = 1, + .Dispatch = HdfEnCoderDispatch, + }; + device->service = &enCoderService; + return HDF_SUCCESS; +} + +struct HdfDriverEntry g_hdfEnCoderEntry = { + .moduleVersion = 1, + .moduleName = "HDF_ENCODER", + .Bind = HdfEnCoderDriverBind, + .Init = HdfEnCoderDriverInit, + .Release = HdfEncoderDriverRelease, +}; + +HDF_INIT(g_hdfEnCoderEntry); diff --git a/model/input/driver/hdf_encoder.h b/model/input/driver/hdf_encoder.h new file mode 100644 index 0000000000000000000000000000000000000000..9b65f42bcb855589208681f984898b3c77887430 --- /dev/null +++ b/model/input/driver/hdf_encoder.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 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_ENCODER_H +#define HDF_ENCODER_H + +#include +#include "hdf_device_object.h" +#include "hdf_input_device_manager.h" +#include "input_config.h" +#include "osal_time.h" +#include "osal_timer.h" + +typedef struct EncoderDriverInfo { + struct HdfDeviceObject *hdfEncoderDev; + uint8_t devType; + EncoderCfg *encoderCfg; + InputDevice *inputDev; + OsalTimer timer; + uint16_t encoderClkPreSta; + uint16_t encoderClkNowSta; + uint16_t encoderDataPreSta; + uint16_t encoderDataNowSta; + uint16_t encoderSWPreSta; + uint16_t encoderSWNowSta +} EncoderDriver; + +#endif \ No newline at end of file diff --git a/model/input/driver/hdf_hid_adapter.c b/model/input/driver/hdf_hid_adapter.c index 1ab568243f094cd993b56a0bfe06fdfb05d1d81e..b576193d1339dce23349f16674089cc1534b0d25 100644 --- a/model/input/driver/hdf_hid_adapter.c +++ b/model/input/driver/hdf_hid_adapter.c @@ -101,7 +101,7 @@ static void FreeCachedInfo(void) } } -static int32_t SetInputDevAbsAttr(InputDevice *inputDev, HidInfo *info) +static int32_t SetInputDevAbsAttr(InputDevice *inputDev, const HidInfo *info) { int32_t ret; for (int i = 0; i < BITS_TO_LONG(ABS_CNT); i++) { @@ -114,31 +114,11 @@ static int32_t SetInputDevAbsAttr(InputDevice *inputDev, HidInfo *info) return HDF_SUCCESS; } -static int32_t GetInfoFromCache(InputDevice *inputDev, HidInfo *info) +static void GetInfoFromCache(InputDevice *inputDev, const HidInfo *info) { - int32_t id = 0; - while (id < MAX_INPUT_DEV_NUM) { - if (g_cachedInfo[id] != NULL && !strcmp(inputDev->devName, g_cachedInfo[id]->devName)) { - info = g_cachedInfo[id]; - break; - } - id++; - } - if (id == MAX_INPUT_DEV_NUM || info == NULL) { - HDF_LOGE("%s: match cached info failed", __func__); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -static void SetInputDevAbility(InputDevice *inputDev) -{ - HidInfo *info = NULL; uint32_t len; int32_t ret; - ret = GetInfoFromCache(inputDev, info); - MEMCPY_CHECK_RETURN(ret); len = sizeof(unsigned long); ret = memcpy_s(inputDev->abilitySet.devProp, len * BITS_TO_LONG(INPUT_PROP_CNT), info->devProp, len * BITS_TO_LONG(INPUT_PROP_CNT)); @@ -176,6 +156,26 @@ static void SetInputDevAbility(InputDevice *inputDev) inputDev->attrSet.id.vendor = info->vendor; inputDev->attrSet.id.product = info->product; inputDev->attrSet.id.version = info->version; +} + +static void SetInputDevAbility(InputDevice *inputDev) +{ + HidInfo *info = NULL; + int32_t id = 0; + + while (id < MAX_INPUT_DEV_NUM) { + if (g_cachedInfo[id] != NULL && !strcmp(inputDev->devName, g_cachedInfo[id]->devName)) { + info = g_cachedInfo[id]; + break; + } + id++; + } + if (id == MAX_INPUT_DEV_NUM || info == NULL) { + HDF_LOGE("%s: match cached info failed", __func__); + return; + } + + GetInfoFromCache(inputDev, info); FreeCachedInfo(); } @@ -188,13 +188,6 @@ static InputDevice* HidConstructInputDev(HidInfo *info) } (void)memset_s(inputDev, sizeof(InputDevice), 0, sizeof(InputDevice)); - int32_t ret = OsalMutexInit(&inputDev->mutex); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: Init mutex error", __func__); - OsalMemFree(inputDev); - return NULL; - } - inputDev->devType = info->devType; inputDev->devName = info->devName; SetInputDevAbility(inputDev); diff --git a/model/input/driver/hdf_input_device_manager.c b/model/input/driver/hdf_input_device_manager.c index 9be0cce56e19eaeb8409ae4bc6f32f66e940eada..7f1a02fa0355ed1ae8b927da9a80322c853f4757 100644 --- a/model/input/driver/hdf_input_device_manager.c +++ b/model/input/driver/hdf_input_device_manager.c @@ -6,13 +6,13 @@ * See the LICENSE file in the root of this repository for complete details. */ -#include -#include "osal_mem.h" -#include "devsvc_manager_clnt.h" +#include "hdf_input_device_manager.h" +#include "event_hub.h" #include "hdf_base.h" +#include "hdf_device_object.h" #include "hdf_log.h" -#include "event_hub.h" -#include "hdf_input_device_manager.h" +#include "osal_mem.h" +#include #define NODE_MODE 0660 #define SERVICE_NAME_LEN 24 @@ -52,10 +52,24 @@ static struct HdfDeviceObject *HidRegisterHdfDevice(InputDevice *inputDev) return NULL; } - hdfDev = HdfRegisterDevice(moduleName, svcName, NULL); + hdfDev = HdfDeviceObjectAlloc(g_inputManager->hdfDevObj, moduleName); if (hdfDev == NULL) { - HDF_LOGE("%s: HdfRegisterDevice failed", __func__); + HDF_LOGE("%s: failed to alloc device object", __func__); + return NULL; + } + ret = HdfDeviceObjectRegister(hdfDev); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: failed to regitst device %s", __func__, moduleName); + HdfDeviceObjectRelease(hdfDev); + return NULL; } + ret = HdfDeviceObjectPublishService(hdfDev, svcName, SERVICE_POLICY_CAPACITY, 0664); // 0664:permission setting + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: failed to regitst device %s", __func__, moduleName); + HdfDeviceObjectRelease(hdfDev); + return NULL; + } + inputDev->hdfDevObj = hdfDev; HDF_LOGI("%s: svcName is %s, devName = %s", __func__, svcName, inputDev->devName); return hdfDev; } @@ -104,18 +118,8 @@ static int32_t CreateDeviceNode(InputDevice *inputDev) static void DeleteDeviceNode(InputDevice *inputDev) { if (IsHidDevice(inputDev->devType)) { - char svcName[SERVICE_NAME_LEN] = {0}; - const char *moduleName = "HDF_HID"; - - int32_t len = (inputDev->devId < PLACEHOLDER_LIMIT) ? 1 : PLACEHOLDER_LENGTH; - int32_t ret = snprintf_s(svcName, SERVICE_NAME_LEN, strlen("hdf_input_event") + len, "%s%u", - "hdf_input_event", inputDev->devId); - if (ret < 0) { - HDF_LOGE("%s: snprintf_s failed", __func__); - return; - } - HDF_LOGI("%s: svcName is %s, devName = %s", __func__, svcName, inputDev->devName); - HdfUnregisterDevice(moduleName, svcName); + HDF_LOGI("remove input device: hdf_input_event%u", inputDev->devId); + HdfDeviceObjectRelease(inputDev->hdfDevObj); } HDF_LOGI("%s: delete node succ, devId is %d", __func__, inputDev->devId); @@ -344,7 +348,6 @@ void UnregisterInputDevice(InputDevice *inputDev) } HdfSBufRecycle(inputDev->eventBuf); inputDev->eventBuf = NULL; - OsalMutexDestroy(&inputDev->mutex); OsalMemFree(inputDev); OsalMutexUnlock(&g_inputManager->mutex); HDF_LOGI("%s: exit succ, devCount is %d", __func__, g_inputManager->devCount); diff --git a/model/input/driver/hdf_input_device_manager.h b/model/input/driver/hdf_input_device_manager.h index 98d247d88b91cef0c54e753daf958bfe448e790e..35f454548cd27ef86554f2c0704ef470b119dd6c 100644 --- a/model/input/driver/hdf_input_device_manager.h +++ b/model/input/driver/hdf_input_device_manager.h @@ -112,7 +112,6 @@ typedef struct InputDeviceInfo { void *pvtData; DevAttr attrSet; DevAbility abilitySet; - struct OsalMutex mutex; struct InputDeviceInfo *next; } InputDevice; diff --git a/model/input/driver/hdf_key.c b/model/input/driver/hdf_key.c index 7df3cd819bd09b3bd707ae155e2709992a1f17d4..56ba4cb97c40b928f4511818593070c1f57d5119 100644 --- a/model/input/driver/hdf_key.c +++ b/model/input/driver/hdf_key.c @@ -23,6 +23,7 @@ int32_t KeyIrqHandle(uint16_t intGpioNum, void *data) { + int32_t ret; uint16_t gpioValue = 0; KeyDriver *driver = (KeyDriver *)data; if (driver == NULL) { @@ -32,7 +33,7 @@ int32_t KeyIrqHandle(uint16_t intGpioNum, void *data) if (event == NULL) { return HDF_FAILURE; } - int32_t ret = GpioDisableIrq(intGpioNum); + ret = GpioDisableIrq(intGpioNum); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: disable irq failed, ret %d", __func__, ret); @@ -143,13 +144,14 @@ static InputDevice *InputDeviceInstance(KeyDriver *keyDrv) static int32_t RegisterKeyDevice(KeyChipCfg *keyCfg) { + int32_t ret; KeyDriver *keyDrv = KeyDriverInstance(keyCfg); if (keyDrv == NULL) { HDF_LOGE("%s: instance key config failed", __func__); return HDF_ERR_MALLOC_FAIL; } - int32_t ret = KeyInit(keyDrv); + ret = KeyInit(keyDrv); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: key driver init failed, ret %d", __func__, ret); goto EXIT; @@ -178,6 +180,7 @@ EXIT: static int32_t HdfKeyDriverInit(struct HdfDeviceObject *device) { + int32_t ret; HDF_LOGI("%s: enter", __func__); if (device == NULL) { return HDF_ERR_INVALID_PARAM; @@ -189,7 +192,7 @@ static int32_t HdfKeyDriverInit(struct HdfDeviceObject *device) return HDF_ERR_MALLOC_FAIL; } - int32_t ret = RegisterKeyDevice(keyCfg); + ret = RegisterKeyDevice(keyCfg); if (ret != HDF_SUCCESS) { goto EXIT; } diff --git a/model/input/driver/hdf_touch.c b/model/input/driver/hdf_touch.c index 9a1264e393bec4854021d7f5dc36725aee575fba..5d8dd00d628fe5ff9b925324e4f7c1c9863a31ff 100644 --- a/model/input/driver/hdf_touch.c +++ b/model/input/driver/hdf_touch.c @@ -294,12 +294,6 @@ static InputDevice *InputDeviceInstance(ChipDevice *chipDev) inputDev->devType = chipDev->driver->boardCfg->attr.devType; inputDev->devName = chipDev->driver->devName; - int32_t ret = OsalMutexInit(&inputDev->mutex); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: Init mutex error", __func__); - OsalMemFree(inputDev); - return NULL; - } return inputDev; } @@ -352,7 +346,7 @@ static int32_t DeviceBindDriver(ChipDevice *chipDev) return HDF_SUCCESS; } -int32_t RegisterChipDevice(ChipDevice *chipDev) +int32_t RegisterTouchChipDevice(ChipDevice *chipDev) { int32_t ret; InputDevice *inputDev = NULL; @@ -462,13 +456,14 @@ static int32_t TouchGetDeviceStrInfo(TouchDriver *driver, int32_t cmd, struct Hd static int32_t TouchGetDeviceAttr(TouchDriver *driver, struct HdfSBuf *reply) { + char *tempStr = "main_touch"; + int32_t ret; if (driver->inputDev == NULL) { return HDF_FAILURE; } HDF_LOGE("%s: enter", __func__); - char *tempStr = "main_touch"; - int32_t ret = strncpy_s(driver->inputDev->attrSet.devName, DEV_NAME_LEN, tempStr, strlen(tempStr)); + ret = strncpy_s(driver->inputDev->attrSet.devName, DEV_NAME_LEN, tempStr, strlen(tempStr)); if (ret != 0) { HDF_LOGE("%s: strncpy dev attr failed", __func__); return HDF_FAILURE; diff --git a/model/input/driver/hdf_touch.h b/model/input/driver/hdf_touch.h index f8ed6ce5c094d5f0bb050ea307040d785518b5bd..248273d43cc81a662d9fb9d48f02e09e107e070b 100644 --- a/model/input/driver/hdf_touch.h +++ b/model/input/driver/hdf_touch.h @@ -107,6 +107,6 @@ typedef struct { const char *cmdValue; } InputExtraCmd; -int32_t RegisterChipDevice(ChipDevice *chipDev); +int32_t RegisterTouchChipDevice(ChipDevice *chipDev); #endif diff --git a/model/input/driver/input_config.h b/model/input/driver/input_config.h index e44d400cc9baaa9acdaca5f36ef1e03eed95ce0a..ee25b9f2c503a3d2ba82b59aaf6eb5ff4a8b3f1f 100644 --- a/model/input/driver/input_config.h +++ b/model/input/driver/input_config.h @@ -140,8 +140,17 @@ typedef struct { uint32_t debounceTime; } KeyChipCfg; +typedef struct { + struct HdfDeviceObject *hdfEncoderDev; + uint8_t devType; + uint16_t gpioClk; + uint16_t gpioData; + uint16_t gpioSW; +} EncoderCfg; + int32_t ParseTouchBoardConfig(const struct DeviceResourceNode *node, TouchBoardCfg *config); int32_t ParseTouchChipConfig(const struct DeviceResourceNode *node, TouchChipCfg *config); int32_t ParseKeyConfig(const struct DeviceResourceNode *node, KeyChipCfg *config); +int32_t ParseEncoderConfig(const struct DeviceResourceNode *node, EncoderCfg *config); #endif \ No newline at end of file diff --git a/model/input/driver/input_config_parser.c b/model/input/driver/input_config_parser.c index f6c49ebab1c2fe2f6cf6ecfd14e5dd36475307bf..17f65dd27edbd23f2d3fbc824b04b6c7f481cef0 100644 --- a/model/input/driver/input_config_parser.c +++ b/model/input/driver/input_config_parser.c @@ -25,12 +25,13 @@ int32_t ParseKeyConfig(const struct DeviceResourceNode *node, KeyChipCfg *config) { + int32_t ret; + struct DeviceResourceIface *parser = NULL; if (node == NULL || config == NULL) { HDF_LOGE("%s: param is null", __func__); return HDF_FAILURE; } - struct DeviceResourceIface *parser = NULL; parser = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); if (parser == NULL) { HDF_LOGE("%s: instance parser failed", __func__); @@ -38,12 +39,12 @@ int32_t ParseKeyConfig(const struct DeviceResourceNode *node, KeyChipCfg *config } const struct DeviceResourceNode *keyNode = node; - int32_t ret = parser->GetString(keyNode, "keyName", &config->keyName, NULL); + ret = parser->GetString(keyNode, "keyName", &config->keyName, NULL); CHECK_PARSER_RET(ret, "GetString"); ret = parser->GetUint8(keyNode, "inputType", &config->devType, 0); CHECK_PARSER_RET(ret, "GetUint8"); ret = parser->GetUint16(keyNode, "gpioNum", &config->gpioNum, 0); - CHECK_PARSER_RET(ret, "GetUint32"); + CHECK_PARSER_RET(ret, "GetUint16"); ret = parser->GetUint16(keyNode, "irqFlag", &config->irqFlag, 0); CHECK_PARSER_RET(ret, "GetUint8"); ret = parser->GetUint32(keyNode, "debounceTime", &config->debounceTime, 0); @@ -52,6 +53,33 @@ int32_t ParseKeyConfig(const struct DeviceResourceNode *node, KeyChipCfg *config return HDF_SUCCESS; } +int32_t ParseEncoderConfig(const struct DeviceResourceNode *node, EncoderCfg *config) +{ + if (node == NULL || config == NULL) { + HDF_LOGE("%s: param is null", __func__); + return HDF_FAILURE; + } + + struct DeviceResourceIface *parser = NULL; + parser = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (parser == NULL) { + HDF_LOGE("%s: instance parser failed", __func__); + return HDF_FAILURE; + } + + const struct DeviceResourceNode *encoderNode = node; + int32_t ret = parser->GetUint8(encoderNode, "inputType", &config->devType, 0); + CHECK_PARSER_RET(ret, "GetUint8"); + ret = parser->GetUint16(encoderNode, "gpioClk", &config->gpioClk, 0); + CHECK_PARSER_RET(ret, "GetUint16"); + ret = parser->GetUint16(encoderNode, "gpioDT", &config->gpioData, 0); + CHECK_PARSER_RET(ret, "GetUint16"); + ret = parser->GetUint16(encoderNode, "gpioSW", &config->gpioSW, 0); + CHECK_PARSER_RET(ret, "GetUint16"); + + return HDF_SUCCESS; +} + static int32_t ParseAttr(struct DeviceResourceIface *parser, const struct DeviceResourceNode *attrNode, BoardAttrCfg *attr) { diff --git a/model/input/driver/touchscreen/touch_ft6336.c b/model/input/driver/touchscreen/touch_ft6336.c index 87a006fbe9ae201821a827a713b1b69753fc0da2..422439d2aabf441a9433f46c5c9b5570c0e38d9a 100644 --- a/model/input/driver/touchscreen/touch_ft6336.c +++ b/model/input/driver/touchscreen/touch_ft6336.c @@ -92,10 +92,11 @@ static int32_t ChipDataHandle(ChipDevice *device) uint8_t buf[POINT_BUFFER_LEN] = {0}; uint8_t reg = 0x0; uint8_t pointNum; + int32_t ret; InputI2cClient *i2cClient = &device->driver->i2cClient; FrameData *frame = &device->driver->frameData; - int32_t ret = InputI2cRead(i2cClient, ®, 1, buf, POINT_BUFFER_LEN); + ret = InputI2cRead(i2cClient, ®, 1, buf, POINT_BUFFER_LEN); CHIP_CHECK_RETURN(ret); OsalMutexLock(&device->driver->mutex); @@ -196,7 +197,7 @@ static int32_t HdfFocalChipInit(struct HdfDeviceObject *device) chipDev->chipName = chipCfg->chipName; chipDev->vendorName = chipCfg->vendorName; - if (RegisterChipDevice(chipDev) != HDF_SUCCESS) { + if (RegisterTouchChipDevice(chipDev) != HDF_SUCCESS) { goto EXIT1; } HDF_LOGI("%s: exit succ, chipName = %s", __func__, chipCfg->chipName); diff --git a/model/input/driver/touchscreen/touch_gt911.c b/model/input/driver/touchscreen/touch_gt911.c index fb3f5e96fd5b5a29ff710d3e0fdc4d825124f4bb..5936d8f333c11ddd23aaccbac8c06387edd09acc 100644 --- a/model/input/driver/touchscreen/touch_gt911.c +++ b/model/input/driver/touchscreen/touch_gt911.c @@ -248,6 +248,10 @@ static ChipDevice *ChipDeviceInstance(void) static void FreeChipConfig(TouchChipCfg *config) { + if (config == NULL) { + HDF_LOGE("%s: param is null", __func__); + return; + } if (config->pwrSeq.pwrOn.buf != NULL) { OsalMemFree(config->pwrSeq.pwrOn.buf); } @@ -291,8 +295,9 @@ static int32_t HdfGoodixChipInit(struct HdfDeviceObject *device) chipDev->ops = &g_gt911ChipOps; chipDev->chipName = chipCfg->chipName; chipDev->vendorName = chipCfg->vendorName; + device->priv = (void *)chipDev; - if (RegisterChipDevice(chipDev) != HDF_SUCCESS) { + if (RegisterTouchChipDevice(chipDev) != HDF_SUCCESS) { goto EXIT1; } HDF_LOGI("%s: exit succ, chipName = %s", __func__, chipCfg->chipName); @@ -305,10 +310,20 @@ EXIT: return HDF_FAILURE; } +static void HdfGoodixChipRelease(struct HdfDeviceObject *device) +{ + if (device == NULL || device->priv == NULL) { + HDF_LOGE("%s: param is null", __func__); + return; + } + HDF_LOGI("%s: goodix chip is release", __func__); +} + struct HdfDriverEntry g_touchGoodixChipEntry = { .moduleVersion = 1, .moduleName = "HDF_TOUCH_GT911", .Init = HdfGoodixChipInit, + .Release = HdfGoodixChipRelease, }; HDF_INIT(g_touchGoodixChipEntry); diff --git a/model/misc/dsoftbus/include/module_manager.h b/model/misc/dsoftbus/include/module_manager.h index a59ef5fe1b4ab0127010b1ed12b8fee25949efdf..19464c647f9725753221518a8f730890becf4810 100644 --- a/model/misc/dsoftbus/include/module_manager.h +++ b/model/misc/dsoftbus/include/module_manager.h @@ -19,6 +19,7 @@ extern "C" { typedef enum { SOFTBUS_MODULE_WLAN_PARAM_MONITOR = 0, + SOFTBUS_MODULE_LWIP_MONITOR, SOFTBUS_MODULE_MAX_INDEX, } SoftbusDriverModuleId; diff --git a/model/misc/dsoftbus/src/module_manager.c b/model/misc/dsoftbus/src/module_manager.c index ea9f741bba0f9633582c80784342ca257173b562..6dc8b25e1267a827de6dd5e72f14f6d9d50ff750 100644 --- a/model/misc/dsoftbus/src/module_manager.c +++ b/model/misc/dsoftbus/src/module_manager.c @@ -9,6 +9,9 @@ #include "module_manager.h" #include "hdf_log.h" +#ifdef ENABLE_LWIP_MONITOR +#include "softbus_lwip_monitor.h" +#endif #ifdef ENABLE_WLAN_PARAM_MONITOR #include "wlan_param_monitor.h" #endif @@ -16,10 +19,17 @@ #define HDF_LOG_TAG "hdf_dsoftbus" static SoftbusDriverModule g_modules[] = { +#ifdef ENABLE_LWIP_MONITOR + { + .init = SoftbusLwipMonitorInit, + .deinit = NULL, + .process = NULL, + }, +#endif #ifdef ENABLE_WLAN_PARAM_MONITOR { .init = SoftbusWlanParamMonitorInit, - .deinit = SoftbusWlanParamMonitorDeinit, + .deinit = NULL, .process = SoftbusWlanParamMonitorProcess, }, #endif @@ -40,7 +50,7 @@ void SoftbusDispatchModuleCommand(int32_t moduleId, const struct HdfSBuf *reqDat g_modules[i].process(reqData, rspData); return; } - HDF_LOGE("no moduleId: %d registered", moduleId); + HDF_LOGE("no moduleId: %d process command", moduleId); } int32_t SoftbusModuleManagerInit(struct HdfDeviceObject *device) diff --git a/model/misc/dsoftbus/src/wlan_param_monitor.c b/model/misc/dsoftbus/src/wlan_param_monitor.c index 07eeb8309a9ce03cffbda2ab6de49d26dae04e8b..d06fa4fec040b7b70c83d0f9bad941b17594af30 100644 --- a/model/misc/dsoftbus/src/wlan_param_monitor.c +++ b/model/misc/dsoftbus/src/wlan_param_monitor.c @@ -12,15 +12,13 @@ #include "hdf_log.h" #include "module_manager.h" #include "osal_time.h" -#include "osal_timer.h" #define HDF_LOG_TAG "wlan_param_monitor" #define WLAN_PARAM_REPORT_INTERVAL 1000 typedef enum { - CMD_START_MONITOR = 0, - CMD_STOP_MONITOR, + CMD_REQUEST_PARAM = 0, CMD_MAX_INDEX } Command; @@ -29,26 +27,16 @@ typedef enum { EVENT_MAX_INDEX } Event; -typedef struct { - OSAL_DECLARE_TIMER(timer); - bool isTimerStart; -} WlanParamMonitorCtrl; - typedef struct { uint32_t event; uint32_t value; } ReportInfo; -static WlanParamMonitorCtrl g_wlanParamMonitorCtrl = { - .isTimerStart = false, -}; - -static void WlanParamReportTimer(uintptr_t arg) +static void ProcessRequestParam(void) { ReportInfo info; struct HdfSBuf *data = NULL; - (void)arg; info.event = EVENT_WLAN_PARAM; info.value = (uint32_t)OsalGetSysTimeMs(); data = HdfSBufObtainDefaultSize(); @@ -65,38 +53,6 @@ static void WlanParamReportTimer(uintptr_t arg) HdfSBufRecycle(data); } -static void ProcessStartMonitor(void) -{ - if (g_wlanParamMonitorCtrl.isTimerStart) { - HDF_LOGE("wlan param monitor timer is already started"); - return; - } - if (OsalTimerCreate(&g_wlanParamMonitorCtrl.timer, WLAN_PARAM_REPORT_INTERVAL, - WlanParamReportTimer, 0) != HDF_SUCCESS) { - HDF_LOGE("create wlan param monitor timer fail"); - return; - } - if (OsalTimerStartLoop(&g_wlanParamMonitorCtrl.timer) != HDF_SUCCESS) { - OsalTimerDelete(&g_wlanParamMonitorCtrl.timer); - HDF_LOGE("start wlan param monitor timer fail"); - return; - } - g_wlanParamMonitorCtrl.isTimerStart = true; -} - -static void ProcessStopMonitor(void) -{ - if (!g_wlanParamMonitorCtrl.isTimerStart) { - HDF_LOGE("wlan param monitor timer is not started"); - return; - } - if (OsalTimerDelete(&g_wlanParamMonitorCtrl.timer) != HDF_SUCCESS) { - HDF_LOGE("delete wlan param monitor timer fail"); - } else { - g_wlanParamMonitorCtrl.isTimerStart = false; - } -} - int32_t SoftbusWlanParamMonitorInit(struct HdfDeviceObject *device) { (void)device; @@ -104,13 +60,6 @@ int32_t SoftbusWlanParamMonitorInit(struct HdfDeviceObject *device) return HDF_SUCCESS; } -void SoftbusWlanParamMonitorDeinit(void) -{ - if (g_wlanParamMonitorCtrl.isTimerStart) { - ProcessStartMonitor(); - } -} - void SoftbusWlanParamMonitorProcess(const struct HdfSBuf *reqData, struct HdfSBuf *rspData) { uint32_t cmd; @@ -128,14 +77,7 @@ void SoftbusWlanParamMonitorProcess(const struct HdfSBuf *reqData, struct HdfSBu } cmd = *((uint32_t *)data); HDF_LOGI("process command: %d", cmd); - switch (cmd) { - case CMD_START_MONITOR: - ProcessStartMonitor(); - break; - case CMD_STOP_MONITOR: - ProcessStopMonitor(); - break; - default: - break; + if (cmd == CMD_REQUEST_PARAM) { + ProcessRequestParam(); } } \ No newline at end of file diff --git a/model/misc/vibrator/driver/chipset/vibrator_linear_driver.c b/model/misc/vibrator/driver/chipset/vibrator_linear_driver.c index 6f126069ece6d8f5dcfc15bc5e2689d0cc6e7584..b6959fca1960f76259fc71cfc29b166fb24dbe4a 100644 --- a/model/misc/vibrator/driver/chipset/vibrator_linear_driver.c +++ b/model/misc/vibrator/driver/chipset/vibrator_linear_driver.c @@ -82,9 +82,11 @@ static int32_t DispatchLinearVibrator(struct HdfDeviceIoClient *client, int32_t BindLinearVibratorDriver(struct HdfDeviceObject *device) { + struct VibratorLinearDriverData *drvData = NULL; + CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(device, HDF_FAILURE); - struct VibratorLinearDriverData *drvData = (struct VibratorLinearDriverData *)OsalMemCalloc(sizeof(*drvData)); + drvData = (struct VibratorLinearDriverData *)OsalMemCalloc(sizeof(*drvData)); CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_MALLOC_FAIL); drvData->ioService.Dispatch = DispatchLinearVibrator; @@ -99,6 +101,7 @@ static int32_t ParserLinearConfig(const struct DeviceResourceNode *node, struct { int32_t ret; struct DeviceResourceIface *parser = NULL; + const struct DeviceResourceNode *configNode = NULL; CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(node, HDF_FAILURE); CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(drvData, HDF_FAILURE); @@ -107,7 +110,7 @@ static int32_t ParserLinearConfig(const struct DeviceResourceNode *node, struct CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(parser, HDF_ERR_INVALID_PARAM); CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(parser->GetChildNode, HDF_ERR_INVALID_PARAM); - const struct DeviceResourceNode *configNode = parser->GetChildNode(node, "vibratorChipConfig"); + configNode = parser->GetChildNode(node, "vibratorChipConfig"); ret = parser->GetUint32(configNode, "busType", &drvData->busType, 0); CHECK_VIBRATOR_PARSER_RESULT_RETURN_VALUE(ret, "busType"); if (drvData->busType == VIBRATOR_BUS_GPIO) { @@ -128,10 +131,11 @@ static int32_t ParserLinearConfig(const struct DeviceResourceNode *node, struct int32_t InitLinearVibratorDriver(struct HdfDeviceObject *device) { static struct VibratorOps ops; + struct VibratorLinearDriverData *drvData = NULL; CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(device, HDF_FAILURE); - struct VibratorLinearDriverData *drvData = (struct VibratorLinearDriverData *)device->service; + drvData = (struct VibratorLinearDriverData *)device->service; CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(drvData, HDF_FAILURE); ops.Start = StartLinearVibrator; @@ -157,11 +161,13 @@ int32_t InitLinearVibratorDriver(struct HdfDeviceObject *device) void ReleaseLinearVibratorDriver(struct HdfDeviceObject *device) { + struct VibratorLinearDriverData *drvData = NULL; + if (device == NULL) { HDF_LOGE("%s: Device is null", __func__); return; } - struct VibratorLinearDriverData *drvData = (struct VibratorLinearDriverData *)device->service; + drvData = (struct VibratorLinearDriverData *)device->service; if (drvData == NULL) { HDF_LOGE("%s: DrvData pointer is null", __func__); return; diff --git a/model/misc/vibrator/driver/include/vibrator_haptic.h b/model/misc/vibrator/driver/include/vibrator_haptic.h index c6f4b10623a3bff6cbc6575ebc4504b2b5dcb24a..ec1d93d67f6e5468b90db080e99123e5e64c8fff 100644 --- a/model/misc/vibrator/driver/include/vibrator_haptic.h +++ b/model/misc/vibrator/driver/include/vibrator_haptic.h @@ -32,7 +32,8 @@ enum VibratorTimeSeqIndex { struct VibratorEffectNode { const char *effect; int32_t num; - uint32_t *seq; // The first element of seq is preset type referring to enum VibratorEffectType + uint32_t type; // preset type + uint32_t *seq; struct DListHead node; }; diff --git a/model/misc/vibrator/driver/src/vibrator_haptic.c b/model/misc/vibrator/driver/src/vibrator_haptic.c index 2fba10f7af56abd01a5c37eb7249de63eaaa2021..a4177106440bd8849f819373b1c273e36e1bf0f2 100644 --- a/model/misc/vibrator/driver/src/vibrator_haptic.c +++ b/model/misc/vibrator/driver/src/vibrator_haptic.c @@ -60,21 +60,20 @@ static int32_t ParserHapticEffect(struct DeviceResourceIface *parser, const stru int32_t ret; int32_t count; struct VibratorEffectNode *effectNode = NULL; - const struct DeviceResourceAttr *hapticAttr = NULL; + const struct DeviceResourceNode *childNode = NULL; struct VibratorHapticData *hapticData = GetHapticData(); CHECK_VIBRATOR_NULL_PTR_RETURN_VALUE(hapticData, HDF_FAILURE); (void)OsalMutexLock(&hapticData->mutex); - DEV_RES_NODE_FOR_EACH_ATTR(hapticNode, hapticAttr) { - if ((hapticAttr == NULL) || (hapticAttr->name == NULL)) { + DEV_RES_NODE_FOR_EACH_CHILD_NODE(hapticNode, childNode) { + if ((childNode == NULL) || (childNode->name == NULL)) { break; } - count = parser->GetElemNum(hapticNode, hapticAttr->name); - // Minimum of two elements, including the type and sequence. + count = parser->GetElemNum(childNode, "seq"); if (count <= 1 || count > VIBRATOR_HAPTIC_SEQ_MAX) { - HDF_LOGE("%s: haptic [%s] parser seq count fail", __func__, hapticAttr->name); + HDF_LOGE("%s: haptic [%s] parser seq count fail", __func__, childNode->name); continue; } @@ -83,10 +82,11 @@ static int32_t ParserHapticEffect(struct DeviceResourceIface *parser, const stru HDF_LOGE("%s: malloc effect effectNode fail", __func__); continue; } - effectNode->effect = hapticAttr->name; - ret = parser->GetUint32Array(hapticNode, hapticAttr->name, effectNode->seq, count, 0); - CHECK_VIBRATOR_PARSER_RESULT_RETURN_VALUE(ret, hapticAttr->name); effectNode->num = count; + ret = parser->GetString(childNode, "effectName", &effectNode->effect, NULL); + ret = parser->GetUint32(childNode, "type", &effectNode->type, 0); + ret = parser->GetUint32Array(childNode, "seq", effectNode->seq, count, 0); + DListInsertTail(&effectNode->node, &hapticData->effectSeqHead); } (void)OsalMutexUnlock(&hapticData->mutex); @@ -249,9 +249,10 @@ static int32_t GetHapticSeqByEffect(struct VibratorEffectCfg *effectCfg) if ((effectCfg->cfgMode == VIBRATOR_MODE_PRESET) && (effectCfg->effect != NULL)) { DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &hapticData->effectSeqHead, struct VibratorEffectNode, node) { if (strcmp(effectCfg->effect, pos->effect) == 0 && pos->seq != NULL) { - hapticData->effectType = pos->seq[0]; - hapticData->seqCount = pos->num - 1; - hapticData->currentEffectSeq = &(pos->seq[1]); + hapticData->effectType = pos->type; + HDF_LOGE("%s: pos_num = %d", __func__, pos->num); + hapticData->seqCount = pos->num; + hapticData->currentEffectSeq = &(pos->seq[0]); break; } } diff --git a/model/network/wifi/bus/hdf_ibus_intf.c b/model/network/wifi/bus/hdf_ibus_intf.c index 4139843752a5867966038f35e7cf7e50871b2987..8a0bde671bbb5750afa64e5006508af21f263949 100644 --- a/model/network/wifi/bus/hdf_ibus_intf.c +++ b/model/network/wifi/bus/hdf_ibus_intf.c @@ -19,14 +19,14 @@ extern "C" { struct BusDev *HdfWlanCreateBusManager(const struct HdfConfigWlanBus *busConfig) { + struct BusDev *bus = NULL; if (busConfig == NULL) { return NULL; } - struct BusDev *bus = (struct BusDev *)OsalMemCalloc(sizeof(struct BusDev)); + bus = (struct BusDev *)OsalMemCalloc(sizeof(struct BusDev)); if (bus == NULL) { return NULL; } - switch (busConfig->busType) { case BUS_SDIO: if (HdfSdioBusInit(bus, busConfig) != HDF_SUCCESS) { diff --git a/model/network/wifi/core/components/p2p/p2p.c b/model/network/wifi/core/components/p2p/p2p.c new file mode 100755 index 0000000000000000000000000000000000000000..279561a04737a130afb8d73160492e8e3d938cf6 --- /dev/null +++ b/model/network/wifi/core/components/p2p/p2p.c @@ -0,0 +1,400 @@ +/* + * 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 "p2p.h" +#include "message/message_router.h" +#include "message/sidecar.h" +#include "wifi_base.h" +#include "wifi_mac80211_ops.h" +#include "hdf_wlan_services.h" +#include "hdf_wlan_utils.h" + +#define HDF_LOG_TAG HDF_WIFI_CORE + +#ifdef __cplusplus +extern "C" { +#endif +static int32_t RemainOnChannel(struct NetDevice *netdev, WifiOnChannel *onChannel) +{ + struct HdfChipDriver *chipDriver = GetChipDriver(netdev); + if (chipDriver == NULL) { + HDF_LOGE("%s:bad net device found!", __func__); + return HDF_FAILURE; + } + + RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->p2pOps, RemainOnChannel); + return chipDriver->p2pOps->RemainOnChannel(netdev, onChannel); +} + +static int32_t WifiCmdRemainOnChannel(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) +{ + int32_t ret; + struct NetDevice *netdev = NULL; + const char *ifName = NULL; + WifiOnChannel wifiOnChannel = {0}; + + (void)context; + if (reqData == NULL || rspData == NULL) { + return HDF_ERR_INVALID_PARAM; + } + ifName = HdfSbufReadString(reqData); + if (ifName == NULL) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); + return HDF_FAILURE; + } + netdev = NetDeviceGetInstByName(ifName); + if (netdev == NULL) { + HDF_LOGE("%s: netdev not found!ifName=%s", __func__, ifName); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(reqData, &(wifiOnChannel.freq))) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "freq"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint32(reqData, &(wifiOnChannel.duration))) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "duration"); + return HDF_FAILURE; + } + ret = RemainOnChannel(netdev, &wifiOnChannel); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: fail to remain on channel,%d", __func__, ret); + } + return ret; +} + +static int32_t ProbeReqReport(struct NetDevice *netdev, int32_t report) +{ + struct HdfChipDriver *chipDriver = GetChipDriver(netdev); + if (chipDriver == NULL) { + HDF_LOGE("%s:bad net device found!", __func__); + return HDF_FAILURE; + } + + RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->p2pOps, ProbeReqReport); + return chipDriver->p2pOps->ProbeReqReport(netdev, report); +} + +static int32_t WifiCmdProbeReqReport(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) +{ + int32_t ret; + struct NetDevice *netdev = NULL; + const char *ifName = NULL; + int32_t report; + + (void)context; + if (reqData == NULL || rspData == NULL) { + return HDF_ERR_INVALID_PARAM; + } + ifName = HdfSbufReadString(reqData); + if (ifName == NULL) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); + return HDF_FAILURE; + } + netdev = NetDeviceGetInstByName(ifName); + if (netdev == NULL) { + HDF_LOGE("%s: netdev not found!ifName=%s", __func__, ifName); + return HDF_FAILURE; + } + if (!HdfSbufReadInt32(reqData, &(report))) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "report"); + return HDF_FAILURE; + } + + ret = ProbeReqReport(netdev, report); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: fail to probe req report,%d", __func__, ret); + } + return ret; +} + +static int32_t CancelRemainOnChannel(struct NetDevice *netdev) +{ + struct HdfChipDriver *chipDriver = GetChipDriver(netdev); + if (chipDriver == NULL) { + HDF_LOGE("%s:bad net device found!", __func__); + return HDF_FAILURE; + } + + RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->p2pOps, CancelRemainOnChannel); + return chipDriver->p2pOps->CancelRemainOnChannel(netdev); +} + +static int32_t WifiCmdCancelRemainOnChannel(const RequestContext *context, struct HdfSBuf *reqData, + struct HdfSBuf *rspData) +{ + int32_t ret; + struct NetDevice *netdev = NULL; + const char *ifName = NULL; + + (void)context; + if (reqData == NULL || rspData == NULL) { + return HDF_ERR_INVALID_PARAM; + } + ifName = HdfSbufReadString(reqData); + if (ifName == NULL) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); + return HDF_FAILURE; + } + netdev = NetDeviceGetInstByName(ifName); + if (netdev == NULL) { + HDF_LOGE("%s: netdev not found!ifName=%s", __func__, ifName); + return HDF_FAILURE; + } + + ret = CancelRemainOnChannel(netdev); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: fail to cancel remain on channel,%d", __func__, ret); + } + return ret; +} + +static int32_t AddIf(struct NetDevice *netdev, WifiIfAdd *ifAdd) +{ + struct HdfChipDriver *chipDriver = GetChipDriver(netdev); + if (chipDriver == NULL) { + HDF_LOGE("%s:bad net device found!", __func__); + return HDF_FAILURE; + } + + RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->p2pOps, AddIf); + return chipDriver->p2pOps->AddIf(netdev, ifAdd); +} + +static int32_t WifiCmdAddIf(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) +{ + int32_t ret; + struct NetDevice *netdev = NULL; + const char *ifName = NULL; + WifiIfAdd ifAdd = {0}; + + (void)context; + if (reqData == NULL || rspData == NULL) { + return HDF_ERR_INVALID_PARAM; + } + ifName = HdfSbufReadString(reqData); + if (ifName == NULL) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); + return HDF_FAILURE; + } + netdev = NetDeviceGetInstByName(ifName); + if (netdev == NULL) { + HDF_LOGE("%s: netdev not found!ifName=%s", __func__, ifName); + return HDF_FAILURE; + } + + if (!HdfSbufReadUint8(reqData, &(ifAdd.type))) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "type"); + return HDF_FAILURE; + } + + ret = AddIf(netdev, &ifAdd); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: fail to cancel remain on channel,%d", __func__, ret); + } + return ret; +} + +static int32_t RemoveIf(struct NetDevice *netdev, WifiIfRemove *ifRemove) +{ + struct HdfChipDriver *chipDriver = GetChipDriver(netdev); + if (chipDriver == NULL) { + HDF_LOGE("%s:bad net device found!", __func__); + return HDF_FAILURE; + } + + RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->p2pOps, RemoveIf); + return chipDriver->p2pOps->RemoveIf(netdev, ifRemove); +} + +static int32_t WifiCmdRemoveIf(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) +{ + int32_t ret; + struct NetDevice *netdev = NULL; + const char *ifName = NULL; + WifiIfRemove *ifRemove = NULL; + uint32_t dataSize; + (void)context; + if (reqData == NULL || rspData == NULL) { + return HDF_ERR_INVALID_PARAM; + } + ifName = HdfSbufReadString(reqData); + if (ifName == NULL) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); + return HDF_FAILURE; + } + netdev = NetDeviceGetInstByName(ifName); + if (netdev == NULL) { + HDF_LOGE("%s: netdev not found!ifName=%s", __func__, ifName); + return HDF_FAILURE; + } + + dataSize = 0; + if (!HdfSbufReadBuffer(reqData, (const void **)&(ifRemove), &dataSize) || dataSize != sizeof(WifiIfRemove)) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); + return HDF_FAILURE; + } + ret = RemoveIf(netdev, ifRemove); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: fail to remove interface,%d", __func__, ret); + } + return ret; +} + +static int32_t SetApWpsP2pIe(struct NetDevice *netdev, WifiAppIe *appIe) +{ + struct HdfChipDriver *chipDriver = GetChipDriver(netdev); + if (chipDriver == NULL) { + HDF_LOGE("%s:bad net device found!", __func__); + return HDF_FAILURE; + } + + RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->p2pOps, SetApWpsP2pIe); + return chipDriver->p2pOps->SetApWpsP2pIe(netdev, appIe); +} + +static int32_t WifiCmdSetApWpsP2pIe(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) +{ + int32_t ret; + struct NetDevice *netdev = NULL; + const char *ifName = NULL; + WifiAppIe appIe = {0}; + + (void)context; + if (reqData == NULL || rspData == NULL) { + return HDF_ERR_INVALID_PARAM; + } + ifName = HdfSbufReadString(reqData); + if (ifName == NULL) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); + return HDF_FAILURE; + } + netdev = NetDeviceGetInstByName(ifName); + if (netdev == NULL) { + HDF_LOGE("%s: netdev not found!ifName=%s", __func__, ifName); + return HDF_FAILURE; + } + + if (!HdfSbufReadUint32(reqData, &(appIe.ieLen))) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ieLen"); + return HDF_FAILURE; + } + if (!HdfSbufReadUint8(reqData, &(appIe.appIeType))) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "appIeType"); + return HDF_FAILURE; + } + if (!HdfSbufReadBuffer(reqData, (const void**)&(appIe.ie), &(appIe.ieLen))) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "appIeType"); + return HDF_FAILURE; + } + ret = SetApWpsP2pIe(netdev, &appIe); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: fail to setapwpsp2pie,%d", __func__, ret); + } + return ret; +} + +int32_t GetDriverFlag (struct NetDevice *netdev, WifiGetDrvFlags **params) +{ + struct HdfChipDriver *chipDriver = GetChipDriver(netdev); + if (chipDriver == NULL) { + HDF_LOGE("%s:bad net device found!", __func__); + return HDF_FAILURE; + } + + RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->p2pOps, GetDriverFlag); + return chipDriver->p2pOps->GetDriverFlag(netdev, params); +} + +static int32_t WifiCmdGetDriverFlag(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) +{ + int32_t ret; + struct NetDevice *netdev = NULL; + const char *ifName = NULL; + WifiGetDrvFlags *params = NULL; + + (void)context; + if (reqData == NULL || rspData == NULL) { + return HDF_ERR_INVALID_PARAM; + } + ifName = HdfSbufReadString(reqData); + if (ifName == NULL) { + HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); + return HDF_FAILURE; + } + netdev = NetDeviceGetInstByName(ifName); + if (netdev == NULL) { + HDF_LOGE("%s: netdev not found!ifName=%s", __func__, ifName); + return HDF_FAILURE; + } + + ret = GetDriverFlag(netdev, ¶ms); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: fail to getdriverflag,%d", __func__, ret); + } + + if (!HdfSbufWriteUint64(rspData, params->drvFlags)) { + HDF_LOGE("%s:%s!", __func__, ERROR_DESC_WRITE_RSP_FAILED); + ret = HDF_ERR_IO; + } + + HDF_LOGE("WifiCmdGetDriverFlag:%llx", params->drvFlags); + return ret; +} + +static struct MessageDef g_wifiP2pFeatureCmds[] = { + DUEMessage(CMD_P2P_PROBE_REQ_REPORT, WifiCmdProbeReqReport, 0), + DUEMessage(CMD_P2P_REMAIN_ON_CHANNEL, WifiCmdRemainOnChannel, 0), + DUEMessage(CMD_P2P_CANCEL_REMAIN_ON_CHANNEL, WifiCmdCancelRemainOnChannel, 0), + DUEMessage(CMD_P2P_ADD_IF, WifiCmdAddIf, 0), + DUEMessage(CMD_P2P_REMOVE_IF, WifiCmdRemoveIf, 0), + DUEMessage(CMD_P2P_SET_AP_WPS_P2P_IE, WifiCmdSetApWpsP2pIe, 0), + DUEMessage(CMD_P2P_GET_DRIVER_FLAGS, WifiCmdGetDriverFlag, 0), +}; +ServiceDefine(P2PService, P2P_SERVICE_ID, g_wifiP2pFeatureCmds); + +static Service *g_p2pService = NULL; + +int32_t P2pInit(struct WifiFeature *feature) +{ + (void)feature; + if (g_p2pService == NULL) { + ServiceCfg cfg = { + .dispatcherId = DEFAULT_DISPATCHER_ID + }; + g_p2pService = CreateService(P2PService, &cfg); + if (g_p2pService == NULL) { + return HDF_FAILURE; + } + } + return HDF_SUCCESS; +} + +int32_t P2pDeinit(struct WifiFeature *feature) +{ + (void)feature; + if (g_p2pService != NULL && g_p2pService->Destroy != NULL) { + g_p2pService->Destroy(g_p2pService); + g_p2pService = NULL; + } + return HDF_SUCCESS; +} + +struct WifiFeature g_wifiP2PFeature = { + .name = "p2p", + .init = P2pInit, + .deInit = P2pDeinit +}; + +struct WifiFeature *GetWifiP2pFeature(void) +{ + return &g_wifiP2PFeature; +} + +#ifdef __cplusplus +} +#endif diff --git a/model/network/wifi/core/components/p2p/p2p.h b/model/network/wifi/core/components/p2p/p2p.h new file mode 100755 index 0000000000000000000000000000000000000000..be36bc23e9d8f3cc3d066a70693ece2aae075547 --- /dev/null +++ b/model/network/wifi/core/components/p2p/p2p.h @@ -0,0 +1,23 @@ +/* + * 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 HDFLITE_P2P_H +#define HDFLITE_P2P_H + +#include "wifi_module.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct WifiFeature *GetWifiP2pFeature(void); + +#ifdef __cplusplus +} +#endif +#endif // HDFLITE_P2P_H diff --git a/model/network/wifi/core/components/softap/ap.c b/model/network/wifi/core/components/softap/ap.c index d685abed7f9b77c0cabaf84d50cf994c1743da98..8b15e8e0f87aedca33de1a92a0619166925c3539 100644 --- a/model/network/wifi/core/components/softap/ap.c +++ b/model/network/wifi/core/components/softap/ap.c @@ -29,12 +29,10 @@ static uint32_t ChangeBeacon(struct NetDevice *netDev, WifiApSetting *apSettings HDF_LOGE("%s:bad net device found!", __func__); return HDF_FAILURE; } - if (netDev == NULL || apSettings == NULL) { HDF_LOGE("%s: parameter null", __func__); return HDF_FAILURE; } - beaconConf.interval = apSettings->beaconInterval; beaconConf.DTIMPeriod = apSettings->dtimPeriod; beaconConf.hiddenSSID = (apSettings->hiddenSsid == 1); @@ -42,24 +40,23 @@ static uint32_t ChangeBeacon(struct NetDevice *netDev, WifiApSetting *apSettings beaconConf.headIEsLength = apSettings->beaconData.headLen; beaconConf.tailIEs = apSettings->beaconData.tail; beaconConf.tailIEsLength = apSettings->beaconData.tailLen; - RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->apOps, ConfigBeacon); return chipDriver->apOps->ConfigBeacon(netDev, &beaconConf); } static int32_t StartAp(struct NetDevice *netDev, WifiApSetting *apSettings) { - HDF_LOGE("%s:starting ap...", __func__); struct WlanAPConf apConf = { 0 }; int32_t ret; - struct HdfChipDriver *chipDriver = GetChipDriver(netDev); + struct HdfChipDriver *chipDriver = NULL; + errno_t err; + HDF_LOGI("%s:starting ap...", __func__); + chipDriver = GetChipDriver(netDev); if (chipDriver == NULL) { HDF_LOGE("%s:bad net device found!", __func__); return HDF_FAILURE; } - - apConf.band = IEEE80211_BAND_2GHZ; - errno_t err = memcpy_s(apConf.ssidConf.ssid, IEEE80211_MAX_SSID_LEN, apSettings->ssid, apSettings->ssidLen); + err = memcpy_s(apConf.ssidConf.ssid, IEEE80211_MAX_SSID_LEN, apSettings->ssid, apSettings->ssidLen); if (err != EOK) { HDF_LOGE("%s: memcpy_s failed!ret=%d", __func__, err); return HDF_FAILURE; @@ -68,20 +65,18 @@ static int32_t StartAp(struct NetDevice *netDev, WifiApSetting *apSettings) apConf.centerFreq1 = apSettings->freqParams.centerFreq1; apConf.channel = apSettings->freqParams.channel; apConf.width = apSettings->freqParams.bandwidth; - + apConf.band = apSettings->freqParams.band; RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->apOps, ConfigAp); ret = chipDriver->apOps->ConfigAp(netDev, &apConf); if (ret != HDF_SUCCESS) { HDF_LOGE("%s:ConfigAp failed!ret=%d", __func__, ret); return HDF_FAILURE; } - ret = ChangeBeacon(netDev, apSettings); if (ret != HDF_SUCCESS) { HDF_LOGE("%s:ChangeBeacon failed!ret=%d", __func__, ret); return HDF_FAILURE; } - RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->apOps, StartAp); ret = chipDriver->apOps->StartAp(netDev); if (ret != HDF_SUCCESS) { @@ -99,14 +94,12 @@ static uint32_t StopAp(struct NetDevice *netDev) HDF_LOGE("%s:bad net device found!", __func__); return HDF_FAILURE; } - RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->apOps, StopAp); ret = chipDriver->apOps->StopAp(netDev); if (ret != HDF_SUCCESS) { HDF_LOGE("StopAp:failed, error[%d]", ret); return ret; } - return NetIfSetStatus(netDev, NETIF_DOWN); } @@ -139,7 +132,6 @@ static uint32_t GetAssociatedStasCount(struct NetDevice *netDev, uint32_t *num) HDF_LOGE("%s:bad net device found!", __func__); return HDF_FAILURE; } - RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->apOps, GetAssociatedStasCount); return chipDriver->apOps->GetAssociatedStasCount(netDev, num); } @@ -161,7 +153,6 @@ static int32_t WifiCmdSetAp(const RequestContext *context, struct HdfSBuf *reqDa uint32_t settingLen = 0; const char *ifName = NULL; struct NetDevice *netdev = NULL; - (void)context; (void)rspData; if (reqData == NULL) { @@ -199,7 +190,6 @@ static int32_t WifiCmdSetAp(const RequestContext *context, struct HdfSBuf *reqDa HDF_LOGE("%s:netdev not found!ifName=%s", __func__, ifName); return HDF_FAILURE; } - HDF_LOGI("%s:%s starting AP ...", __func__, ifName); return StartAp(netdev, apSettings); } @@ -208,7 +198,6 @@ static int32_t WifiCmdStopAp(const RequestContext *context, struct HdfSBuf *reqD { const char *ifName = NULL; struct NetDevice *netdev = NULL; - (void)context; (void)rspData; if (reqData == NULL) { @@ -220,13 +209,11 @@ static int32_t WifiCmdStopAp(const RequestContext *context, struct HdfSBuf *reqD HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); return HDF_FAILURE; } - netdev = NetDeviceGetInstByName(ifName); if (netdev == NULL) { HDF_LOGE("%s:netdev not found!ifName=%s", __func__, ifName); return HDF_FAILURE; } - HDF_LOGI("%s:%s stopping AP ...", __func__, ifName); return StopAp(netdev); } @@ -237,7 +224,6 @@ static int32_t WifiCmdChangeBeacon(const RequestContext *context, struct HdfSBuf WifiApSetting *apSettings = NULL; uint32_t settingLen = 0; const char *ifName = NULL; - (void)context; (void)rspData; if (reqData == NULL) { @@ -275,7 +261,6 @@ static int32_t WifiCmdChangeBeacon(const RequestContext *context, struct HdfSBuf HDF_LOGE("%s:netdev not found!ifName=%s", __func__, ifName); return HDF_FAILURE; } - return ChangeBeacon(netdev, apSettings); } @@ -286,7 +271,6 @@ static int32_t WifiCmdStaRemove(const RequestContext *context, struct HdfSBuf *r const char *ifName = NULL; uint32_t dataSize = 0; int32_t ret; - (void)context; (void)rspData; if (reqData == NULL) { @@ -298,20 +282,17 @@ static int32_t WifiCmdStaRemove(const RequestContext *context, struct HdfSBuf *r HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); return HDF_FAILURE; } - netdev = NetDeviceGetInstByName(ifName); if (netdev == NULL) { HDF_LOGE("%s:netdev not found!ifName=%s", __func__, ifName); return HDF_FAILURE; } - params.subtype = 0; params.reasonCode = 0; if (!HdfSbufReadBuffer(reqData, (const void **)¶ms.mac, &dataSize) || dataSize != ETH_ADDR_LEN) { HDF_LOGE("%s: %s!ParamName=%s,readSize=%u", __func__, ERROR_DESC_READ_REQ_FAILED, "mac", dataSize); return HDF_FAILURE; } - ret = DelStation(netdev, ¶ms); HDF_LOGI("%s:del station XX:XX:XX:XX:XX:%02X ret=%d", __func__, params.mac[ETH_ADDR_LEN - 1], ret); return ret; @@ -321,7 +302,6 @@ static int32_t GetAssociatedStas(struct NetDevice *netdev, uint32_t num, struct { int32_t ret; WifiStaInfo *staInfo = NULL; - staInfo = (WifiStaInfo *)OsalMemCalloc(sizeof(WifiStaInfo) * num); if (staInfo == NULL) { HDF_LOGE("%s: OsalMemCalloc failed!", __func__); @@ -348,7 +328,6 @@ static int32_t WifiCmdGetAssociatedStas(const RequestContext *context, struct Hd struct NetDevice *netdev = NULL; const char *ifName = NULL; uint32_t num; - (void)context; if (reqData == NULL || rspData == NULL) { return HDF_ERR_INVALID_PARAM; @@ -389,7 +368,6 @@ static int32_t WifiCmdSetCountryCode(const RequestContext *context, struct HdfSB const char *ifName = NULL; const char *code = NULL; uint32_t replayDataSize; - (void)context; if (reqData == NULL || rspData == NULL) { return HDF_ERR_INVALID_PARAM; diff --git a/model/network/wifi/core/components/sta/sta.c b/model/network/wifi/core/components/sta/sta.c index f72abde6bc17b29f11c1217929cabae320de982b..2bd56db640f60838b1068bff5df3865576708279 100644 --- a/model/network/wifi/core/components/sta/sta.c +++ b/model/network/wifi/core/components/sta/sta.c @@ -60,7 +60,6 @@ inline static int32_t AbortScan(struct NetDevice *netDev) HDF_LOGE("%s:bad net device found!", __func__); return HDF_FAILURE; } - RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->staOps, AbortScan); return chipDriver->staOps->AbortScan(netDev); } @@ -68,24 +67,20 @@ inline static int32_t AbortScan(struct NetDevice *netDev) static int WifiFillScanParam(struct WlanScanRequest *params, struct HdfSBuf *reqData) { uint32_t dataSize = 0; - if (!HdfSbufReadBuffer(reqData, (const void **)¶ms->bssid, &dataSize)) { HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "apSettings"); return HDF_FAILURE; } - if (!HdfSbufReadBuffer(reqData, (const void **)¶ms->ssids, &dataSize)) { HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ssids"); return HDF_FAILURE; } params->ssidCount = dataSize / sizeof(params->ssids[0]); - if (!HdfSbufReadBuffer(reqData, (const void **)¶ms->extraIEs, &dataSize)) { HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "extraIes"); return HDF_FAILURE; } params->extraIEsLen = dataSize; - if (!HdfSbufReadBuffer(reqData, (const void **)¶ms->freqs, &dataSize)) { HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "freqs"); return HDF_FAILURE; @@ -99,17 +94,14 @@ static int WifiFillScanParam(struct WlanScanRequest *params, struct HdfSBuf *req static uint8_t WifiValidIeAttr(const uint8_t *ie, uint32_t len) { uint8_t elemLen; - if (ie == NULL) { // ie null is normal return true; } - while (len != 0) { if (len < 2) { return false; } len -= 2; - elemLen = ie[1]; if (elemLen > len) { return false; @@ -117,19 +109,16 @@ static uint8_t WifiValidIeAttr(const uint8_t *ie, uint32_t len) len -= elemLen; ie += 2 + elemLen; } - return true; } static int WifiFillAssocParams(WifiAssociateParams *assoc, struct HdfSBuf *reqData) { uint32_t dataSize = 0; - if (!HdfSbufReadBuffer(reqData, (const void **)&assoc->bssid, &dataSize) || dataSize != ETH_ADDR_LEN) { HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "bssid"); return HDF_FAILURE; } - if (!HdfSbufReadBuffer(reqData, (const void **)&assoc->ssid, &(assoc->ssidLen))) { HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ssid"); return HDF_FAILURE; @@ -170,7 +159,6 @@ static int WifiFillAssocParams(WifiAssociateParams *assoc, struct HdfSBuf *reqDa HDF_LOGE("%s:void ssid", __func__); return HDF_FAILURE; } - if (WifiValidIeAttr(assoc->ie, assoc->ieLen) == false) { HDF_LOGE("%s:illegal ie", __func__); return HDF_FAILURE; @@ -185,27 +173,23 @@ static int WifiSetAssocParams(const WifiAssociateParams *assoc, const struct Net params->ssidLen = assoc->ssidLen; params->ie = assoc->ie; params->ieLen = assoc->ieLen; - if ((assoc->authType > WIFI_AUTHTYPE_AUTOMATIC) || (assoc->authType == WIFI_AUTHTYPE_SAE)) { HDF_LOGE("%s:illegal authType %u", __func__, assoc->authType); return HDF_FAILURE; } params->authType = assoc->authType; - params->bssid = assoc->bssid; params->privacy = assoc->privacy; if ((assoc->mfp != WIFI_MFP_REQUIRED) && (assoc->mfp != WIFI_MFP_NO) && (assoc->mfp != WIFI_MFP_OPTIONAL)) { HDF_LOGE("%s:unexpected mfp.mfp=%u", __func__, assoc->mfp); return HDF_FAILURE; } - params->mfp = (WifiMfp)assoc->mfp; if (assoc->key != NULL) { params->key = assoc->key; params->keyLen = assoc->keyLen; params->keyIdx = assoc->keyIdx; } - if (memcpy_s(¶ms->crypto, sizeof(WifiCryptoSetting), assoc->crypto, sizeof(WifiCryptoSetting)) != EOK) { HDF_LOGE("%s:copy crypto failed!", __func__); return HDF_FAILURE; @@ -221,7 +205,6 @@ static int32_t WifiCmdAssoc(const RequestContext *context, struct HdfSBuf *reqDa struct WlanHwCapability *capability = NULL; const char *ifName = NULL; int32_t ret; - (void)context; (void)rspData; if (reqData == NULL) { @@ -236,7 +219,6 @@ static int32_t WifiCmdAssoc(const RequestContext *context, struct HdfSBuf *reqDa if (WifiFillAssocParams(&assoc, reqData) != HDF_SUCCESS) { return HDF_FAILURE; } - if ((netdev = NetDeviceGetInstByName(ifName)) == NULL) { HDF_LOGE("%s:netdev not found!ifName=%s", __func__, ifName); return HDF_FAILURE; @@ -244,7 +226,6 @@ static int32_t WifiCmdAssoc(const RequestContext *context, struct HdfSBuf *reqDa if (WifiSetAssocParams(&assoc, netdev, ¶ms) != HDF_SUCCESS) { return HDF_FAILURE; } - capability = GetHwCapability(netdev); if (capability == NULL) { HDF_LOGE("%s:GetHwCapability failed!", __func__); @@ -259,12 +240,10 @@ static int32_t WifiCmdAssoc(const RequestContext *context, struct HdfSBuf *reqDa break; } } while (false); - if (capability->Release != NULL) { capability->Release(capability); capability = NULL; } - return ret; } @@ -274,7 +253,6 @@ static int32_t WifiCmdDisconnect(const RequestContext *context, struct HdfSBuf * uint16_t reasonCode; const char *ifName = NULL; int ret; - (void)context; (void)rspData; if (reqData == NULL) { @@ -286,7 +264,6 @@ static int32_t WifiCmdDisconnect(const RequestContext *context, struct HdfSBuf * HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); return HDF_FAILURE; } - if (!HdfSbufReadUint16(reqData, &reasonCode)) { HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "reasonCode"); return HDF_FAILURE; @@ -296,7 +273,6 @@ static int32_t WifiCmdDisconnect(const RequestContext *context, struct HdfSBuf * HDF_LOGE("%s:netdev not found!ifName=%s", __func__, ifName); return HDF_FAILURE; } - HDF_LOGW("%s:%s disconnecting from AP...", __func__, ifName); ret = Disconnect(netdev, reasonCode); if (ret != HDF_SUCCESS) { @@ -311,7 +287,6 @@ static int32_t WifiCmdScan(const RequestContext *context, struct HdfSBuf *reqDat const char *ifName = NULL; struct WlanScanRequest params = { 0 }; int32_t ret; - (void)context; (void)rspData; if (reqData == NULL) { @@ -332,7 +307,6 @@ static int32_t WifiCmdScan(const RequestContext *context, struct HdfSBuf *reqDat if (ret != HDF_SUCCESS) { return ret; } - ret = ScanAll(netdev, ¶ms); if (ret != HDF_SUCCESS) { HDF_LOGE("%s:ScanAll failed!ret=%d", __func__, ret); @@ -345,10 +319,8 @@ static int32_t WifiCmdAbortScan(const RequestContext *context, struct HdfSBuf *r struct NetDevice *netdev = NULL; int32_t ret; const char *ifName = HdfSbufReadString(reqData); - (void)context; (void)rspData; - if (ifName == NULL) { HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); return HDF_FAILURE; @@ -362,7 +334,6 @@ static int32_t WifiCmdAbortScan(const RequestContext *context, struct HdfSBuf *r if (ret != HDF_SUCCESS) { HDF_LOGE("%s:AbortScan failed!ret=%d", __func__, ret); } - // keep return SUCCESS if AbortScan return FAILED return HDF_SUCCESS; } @@ -376,7 +347,7 @@ static int32_t WifiCmdSetScanningMacAddress(const RequestContext *context, struc const char *ifName = NULL; unsigned char *mac = NULL; uint32_t replayDataSize; - + struct HdfChipDriver *chipDriver = NULL; (void)context; if (reqData == NULL || rspData == NULL) { return HDF_ERR_INVALID_PARAM; @@ -396,14 +367,12 @@ static int32_t WifiCmdSetScanningMacAddress(const RequestContext *context, struc HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "mac"); return HDF_FAILURE; } - - struct HdfChipDriver *chipDriver = GetChipDriver(netdev); + chipDriver = GetChipDriver(netdev); if (chipDriver == NULL) { HDF_LOGE("%s:bad net device found!", __func__); return HDF_FAILURE; } RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->staOps, SetScanningMacAddress); - ret = chipDriver->staOps->SetScanningMacAddress(netdev, mac, IEEE80211_MAC_ADDR_LEN); if (ret != HDF_SUCCESS && ret != HDF_ERR_NOT_SUPPORT) { HDF_LOGE("%s: fail to do set scanning mac addr!ret=%d", __func__, ret); diff --git a/model/network/wifi/core/module/wifi_base.c b/model/network/wifi/core/module/wifi_base.c index 1d19774a23e801cab8d61bd783cd05795ea96ecf..8fc2c09378c51c102d763386d2488bd752e38b55 100644 --- a/model/network/wifi/core/module/wifi_base.c +++ b/model/network/wifi/core/module/wifi_base.c @@ -29,6 +29,7 @@ #endif #define WIFI_24G_CHANNEL_NUM 14 +#define WIFI_MAX_CHANNEL_NUM 24 #define DEFAULT_EAPOL_PACKAGE_SIZE 800 Service *g_baseService = NULL; @@ -366,13 +367,11 @@ static int32_t WifiCmdEnableEapol(const RequestContext *context, struct HdfSBuf HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); return HDF_FAILURE; } - netdev = NetDeviceGetInstByName(ifName); if (netdev == NULL) { HDF_LOGE("%s:netdev not found!ifName=%s", __func__, ifName); return HDF_FAILURE; } - eapol.callback = (void *)HdfWifiEventEapolRecv; eapol.context = NULL; @@ -383,7 +382,6 @@ static int32_t WifiCmdDisableEapol(const RequestContext *context, struct HdfSBuf { struct NetDevice *netdev = NULL; const char *ifName = NULL; - (void)context; (void)rspData; if (reqData == NULL) { @@ -395,7 +393,6 @@ static int32_t WifiCmdDisableEapol(const RequestContext *context, struct HdfSBuf HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); return HDF_FAILURE; } - netdev = NetDeviceGetInstByName(ifName); if (netdev == NULL) { HDF_LOGE("%s:netdev not found!ifName=%s", __func__, ifName); @@ -410,7 +407,6 @@ static int32_t WifiCmdGetAddr(const RequestContext *context, struct HdfSBuf *req struct NetDevice *netdev = NULL; const char *ifName = NULL; int32_t ret = HDF_SUCCESS; - (void)context; if (reqData == NULL || rspData == NULL) { HDF_LOGE("%s: reqData or rspData is NULL", __func__); @@ -421,7 +417,6 @@ static int32_t WifiCmdGetAddr(const RequestContext *context, struct HdfSBuf *req HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); return HDF_FAILURE; } - netdev = NetDeviceGetInstByName(ifName); if (netdev == NULL) { HDF_LOGE("%s: invalid netdev", __func__); @@ -437,9 +432,7 @@ static int32_t WifiCmdGetAddr(const RequestContext *context, struct HdfSBuf *req static int32_t WifiCmdSetMode(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) { struct NetDevice *netdev = NULL; - WifiSetMode *mode = NULL; - const char *ifName = NULL; uint32_t dataSize = 0; int32_t ret; @@ -465,9 +458,7 @@ static int32_t WifiCmdSetMode(const RequestContext *context, struct HdfSBuf *req HDF_LOGE("%s: invalid netdev", __func__); return HDF_FAILURE; } - HDF_LOGW("%s:%s changing mode to %u ...", __func__, ifName, mode->iftype); - ret = SetMode(netdev, mode->iftype); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: fail to do change intf,%d", __func__, ret); @@ -475,6 +466,25 @@ static int32_t WifiCmdSetMode(const RequestContext *context, struct HdfSBuf *req return ret; } +static void WifiGetChannelData(struct WlanBand *band, WifiHwFeatureData **featureData, struct WlanHwCapability *capability, uint32_t iee80211band) +{ + uint32_t loop; + if (band == NULL || featureData == NULL || *featureData == NULL) + { + HDF_LOGE("%s: band or featureData is NULL", __func__); + return; + } + + (*featureData)->bands[iee80211band].channelNum = band->channelCount; + (*featureData)->htCapab = capability->htCapability; + + for (loop = 0; loop < band->channelCount; ++loop) { + (*featureData)->bands[iee80211band].iee80211Channel[loop].freq = band->channels[loop].centerFreq; + (*featureData)->bands[iee80211band].iee80211Channel[loop].flags = band->channels[loop].flags; + (*featureData)->bands[iee80211band].iee80211Channel[loop].channel = band->channels[loop].channelId; + } +} + static int32_t WifiFillHwFeature(struct NetDevice *netdev, WifiHwFeatureData *featureData) { int32_t ret = HDF_SUCCESS; @@ -502,21 +512,18 @@ static int32_t WifiFillHwFeature(struct NetDevice *netdev, WifiHwFeatureData *fe ret = HDF_FAILURE; break; } - featureData->channelNum = band->channelCount; - featureData->htCapab = capability->htCapability; - - for (loop = 0; loop < band->channelCount; ++loop) { - featureData->iee80211Channel[loop].flags = band->channels[loop].flags; - featureData->iee80211Channel[loop].freq = band->channels[loop].centerFreq; - featureData->iee80211Channel[loop].channel = band->channels[loop].channelId; + WifiGetChannelData(band, &featureData, capability, IEEE80211_BAND_2GHZ); + } + if (capability->bands[IEEE80211_BAND_5GHZ] != NULL) { + struct WlanBand *band = capability->bands[IEEE80211_BAND_5GHZ]; + if (band->channelCount > WIFI_MAX_CHANNEL_NUM) { + HDF_LOGE("%s: channels %u out of range", __func__, band->channelCount); + ret = HDF_FAILURE; + break; } - } else { - HDF_LOGE("%s: Supportting 2.4G is required by now!", __func__); - ret = HDF_FAILURE; - break; + WifiGetChannelData(band, &featureData, capability, IEEE80211_BAND_5GHZ); } - // 5G not supported } while (false); if (capability->Release != NULL) { @@ -535,7 +542,6 @@ static uint32_t GetDeviceMacAddr(struct NetDevice *netdev, int32_t type, uint8_t } RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->ops, GetDeviceMacAddr); - return chipDriver->ops->GetDeviceMacAddr(netdev, type, mac, len); } @@ -546,7 +552,6 @@ static uint32_t SetMacAddr(struct NetDevice *netdev, uint8_t *mac, uint8_t len) HDF_LOGE("%s:bad net device found!", __func__); return HDF_FAILURE; } - RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->ops, SetMacAddr); return chipDriver->ops->SetMacAddr(netdev, mac, len); } @@ -592,19 +597,16 @@ static int32_t WifiCmdGetHwFeature(const RequestContext *context, struct HdfSBuf HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); return HDF_FAILURE; } - netdev = NetDeviceGetInstByName(ifName); if (netdev == NULL) { HDF_LOGE("%s: invalid netdev", __func__); return HDF_FAILURE; } - ret = WifiFillHwFeature(netdev, &featureData); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: WifiFillHwFeature failed!ret=%d", __func__, ret); return HDF_FAILURE; } - if (!HdfSbufWriteBuffer(rspData, &featureData, sizeof(featureData))) { HDF_LOGE("%s: %s!", __func__, ERROR_DESC_WRITE_RSP_FAILED); ret = HDF_ERR_IO; @@ -615,7 +617,6 @@ static int32_t WifiCmdGetHwFeature(const RequestContext *context, struct HdfSBuf static int32_t SetNetIfInfo(struct NetDevice *netdev, uint32_t type) { int ret = 0; - if (netdev != NULL) { ret = netdev->netDeviceIf->open(netdev); (void)NetIfSetStatus(netdev, NETIF_UP); @@ -641,7 +642,6 @@ static void SetNetworkAddr(struct NetDevice *netdev, uint32_t type) IpV4Addr ip; IpV4Addr netmask; IpV4Addr gw; - if (type == WIFI_IFTYPE_STATION) { ip.addr = 0x00000000UL; netmask.addr = 0x00000000UL; @@ -662,7 +662,6 @@ static void UnsetNetworkAddr(struct NetDevice *netdev) IpV4Addr ip = { 0x00000000UL }; IpV4Addr netmask = { 0x00000000UL }; IpV4Addr gw = { 0x00000000UL }; - if (netdev != NULL) { NetIfSetAddr(netdev, &ip, &netmask, &gw); } @@ -715,7 +714,6 @@ static int32_t WifiSendMlme(const RequestContext *context, struct HdfSBuf *reqDa (void)context; (void)reqData; (void)rspData; - return HDF_SUCCESS; } @@ -737,7 +735,7 @@ static int32_t WifiCmdSendAction(const RequestContext *context, struct HdfSBuf * const char *ifName = NULL; uint32_t dataSize = 0; struct NetDevice *netdev = NULL; - + int ret; (void)context; (void)rspData; if (reqData == NULL) { @@ -778,7 +776,7 @@ static int32_t WifiCmdSendAction(const RequestContext *context, struct HdfSBuf * return HDF_FAILURE; } - int ret = SendAction(netdev, &actionData); + ret = SendAction(netdev, &actionData); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: fail to remain on channel,%d", __func__, ret); } @@ -787,11 +785,12 @@ static int32_t WifiCmdSendAction(const RequestContext *context, struct HdfSBuf * static int32_t WifiCmdGetNetworkInfo(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) { - (void)context; - (void)reqData; - uint32_t netDevNum = 1; + uint32_t netDevNum; char *defaultIfName = "wlan0"; uint8_t supportMode[PROTOCOL_80211_IFTYPE_NUM] = {0}; + netDevNum = 1; + (void)context; + (void)reqData; if (!HdfSbufWriteUint32(rspData, netDevNum)) { HDF_LOGE("%s: %s!", __func__, ERROR_DESC_WRITE_RSP_FAILED); @@ -813,7 +812,6 @@ static int32_t WifiCmdGetNetworkInfo(const RequestContext *context, struct HdfSB static int32_t WifiCmdIsSupportCombo(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) { uint8_t isComboValid; - (void)context; if (reqData == NULL || rspData == NULL) { return HDF_ERR_INVALID_PARAM; @@ -828,8 +826,8 @@ static int32_t WifiCmdIsSupportCombo(const RequestContext *context, struct HdfSB static int32_t WifiCmdGetSupportCombo(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) { - (void)context; uint8_t isComboValid; + (void)context; if (reqData == NULL || rspData == NULL) { return HDF_ERR_INVALID_PARAM; } @@ -998,7 +996,7 @@ static int32_t WifiCmdSetTxPower(const RequestContext *context, struct HdfSBuf * static int32_t WifiCmdSetClient(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) { uint32_t clientNum = 0; - + struct HdfWifiEventToClientMap *eventToClientMap = NULL; (void)rspData; if (reqData == NULL || context == NULL) { return HDF_ERR_INVALID_PARAM; @@ -1009,7 +1007,7 @@ static int32_t WifiCmdSetClient(const RequestContext *context, struct HdfSBuf *r return HDF_FAILURE; } - struct HdfWifiEventToClientMap *eventToClientMap = HdfWifiGetEventToClientMap(); + eventToClientMap = HdfWifiGetEventToClientMap(); if (eventToClientMap == NULL) { HDF_LOGE("%s:get HdfWifiEventToClientMap failed", __func__); return HDF_FAILURE; @@ -1213,9 +1211,7 @@ static int32_t WifiCmdDoResetChip(const RequestContext *context, struct HdfSBuf HDF_LOGE("%s:power reset failed!", __func__); return ERR_POWER_RESET_FAIL; } - ret = HdfWifiInitDevice(wlanDevice); - return ret; } @@ -1223,6 +1219,7 @@ void SendMessageResetDriverCallBack(const RequestContext *context, struct HdfSBu ErrorCode rspCode) { uint8_t chipId; + int32_t ret; const char *ifName = NULL; (void)context; @@ -1241,7 +1238,7 @@ void SendMessageResetDriverCallBack(const RequestContext *context, struct HdfSBu return; } - int32_t ret = HdfWifiEventResetResult(chipId, rspCode, ifName); + ret = HdfWifiEventResetResult(chipId, rspCode, ifName); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: send resetDriver event fail!", __func__); } @@ -1251,13 +1248,13 @@ void SendMessageResetDriverCallBack(const RequestContext *context, struct HdfSBu static int32_t WifiCmdResetDriver(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) { int32_t ret; - + struct HdfSBuf *data = NULL; (void)context; if (reqData == NULL || rspData == NULL) { return HDF_ERR_INVALID_PARAM; } - struct HdfSBuf *data = HdfSBufCopy(reqData); + data = HdfSBufCopy(reqData); if (data == NULL) { HDF_LOGE("%s: sbuf copy fail", __func__); return HDF_FAILURE; @@ -1286,13 +1283,13 @@ static uint32_t GetIftype(struct NetDevice *netdev, uint8_t *iftype) #define MAX_NETDEVICE_COUNT 20 static int32_t WifiCmdGetNetDevInfo(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) { - (void)context; - (void)reqData; uint32_t i; uint32_t netdevNum; uint8_t iftype; struct NetDevice *netDev = NULL; - + (void)context; + (void)reqData; + netdevNum = NetDevGetRegisterCount(); if (!HdfSbufWriteUint32(rspData, netdevNum)) { HDF_LOGE("%s: %s!", __func__, ERROR_DESC_WRITE_RSP_FAILED); @@ -1304,7 +1301,8 @@ static int32_t WifiCmdGetNetDevInfo(const RequestContext *context, struct HdfSBu if (GetIftype(netDev, &iftype) != HDF_SUCCESS) { iftype = 0; } - if (!HdfSbufWriteUint32(rspData, i) || !HdfSbufWriteBuffer(rspData, netDev->name, strlen(netDev->name) + 1) || + if (!HdfSbufWriteUint32(rspData, i) || + !HdfSbufWriteBuffer(rspData, netDev->name, strlen(netDev->name) + 1) || !HdfSbufWriteUint8(rspData, iftype) || !HdfSbufWriteBuffer(rspData, GET_NET_DEV_MAC_ADDR(netDev), ETH_ADDR_LEN)) { HDF_LOGE("%s: %s!", __func__, ERROR_DESC_WRITE_RSP_FAILED); @@ -1315,333 +1313,6 @@ static int32_t WifiCmdGetNetDevInfo(const RequestContext *context, struct HdfSBu return HDF_SUCCESS; } -static int32_t RemainOnChannel(struct NetDevice *netdev, WifiOnChannel *onChannel) -{ - struct HdfChipDriver *chipDriver = GetChipDriver(netdev); - if (chipDriver == NULL) { - HDF_LOGE("%s:bad net device found!", __func__); - return HDF_FAILURE; - } - - RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->ops, RemainOnChannel); - return chipDriver->ops->RemainOnChannel(netdev, onChannel); -} - -static int32_t WifiCmdRemainOnChannel(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) -{ - int32_t ret; - struct NetDevice *netdev = NULL; - const char *ifName = NULL; - WifiOnChannel wifiOnChannel = {0}; - - (void)context; - if (reqData == NULL || rspData == NULL) { - return HDF_ERR_INVALID_PARAM; - } - ifName = HdfSbufReadString(reqData); - if (ifName == NULL) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); - return HDF_FAILURE; - } - netdev = NetDeviceGetInstByName(ifName); - if (netdev == NULL) { - HDF_LOGE("%s: netdev not found!ifName=%s", __func__, ifName); - return HDF_FAILURE; - } - if (!HdfSbufReadUint32(reqData, &(wifiOnChannel.freq))) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "freq"); - return HDF_FAILURE; - } - if (!HdfSbufReadUint32(reqData, &(wifiOnChannel.duration))) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "duration"); - return HDF_FAILURE; - } - ret = RemainOnChannel(netdev, &wifiOnChannel); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: fail to remain on channel,%d",__func__, ret); - } - return ret; -} - -static int32_t ProbeReqReport(struct NetDevice *netdev, int32_t report) -{ - struct HdfChipDriver *chipDriver = GetChipDriver(netdev); - if (chipDriver == NULL) { - HDF_LOGE("%s:bad net device found!", __func__); - return HDF_FAILURE; - } - - RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->ops, ProbeReqReport); - return chipDriver->ops->ProbeReqReport(netdev, report); -} - -static int32_t WifiCmdProbeReqReport(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) -{ - int32_t ret; - struct NetDevice *netdev = NULL; - const char *ifName = NULL; - int32_t report; - - (void)context; - if (reqData == NULL || rspData == NULL) { - return HDF_ERR_INVALID_PARAM; - } - ifName = HdfSbufReadString(reqData); - if (ifName == NULL) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); - return HDF_FAILURE; - } - netdev = NetDeviceGetInstByName(ifName); - if (netdev == NULL) { - HDF_LOGE("%s: netdev not found!ifName=%s", __func__, ifName); - return HDF_FAILURE; - } - if (!HdfSbufReadInt32(reqData,&(report))) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "report"); - return HDF_FAILURE; - } - - ret = ProbeReqReport(netdev, report); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: fail to probe req report,%d",__func__, ret); - } - return ret; -} - -static int32_t CancelRemainOnChannel(struct NetDevice *netdev) -{ - struct HdfChipDriver *chipDriver = GetChipDriver(netdev); - if (chipDriver == NULL) { - HDF_LOGE("%s:bad net device found!", __func__); - return HDF_FAILURE; - } - - RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->ops, CancelRemainOnChannel); - return chipDriver->ops->CancelRemainOnChannel(netdev); -} - -static int32_t WifiCmdCancelRemainOnChannel(const RequestContext *context, struct HdfSBuf *reqData, - struct HdfSBuf *rspData) -{ - int32_t ret; - struct NetDevice *netdev = NULL; - const char *ifName = NULL; - - (void)context; - if (reqData == NULL || rspData == NULL) { - return HDF_ERR_INVALID_PARAM; - } - ifName = HdfSbufReadString(reqData); - if (ifName == NULL) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); - return HDF_FAILURE; - } - netdev = NetDeviceGetInstByName(ifName); - if (netdev == NULL) { - HDF_LOGE("%s: netdev not found!ifName=%s", __func__, ifName); - return HDF_FAILURE; - } - - ret = CancelRemainOnChannel(netdev); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: fail to cancel remain on channel,%d",__func__, ret); - } - return ret; -} - -static int32_t AddIf(struct NetDevice *netdev, WifiIfAdd *ifAdd) -{ - struct HdfChipDriver *chipDriver = GetChipDriver(netdev); - if (chipDriver == NULL) { - HDF_LOGE("%s:bad net device found!", __func__); - return HDF_FAILURE; - } - - RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->ops, AddIf); - return chipDriver->ops->AddIf(netdev, ifAdd); -} - -static int32_t WifiCmdAddIf(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) -{ - int32_t ret; - struct NetDevice *netdev = NULL; - const char *ifName = NULL; - WifiIfAdd ifAdd = {0}; - - (void)context; - if (reqData == NULL || rspData == NULL) { - return HDF_ERR_INVALID_PARAM; - } - ifName = HdfSbufReadString(reqData); - if (ifName == NULL) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); - return HDF_FAILURE; - } - netdev = NetDeviceGetInstByName(ifName); - if (netdev == NULL) { - HDF_LOGE("%s: netdev not found!ifName=%s", __func__, ifName); - return HDF_FAILURE; - } - - if (!HdfSbufReadUint8(reqData, &(ifAdd.type))) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "type"); - return HDF_FAILURE; - } - - ret = AddIf(netdev, &ifAdd); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: fail to cancel remain on channel,%d",__func__, ret); - } - return ret; -} - -static int32_t RemoveIf(struct NetDevice *netdev, WifiIfRemove *ifRemove) -{ - struct HdfChipDriver *chipDriver = GetChipDriver(netdev); - if (chipDriver == NULL) { - HDF_LOGE("%s:bad net device found!", __func__); - return HDF_FAILURE; - } - - RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->ops, RemoveIf); - return chipDriver->ops->RemoveIf(netdev, ifRemove); -} - -static int32_t WifiCmdRemoveIf(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) -{ - int32_t ret; - struct NetDevice *netdev = NULL; - const char *ifName = NULL; - WifiIfRemove *ifRemove = NULL; - - (void)context; - if (reqData == NULL || rspData == NULL) { - return HDF_ERR_INVALID_PARAM; - } - ifName = HdfSbufReadString(reqData); - if (ifName == NULL) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); - return HDF_FAILURE; - } - netdev = NetDeviceGetInstByName(ifName); - if (netdev == NULL) { - HDF_LOGE("%s: netdev not found!ifName=%s", __func__, ifName); - return HDF_FAILURE; - } - - uint32_t dataSize = 0; - if (!HdfSbufReadBuffer(reqData, (const void **)&(ifRemove), &dataSize) || dataSize != sizeof(WifiIfRemove)) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); - return HDF_FAILURE; - } - ret = RemoveIf(netdev, ifRemove); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: fail to remove interface,%d",__func__, ret); - } - return ret; -} - -static int32_t SetApWpsP2pIe(struct NetDevice *netdev, WifiAppIe *appIe) -{ - struct HdfChipDriver *chipDriver = GetChipDriver(netdev); - if (chipDriver == NULL) { - HDF_LOGE("%s:bad net device found!", __func__); - return HDF_FAILURE; - } - - RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->ops, SetApWpsP2pIe); - return chipDriver->ops->SetApWpsP2pIe(netdev, appIe); -} - -static int32_t WifiCmdSetApWpsP2pIe(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) -{ - int32_t ret; - struct NetDevice *netdev = NULL; - const char *ifName = NULL; - WifiAppIe appIe = {0}; - - (void)context; - if (reqData == NULL || rspData == NULL) { - return HDF_ERR_INVALID_PARAM; - } - ifName = HdfSbufReadString(reqData); - if (ifName == NULL) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); - return HDF_FAILURE; - } - netdev = NetDeviceGetInstByName(ifName); - if (netdev == NULL) { - HDF_LOGE("%s: netdev not found!ifName=%s", __func__, ifName); - return HDF_FAILURE; - } - - if (!HdfSbufReadUint32(reqData, &(appIe.ieLen))) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ieLen"); - return HDF_FAILURE; - } - if (!HdfSbufReadUint8(reqData, &(appIe.appIeType))) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "appIeType"); - return HDF_FAILURE; - } - if (!HdfSbufReadBuffer(reqData, (const void**)&(appIe.ie), &(appIe.ieLen))) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "appIeType"); - return HDF_FAILURE; - } - ret = SetApWpsP2pIe(netdev, &appIe); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: fail to setapwpsp2pie,%d",__func__, ret); - } - return ret; -} - -int32_t GetDriverFlag (struct NetDevice *netdev, WifiGetDrvFlags **params) -{ - struct HdfChipDriver *chipDriver = GetChipDriver(netdev); - if (chipDriver == NULL) { - HDF_LOGE("%s:bad net device found!", __func__); - return HDF_FAILURE; - } - - RETURN_IF_CHIPOPS_NOT_IMPLEMENT(chipDriver->ops, GetDriverFlag); - return chipDriver->ops->GetDriverFlag(netdev, params); -} - -static int32_t WifiCmdGetDriverFlag(const RequestContext *context, struct HdfSBuf *reqData, struct HdfSBuf *rspData) -{ - int32_t ret; - struct NetDevice *netdev = NULL; - const char *ifName = NULL; - WifiGetDrvFlags *params = NULL; - - (void)context; - if (reqData == NULL || rspData == NULL) { - return HDF_ERR_INVALID_PARAM; - } - ifName = HdfSbufReadString(reqData); - if (ifName == NULL) { - HDF_LOGE("%s: %s!ParamName=%s", __func__, ERROR_DESC_READ_REQ_FAILED, "ifName"); - return HDF_FAILURE; - } - netdev = NetDeviceGetInstByName(ifName); - if (netdev == NULL) { - HDF_LOGE("%s: netdev not found!ifName=%s", __func__, ifName); - return HDF_FAILURE; - } - - ret = GetDriverFlag(netdev, ¶ms); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: fail to getdriverflag,%d",__func__, ret); - } - - if (!HdfSbufWriteUint64(rspData, params->drvFlags)) { - HDF_LOGE("%s:%s!", __func__, ERROR_DESC_WRITE_RSP_FAILED); - ret = HDF_ERR_IO; - } - - HDF_LOGE("WifiCmdGetDriverFlag:%llx", params->drvFlags); - return ret; -} - static struct MessageDef g_wifiBaseFeatureCmds[] = { DUEMessage(CMD_BASE_NEW_KEY, WifiCmdNewKey, 0), DUEMessage(CMD_BASE_DEL_KEY, WifiCmdDelKey, 0), @@ -1668,13 +1339,6 @@ static struct MessageDef g_wifiBaseFeatureCmds[] = { DUEMessage(CMD_BASE_GET_IFNAMES, WifiCmdGetIfNamesByChipId, 0), DUEMessage(CMD_BASE_RESET_DRIVER, WifiCmdResetDriver, 0), DUEMessage(CMD_BASE_GET_NETDEV_INFO, WifiCmdGetNetDevInfo, 0), - DUEMessage(CMD_P2P_PROBE_REQ_REPORT, WifiCmdProbeReqReport, 0), - DUEMessage(CMD_P2P_REMAIN_ON_CHANNEL, WifiCmdRemainOnChannel, 0), - DUEMessage(CMD_P2P_CANCEL_REMAIN_ON_CHANNEL, WifiCmdCancelRemainOnChannel, 0), - DUEMessage(CMD_P2P_ADD_IF, WifiCmdAddIf, 0), - DUEMessage(CMD_P2P_REMOVE_IF, WifiCmdRemoveIf, 0), - DUEMessage(CMD_P2P_SET_AP_WPS_P2P_IE, WifiCmdSetApWpsP2pIe, 0), - DUEMessage(CMD_P2P_GET_DRIVER_FLAGS, WifiCmdGetDriverFlag, 0), DUEMessage(CMD_BASE_DO_RESET_PRIVATE, WifiCmdDoResetChip, 0), }; ServiceDefine(BaseService, BASE_SERVICE_ID, g_wifiBaseFeatureCmds); diff --git a/model/network/wifi/core/module/wifi_module.c b/model/network/wifi/core/module/wifi_module.c index 061478f05a2f1591499832299f1a5789e87716e4..8f76769a66b1508cb44a3b689e67b61946c84049 100644 --- a/model/network/wifi/core/module/wifi_module.c +++ b/model/network/wifi/core/module/wifi_module.c @@ -10,6 +10,7 @@ #include "wifi_base.h" #include "ap.h" #include "sta.h" +#include "p2p.h" #include "hdf_wlan_config.h" #include "securec.h" @@ -39,6 +40,7 @@ static int32_t InitFeatures(struct WifiModule *module) module->feList.fe[HDF_WIFI_FEATURE_AP] = GetWifiApFeature(); module->feList.fe[HDF_WIFI_FEATURE_STA] = GetWifiStaFeature(); + module->feList.fe[HDF_WIFI_FEATURE_P2P] = GetWifiP2pFeature(); for (i = 0; i < HDF_WIFI_FEATURE_NUM; i++) { if ((module->moduleConfig.hslConfig->featureMap & (1 << i)) && module->feList.fe[i] != NULL) { diff --git a/model/network/wifi/include/hdf_wifi_cmd.h b/model/network/wifi/include/hdf_wifi_cmd.h index 43a392eadb3f148df3642766ea7117db6e779cd0..611e05d90bcb1a64a2106438f8350d63be519b42 100644 --- a/model/network/wifi/include/hdf_wifi_cmd.h +++ b/model/network/wifi/include/hdf_wifi_cmd.h @@ -254,6 +254,7 @@ typedef struct { int32_t centerFreq1; int32_t centerFreq2; int32_t bandwidth; + uint8_t band; } WifiFreqParams; typedef struct { @@ -312,13 +313,20 @@ typedef struct { } WifiIeee80211Channel; #define MAX_SUPPORTED_RATE 12 +#define WIFI_MAX_CHANNEL_NUM 24 +#define SUPPORTED_NUM_BANDS 2 + +typedef struct { + int32_t channelNum; /**< Number of channels */ + WifiIeee80211Channel iee80211Channel[WIFI_MAX_CHANNEL_NUM]; /**< WLAN channel structures */ +}WlanBands; typedef struct { int32_t channelNum; uint16_t bitrate[MAX_SUPPORTED_RATE]; uint16_t htCapab; uint8_t resv[2]; - WifiIeee80211Channel iee80211Channel[14]; + WlanBands bands[SUPPORTED_NUM_BANDS]; } WifiHwFeatureData; typedef struct { diff --git a/model/network/wifi/platform/include/hdf_wlan_services.h b/model/network/wifi/platform/include/hdf_wlan_services.h index 47fb1b8b5306aa5dab2038c16b370d2c69a7d00f..6e49bfc73f2a8cceb279e7e2726e52aab1b59888 100644 --- a/model/network/wifi/platform/include/hdf_wlan_services.h +++ b/model/network/wifi/platform/include/hdf_wlan_services.h @@ -14,6 +14,7 @@ enum PlatformServiceID { BASE_SERVICE_ID, AP_SERVICE_ID, STA_SERVICE_ID, + P2P_SERVICE_ID, AUTO_ALLOC_SERVICE_ID_START = 300 }; @@ -43,13 +44,6 @@ enum BaseCommands { CMD_BASE_GET_IFNAMES, CMD_BASE_RESET_DRIVER, CMD_BASE_GET_NETDEV_INFO = 25, - CMD_P2P_PROBE_REQ_REPORT = 26, - CMD_P2P_REMAIN_ON_CHANNEL, - CMD_P2P_CANCEL_REMAIN_ON_CHANNEL, - CMD_P2P_ADD_IF, - CMD_P2P_REMOVE_IF, - CMD_P2P_SET_AP_WPS_P2P_IE, - CMD_P2P_GET_DRIVER_FLAGS, CMD_BASE_DO_RESET_PRIVATE, }; @@ -70,4 +64,14 @@ enum STACommands { CMD_STA_SET_SCAN_MAC_ADDR }; +enum P2PCommands { + CMD_P2P_PROBE_REQ_REPORT = 0, + CMD_P2P_REMAIN_ON_CHANNEL, + CMD_P2P_CANCEL_REMAIN_ON_CHANNEL, + CMD_P2P_ADD_IF, + CMD_P2P_REMOVE_IF, + CMD_P2P_SET_AP_WPS_P2P_IE, + CMD_P2P_GET_DRIVER_FLAGS +}; + #endif \ No newline at end of file diff --git a/model/network/wifi/platform/src/hdf_wlan_config_parser.c b/model/network/wifi/platform/src/hdf_wlan_config_parser.c index d32facbbb67215f0c6aaa79b82ed88a06a9b65e1..61da15060ef85815ec7b54d0a683661b093aff3b 100644 --- a/model/network/wifi/platform/src/hdf_wlan_config_parser.c +++ b/model/network/wifi/platform/src/hdf_wlan_config_parser.c @@ -250,6 +250,8 @@ static int32_t ParseWlanPowerConfig(const struct DeviceResourceNode *node, static int32_t ParseWlanPowersConfig(const struct DeviceResourceNode *node, struct HdfConfWlanPowers *powersConfig) { struct DeviceResourceIface *drsOps = NULL; + const struct DeviceResourceNode *fstPowerNode = NULL; + const struct DeviceResourceNode *secPowerNode = NULL; if (node == NULL || powersConfig == NULL) { HDF_LOGE("%s: at least one of the paras is NULL!", __func__); return HDF_FAILURE; @@ -259,8 +261,7 @@ static int32_t ParseWlanPowersConfig(const struct DeviceResourceNode *node, stru HDF_LOGE("%s: at least one of the paras is NULL!", __func__); return HDF_FAILURE; } - - const struct DeviceResourceNode *fstPowerNode = drsOps->GetChildNode(node, "power0"); + fstPowerNode = drsOps->GetChildNode(node, "power0"); if (fstPowerNode == NULL) { HDF_LOGE("%s: get power0 config fail!", __func__); return HDF_FAILURE; @@ -269,7 +270,7 @@ static int32_t ParseWlanPowersConfig(const struct DeviceResourceNode *node, stru return HDF_FAILURE; } - const struct DeviceResourceNode *secPowerNode = drsOps->GetChildNode(node, "power1"); + secPowerNode = drsOps->GetChildNode(node, "power1"); if (secPowerNode == NULL) { HDF_LOGE("%s: get power1 config fail!", __func__); return HDF_FAILURE; diff --git a/model/network/wifi/platform/src/hdf_wlan_power_manager.c b/model/network/wifi/platform/src/hdf_wlan_power_manager.c index 50592e734d3d5c9092a774b0dd9707524ea20668..1c7f29c927dcaff06e1c1db12241c8aa5bc5ef36 100644 --- a/model/network/wifi/platform/src/hdf_wlan_power_manager.c +++ b/model/network/wifi/platform/src/hdf_wlan_power_manager.c @@ -142,11 +142,11 @@ int32_t HdfWlanPowerMgrRelease(struct PowerManager* powerMgr) */ struct PowerManager* HdfWlanCreatePowerManager(const struct HdfConfWlanPowers *configPowers) { + struct PowerManagerImpl *powerMgrimpl = NULL; if (configPowers == NULL) { HDF_LOGE("%s: configPowers is NULL", __func__); return NULL; } - struct PowerManagerImpl *powerMgrimpl = NULL; powerMgrimpl = (struct PowerManagerImpl *)OsalMemCalloc(sizeof(struct PowerManagerImpl)); if (powerMgrimpl == NULL) { HDF_LOGE("%s: OsalMemCalloc fail! ", __func__); @@ -157,6 +157,5 @@ struct PowerManager* HdfWlanCreatePowerManager(const struct HdfConfWlanPowers *c powerMgrimpl->base.Release = HdfWlanPowerMgrRelease; powerMgrimpl->powerDatas.power0 = configPowers->power0; powerMgrimpl->powerDatas.power1 = configPowers->power1; - return (struct PowerManager *)powerMgrimpl; } \ No newline at end of file diff --git a/model/network/wifi/platform/src/hdf_wlan_priority_queue.c b/model/network/wifi/platform/src/hdf_wlan_priority_queue.c index e61c904359f86fe9382af711914b8bc256f87d87..76daf48428a0cfe9c23cdfc77998fc56bfe290fa 100644 --- a/model/network/wifi/platform/src/hdf_wlan_priority_queue.c +++ b/model/network/wifi/platform/src/hdf_wlan_priority_queue.c @@ -29,6 +29,7 @@ PriorityQueue *CreatePriorityQueue(uint16_t queueSize, uint8_t priorityLevelCoun uint32_t queueMemSize; PriorityQueueImpl *priorityQueue = NULL; uint32_t ret = HDF_SUCCESS; + HDF_STATUS status; if (priorityLevelCount > MAX_PRIORITY_LEVEL || priorityLevelCount == 0) { HDF_LOGE("%s:priorityLevelCount must in 1 to 8", __func__); return NULL; @@ -51,8 +52,7 @@ PriorityQueue *CreatePriorityQueue(uint16_t queueSize, uint8_t priorityLevelCoun DestroyPriorityQueue((PriorityQueue *)priorityQueue); return NULL; } - - HDF_STATUS status = OsalSemInit(&priorityQueue->messageSemaphore, 0); + status = OsalSemInit(&priorityQueue->messageSemaphore, 0); if (status != HDF_SUCCESS) { DestroyPriorityQueue((PriorityQueue *)priorityQueue); return NULL; @@ -64,6 +64,7 @@ PriorityQueue *CreatePriorityQueue(uint16_t queueSize, uint8_t priorityLevelCoun void DestroyPriorityQueue(PriorityQueue *queue) { uint8_t i; + HDF_STATUS status; PriorityQueueImpl *queueImpl = (PriorityQueueImpl *)queue; if (queue == NULL) { return; @@ -76,7 +77,7 @@ void DestroyPriorityQueue(PriorityQueue *queue) DestroyQueue(queueImpl->queues[i]); queueImpl->queues[i] = NULL; } - HDF_STATUS status = OsalSemDestroy(&queueImpl->messageSemaphore); + status = OsalSemDestroy(&queueImpl->messageSemaphore); if (status != HDF_SUCCESS) { HDF_LOGE("%s:Destroy message queue semaphore failed!status=%d", __func__, status); } diff --git a/model/network/wifi/platform/src/hdf_wlan_utils.c b/model/network/wifi/platform/src/hdf_wlan_utils.c index b7dc9ac2476f57d0d3bc60ca53e61b1b484bd3c5..a6bd35cc242ffdad14539ea96cb9669c9b294ef8 100644 --- a/model/network/wifi/platform/src/hdf_wlan_utils.c +++ b/model/network/wifi/platform/src/hdf_wlan_utils.c @@ -1,10 +1,10 @@ -/* - * 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. - */ +/* + * 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_wlan_utils.h" #include @@ -45,6 +45,7 @@ struct WlanHwCapability *GetHwCapability(struct NetDevice *netDev) { struct HdfChipDriver *chipDriver = GetChipDriver(netDev); struct WlanHwCapability *capability = NULL; + int32_t ret; if (chipDriver == NULL) { HDF_LOGE("%s:bad net device found!", __func__); return NULL; @@ -53,7 +54,7 @@ struct WlanHwCapability *GetHwCapability(struct NetDevice *netDev) HDF_LOGE("%s: chipdriver not implemented", __func__); return NULL; } - int32_t ret = chipDriver->ops->GetHwCapability(netDev, &capability); + ret = chipDriver->ops->GetHwCapability(netDev, &capability); if (ret != HDF_SUCCESS || capability == NULL) { HDF_LOGE("%s:GetHwCapability failed!ifName=%s,ret=%d", __func__, netDev->name, ret); return NULL; @@ -222,6 +223,7 @@ char *HdfWlanGetIfNames(const uint8_t chipId, uint8_t *ifNameCount) char *ifNames = NULL; uint32_t bufferSize; uint8_t i, j; + int32_t ret; if (ifNameCount == NULL) { HDF_LOGE("%s: para is NULL", __func__); return NULL; @@ -239,29 +241,25 @@ char *HdfWlanGetIfNames(const uint8_t chipId, uint8_t *ifNameCount) (*ifNameCount)++; } } - if (*ifNameCount == 0) { // Never alloc 0 size bufferSize = sizeof(char); } else { bufferSize = IFNAMSIZ * (uint32_t)(*ifNameCount); } - ifNames = (char *)OsalMemCalloc(bufferSize); if (ifNames == NULL) { HDF_LOGE("%s: oom!", __func__); return NULL; } - if (*ifNameCount == 0) { return ifNames; } - for (i = 0, j = 0; i < MAX_IF_COUNT; i++) { if (((netIfMapTemp >> i) & 0x1) == 0) { continue; } - int32_t ret = GetPlatformIfName(i, ifNames + (j * IFNAMSIZ), IFNAMSIZ); + ret = GetPlatformIfName(i, ifNames + (j * IFNAMSIZ), IFNAMSIZ); if (ret != HDF_SUCCESS) { HDF_LOGE("%s:Get ifName failed!ret=%d", __func__, ret); OsalMemFree(ifNames); diff --git a/model/network/wifi/platform/src/message/message_dispatcher.c b/model/network/wifi/platform/src/message/message_dispatcher.c index 23056b8000bf8661adb6aaf893df256883eccaa1..9231270ded554e4c8f603bc912c0074811a49d0b 100644 --- a/model/network/wifi/platform/src/message/message_dispatcher.c +++ b/model/network/wifi/platform/src/message/message_dispatcher.c @@ -61,6 +61,7 @@ void ReleaseMessageMapper(struct ServiceDef *mapper) struct MessageDef *GetMsgDef(const struct ServiceDef *serviceDef, uint32_t commandId) { + struct MessageDef *msgDef = NULL; if (serviceDef == NULL || serviceDef->messages == NULL) { HDF_LOGE("%s:input is NULL!", __func__); return NULL; @@ -70,7 +71,7 @@ struct MessageDef *GetMsgDef(const struct ServiceDef *serviceDef, uint32_t comma return NULL; } - struct MessageDef *msgDef = serviceDef->messages + commandId; + msgDef = serviceDef->messages + commandId; if (msgDef->handler == NULL) { HDF_LOGE("%s:command has no handler!", __func__); return NULL; @@ -103,11 +104,12 @@ ErrorCode AppendToLocalDispatcher(MessageDispatcher *dispatcher, const uint8_t p void SetToResponse(MessageContext *context) { + ServiceId senderId; if (context->requestType != MESSAGE_TYPE_ASYNC_REQ && context->requestType != MESSAGE_TYPE_SYNC_REQ) { HDF_LOGE("Only sync and async message can send response!type=%u", context->requestType); return; } - ServiceId senderId = context->senderId; + senderId = context->senderId; context->senderId = context->receiverId; context->receiverId = senderId; context->requestType = MESSAGE_RSP_START + context->requestType - MESSAGE_REQ_START; @@ -128,11 +130,12 @@ static void HandleAsyncResponse(MessageContext *context) static void HandleSyncResponse(MessageContext *context) { + HDF_STATUS status; if (context == NULL) { HDF_LOGE("Input context is NULL!"); return; } - HDF_STATUS status = OsalSemPost(&context->rspSemaphore); + status = OsalSemPost(&context->rspSemaphore); if (status != HDF_SUCCESS) { HDF_LOGE("Send semaphore failed!CMD=%u,Sender=%u,Receiver=%u", context->commandId, context->senderId, context->receiverId); @@ -229,11 +232,13 @@ static void ReleaseAllMessage(MessageDispatcher *dispatcher) static int RunDispatcher(void *para) { + MessageDispatcher *dispatcher = NULL; + MessageContext *context = NULL; if (para == NULL) { HDF_LOGE("Start dispatcher failed! cause:%s\n", "input para is NULL"); return ME_ERROR_NULL_PTR; } - MessageDispatcher *dispatcher = (MessageDispatcher *)para; + dispatcher = (MessageDispatcher *)para; if (dispatcher->messageQueue == NULL) { HDF_LOGE("Start dispatcher failed! cause:%s\n", "message queue is NULL"); return ME_ERROR_NULL_PTR; @@ -253,7 +258,7 @@ static int RunDispatcher(void *para) dispatcher->status = ME_STATUS_RUNNING; } while (dispatcher->status == ME_STATUS_RUNNING) { - MessageContext *context = PopPriorityQueue(dispatcher->messageQueue, QUEUE_OPER_TIMEOUT); + context = PopPriorityQueue(dispatcher->messageQueue, QUEUE_OPER_TIMEOUT); if (context == NULL) { continue; } @@ -273,26 +278,30 @@ static int RunDispatcher(void *para) static ErrorCode StartDispatcher(MessageDispatcher *dispatcher) { + HDF_STATUS status; + ErrorCode errCode; + LocalMessageDispatcher *localDispatcher = NULL; + struct OsalThreadParam config; if (dispatcher == NULL) { return ME_ERROR_NULL_PTR; } - HDF_STATUS status = OsalMutexTimedLock(&dispatcher->mutex, HDF_WAIT_FOREVER); + + status = OsalMutexTimedLock(&dispatcher->mutex, HDF_WAIT_FOREVER); if (status != HDF_SUCCESS) { return ME_ERROR_OPER_MUTEX_FAILED; } - ErrorCode errCode = ME_SUCCESS; + + errCode = ME_SUCCESS; do { if (dispatcher->status != ME_STATUS_STOPPED) { errCode = ME_ERROR_WRONG_STATUS; break; } dispatcher->status = ME_STATUS_STARTTING; - struct OsalThreadParam config = { - .name = "MessageDispatcher", - .priority = OSAL_THREAD_PRI_DEFAULT, - .stackSize = 0x2000, - }; - LocalMessageDispatcher *localDispatcher = (LocalMessageDispatcher *)dispatcher; + config.name = "MessageDispatcher"; + config.priority = OSAL_THREAD_PRI_DEFAULT; + config.stackSize = 0x2000; + localDispatcher = (LocalMessageDispatcher *)dispatcher; status = OsalThreadCreate(&localDispatcher->dispatcherThread, RunDispatcher, localDispatcher); if (status != HDF_SUCCESS) { HDF_LOGE("%s:OsalThreadCreate failed!status=%d", __func__, status); @@ -300,6 +309,7 @@ static ErrorCode StartDispatcher(MessageDispatcher *dispatcher) errCode = ME_ERROR_CREATE_THREAD_FAILED; break; } + status = OsalThreadStart(&localDispatcher->dispatcherThread, &config); if (status != HDF_SUCCESS) { HDF_LOGE("%s:OsalThreadStart failed!status=%d", __func__, status); @@ -327,11 +337,11 @@ static ErrorCode StartDispatcher(MessageDispatcher *dispatcher) static void ShutdownDispatcher(MessageDispatcher *dispatcher) { + HDF_STATUS status; if (dispatcher == NULL) { return; } - - HDF_STATUS status = OsalMutexTimedLock(&dispatcher->mutex, HDF_WAIT_FOREVER); + status = OsalMutexTimedLock(&dispatcher->mutex, HDF_WAIT_FOREVER); if (status != HDF_SUCCESS) { HDF_LOGE("Get lock failed!status=%d", status); return; @@ -354,6 +364,7 @@ static void ShutdownDispatcher(MessageDispatcher *dispatcher) IMPLEMENT_SHARED_OBJ(MessageDispatcher); static void DestroyLocalDispatcher(MessageDispatcher *dispatcher) { + int32_t ret; if (dispatcher == NULL) { return; } @@ -365,7 +376,7 @@ static void DestroyLocalDispatcher(MessageDispatcher *dispatcher) dispatcher->messageQueue = NULL; } - int32_t ret = OsalMutexDestroy(&dispatcher->mutex); + ret = OsalMutexDestroy(&dispatcher->mutex); if (ret != HDF_SUCCESS) { HDF_LOGE("%s:Release mutex failed.ret=%d", __func__, ret); } @@ -375,16 +386,17 @@ static void DestroyLocalDispatcher(MessageDispatcher *dispatcher) ErrorCode CreateLocalDispatcher(MessageDispatcher **dispatcher, const DispatcherConfig *config) { + LocalMessageDispatcher *localDispatcher = NULL; + int32_t ret; + ErrorCode errCode; if (dispatcher == NULL || config == NULL) { return ME_ERROR_NULL_PTR; } - LocalMessageDispatcher *localDispatcher = (LocalMessageDispatcher *)OsalMemCalloc(sizeof(LocalMessageDispatcher)); + localDispatcher = (LocalMessageDispatcher *)OsalMemCalloc(sizeof(LocalMessageDispatcher)); if (localDispatcher == NULL) { return ME_ERROR_RES_LAKE; } - - ErrorCode errCode; do { localDispatcher->status = ME_STATUS_STOPPED; localDispatcher->AppendMessage = AppendToLocalDispatcher; @@ -397,7 +409,7 @@ ErrorCode CreateLocalDispatcher(MessageDispatcher **dispatcher, const Dispatcher break; } - int32_t ret = OsalMutexInit(&localDispatcher->mutex); + ret = OsalMutexInit(&localDispatcher->mutex); if (ret != HDF_SUCCESS) { errCode = ME_ERROR_OPER_MUTEX_FAILED; break; diff --git a/model/network/wifi/platform/src/message/message_router.c b/model/network/wifi/platform/src/message/message_router.c index 3776a3e6639faab4add0ecdd2dbc58a1880e486b..17e295e1c007cda2d88f59ed725279bd87762d93 100644 --- a/model/network/wifi/platform/src/message/message_router.c +++ b/model/network/wifi/platform/src/message/message_router.c @@ -70,6 +70,7 @@ static void ReleaseRemoteService(RemoteService *service) static MessageDispatcher *RefDispatcherInner(const DispatcherId dispatcherId, bool requireLock) { + MessageDispatcher *result = NULL; if (dispatcherId >= MESSAGE_ENGINE_MAX_DISPATCHER) { HDF_LOGE("%s:Input ID is too big.input=%u", __func__, dispatcherId); return NULL; @@ -82,7 +83,7 @@ static MessageDispatcher *RefDispatcherInner(const DispatcherId dispatcherId, bo return NULL; } } - MessageDispatcher *result = NULL; + do { if (g_dispatchers[dispatcherId] == NULL) { break; @@ -105,17 +106,19 @@ static MessageDispatcher *RefDispatcherInner(const DispatcherId dispatcherId, bo static ErrorCode RegDispatcher(DispatcherId dispatcherId, MessageDispatcher *dispatcher) { + HDF_STATUS status; + ErrorCode errCode; if (dispatcherId >= MESSAGE_ENGINE_MAX_DISPATCHER) { HDF_LOGE("%s:dispatcher id is too big!id=%u", __func__, dispatcherId); return ME_ERROR_PARA_WRONG; } - HDF_STATUS status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); + status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); if (status != HDF_SUCCESS) { HDF_LOGE("Unable to get lock!status=%d", status); return ME_ERROR_OPER_MUTEX_FAILED; } - ErrorCode errCode = ME_SUCCESS; + errCode = ME_SUCCESS; do { if (g_routerStatus != ME_STATUS_RUNNING) { errCode = ME_ERROR_WRONG_STATUS; @@ -138,11 +141,12 @@ static ErrorCode RegDispatcher(DispatcherId dispatcherId, MessageDispatcher *dis ErrorCode AddDispatcher(DispatcherConfig *config) { + ErrorCode errCode; + MessageDispatcher *dispatcher = NULL; if (config == NULL) { return ME_ERROR_NULL_PTR; } - MessageDispatcher *dispatcher = NULL; - ErrorCode errCode = CreateLocalDispatcher(&dispatcher, config); + errCode = CreateLocalDispatcher(&dispatcher, config); if (errCode != ME_SUCCESS) { return errCode; } @@ -190,12 +194,13 @@ static void NotifyAllNodesServiceDel(const NodeId nodeId, ServiceId serviceId) static ErrorCode NotifyAllNodesServiceAdd(const NodeId nodeId, struct ServiceDef *mapper) { uint8_t i; + uint8_t notifyNodeIndex; + ErrorCode errCode; if (mapper == NULL) { return ME_ERROR_NULL_PTR; } - ErrorCode errCode = ME_SUCCESS; - uint8_t notifyNodeIndex; + errCode = ME_SUCCESS; for (notifyNodeIndex = 0; notifyNodeIndex < MAX_NODE_COUNT; notifyNodeIndex++) { if (notifyNodeIndex == nodeId) { continue; @@ -258,6 +263,11 @@ static ErrorCode DoRegistService(const NodeId nodeId, const DispatcherId dispatc } static ErrorCode RegistServiceInner(const NodeId nodeId, const DispatcherId dispatcherId, struct ServiceDef *mapper) { + HDF_STATUS status; + MessageNode *node = NULL; + RemoteService *remoteService = NULL; + MessageDispatcher *dispatcher = NULL; + ErrorCode errCode; if (mapper == NULL) { return ME_ERROR_NULL_PTR; } @@ -266,22 +276,18 @@ static ErrorCode RegistServiceInner(const NodeId nodeId, const DispatcherId disp HDF_LOGE("%s:serviceId exceed max value! ServiceId=%u", __func__, mapper->serviceId); return ME_ERROR_PARA_WRONG; } - HDF_STATUS status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); + status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); if (status != HDF_SUCCESS) { HDF_LOGE("Unable to get lock!status=%d", status); return ME_ERROR_OPER_MUTEX_FAILED; } - MessageNode *node = RefMessageNode(nodeId, false); + node = RefMessageNode(nodeId, false); if (node == NULL) { HDF_LOGE("%s:Node not found!", __func__); OsalMutexUnlock(&g_routerMutex); return ME_ERROR_NO_SUCH_NODE; } - RemoteService *remoteService = NULL; - MessageDispatcher *dispatcher = NULL; - - ErrorCode errCode; do { if (node->CreateRemoteService == NULL) { HDF_LOGE("%s:Can not reg service to node %d", __func__, nodeId); @@ -337,6 +343,8 @@ ErrorCode RegistLocalService(const DispatcherId dispatcherId, struct ServiceDef ErrorCode RegistRemoteService(NodeId nodeId, RemoteService *service) { + HDF_STATUS status; + ErrorCode errCode; if (service == NULL) { return ME_ERROR_NULL_PTR; } @@ -348,13 +356,13 @@ ErrorCode RegistRemoteService(NodeId nodeId, RemoteService *service) HDF_LOGE("%s:NodeId exceed max value! NodeId=%d", __func__, nodeId); return ME_ERROR_PARA_WRONG; } - HDF_STATUS status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); + status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); if (status != HDF_SUCCESS) { HDF_LOGE("Unable to get lock!status=%d", status); return ME_ERROR_OPER_MUTEX_FAILED; } - ErrorCode errCode = DoRegistService(nodeId, BAD_DISPATCHER_ID, service); + errCode = DoRegistService(nodeId, BAD_DISPATCHER_ID, service); if (errCode != ME_SUCCESS) { HDF_LOGE("%s:RegService failed! errCode=%d", __func__, errCode); } @@ -367,16 +375,19 @@ ErrorCode RegistRemoteService(NodeId nodeId, RemoteService *service) } static ErrorCode UnregistServiceInner(const NodeId nodeId, const DispatcherId dispatcherId, const ServiceId serviceId) { + RemoteService *service = NULL; + HDF_STATUS status; + ErrorCode errCode; if (serviceId >= MESSAGE_ENGINE_MAX_SERVICE) { return ME_ERROR_PARA_WRONG; } - HDF_STATUS status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); + status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); if (status != HDF_SUCCESS) { HDF_LOGE("Unable to get lock!status=%d", status); return ME_ERROR_OPER_MUTEX_FAILED; } - ErrorCode errCode = ME_SUCCESS; + errCode = ME_SUCCESS; do { if (g_servicesIndex[serviceId].nodeIndex != nodeId || g_servicesIndex[serviceId].dispatcherId != dispatcherId) { errCode = ME_ERROR_NO_SUCH_SERVICE; @@ -386,7 +397,7 @@ static ErrorCode UnregistServiceInner(const NodeId nodeId, const DispatcherId di errCode = ME_ERROR_NO_SUCH_SERVICE; break; } - RemoteService *service = g_servicesIndex[serviceId].remoteService; + service = g_servicesIndex[serviceId].remoteService; ReleaseRemoteService(service); g_servicesIndex[serviceId].remoteService = NULL; g_servicesIndex[serviceId].nodeIndex = NO_SUCH_NODE_INDEX; @@ -438,6 +449,9 @@ static bool CheckServiceID(ServiceId serviceId, bool allowSync) RemoteService *RefRemoteService(ServiceId serviceId) { + HDF_STATUS status; + RemoteService *remoteService = NULL; + RemoteService *service = NULL; if (serviceId >= MESSAGE_ENGINE_MAX_SERVICE) { return NULL; } @@ -445,16 +459,14 @@ RemoteService *RefRemoteService(ServiceId serviceId) if (!CheckServiceID(serviceId, true)) { return NULL; } - - RemoteService *service = NULL; - HDF_STATUS status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); + status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); if (status != HDF_SUCCESS) { HDF_LOGE("Unable to get lock!status=%d", status); return NULL; } do { - RemoteService *remoteService = g_servicesIndex[serviceId].remoteService; + remoteService = g_servicesIndex[serviceId].remoteService; if (remoteService != NULL && remoteService->Ref != NULL) { service = remoteService->Ref(remoteService); } @@ -469,11 +481,12 @@ RemoteService *RefRemoteService(ServiceId serviceId) ErrorCode SendMessage(MessageContext *context) { - RemoteService *service = RefRemoteService(context->receiverId); + RemoteService *service = NULL; + ErrorCode errCode; + service = RefRemoteService(context->receiverId); if (service == NULL) { return ME_ERROR_NO_SUCH_SERVICE; } - ErrorCode errCode; do { if (service->SendMessage == NULL) { errCode = ME_ERROR_NOT_SUPPORTED; @@ -552,6 +565,7 @@ static void ReleaseNodes(void) static ErrorCode DoStartMessageRouter(uint8_t nodesConfig) { uint8_t i; + ErrorCode errCode; if (g_routerStatus != ME_STATUS_STOPPED) { HDF_LOGE("Router have already started!"); return ME_ERROR_MUTI_INIT_NOT_ALLOWED; @@ -562,8 +576,6 @@ static ErrorCode DoStartMessageRouter(uint8_t nodesConfig) g_servicesIndex[i].nodeIndex = NO_SUCH_NODE_INDEX; g_servicesIndex[i].dispatcherId = BAD_DISPATCHER_ID; } - - ErrorCode errCode; do { HDF_LOGE("%s:Create local node ...", __func__); errCode = CreateLocalNode(&g_messageNodes[LOCAL_NODE_INDEX]); @@ -595,13 +607,14 @@ static ErrorCode DoStartMessageRouter(uint8_t nodesConfig) ErrorCode EnableDefaultDispatcher(void) { + ErrorCode errCode; DispatcherConfig config = { .dispatcherId = DEFAULT_DISPATCHER_ID, .queueSize = DEFAULT_DISPATCHER_QUEUE_SIZE, .priorityLevelCount = DEFAULT_DISPATCHER_PRIORITY_COUNT }; HDF_LOGI("Register default dispatcher..."); - ErrorCode errCode = AddDispatcher(&config); + errCode = AddDispatcher(&config); if (errCode != ME_SUCCESS) { HDF_LOGE("Register default dispatcher failed!ret=%d", errCode); } @@ -610,18 +623,20 @@ ErrorCode EnableDefaultDispatcher(void) ErrorCode StartMessageRouter(uint8_t nodesConfig) { + HDF_STATUS status; + ErrorCode errCode; if (g_routerMutex.realMutex == NULL) { HDF_STATUS status = OsalMutexInit(&g_routerMutex); if (status != HDF_SUCCESS) { return ME_ERROR_OPER_MUTEX_FAILED; } } - HDF_STATUS status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); + status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); if (status != HDF_SUCCESS) { HDF_LOGE("Unable to get lock!status=%d", status); return ME_ERROR_OPER_MUTEX_FAILED; } - ErrorCode errCode = DoStartMessageRouter(nodesConfig); + errCode = DoStartMessageRouter(nodesConfig); status = OsalMutexUnlock(&g_routerMutex); if (status != HDF_SUCCESS) { HDF_LOGE("Unable to get lock!status=%d", status); @@ -632,6 +647,7 @@ ErrorCode StartMessageRouter(uint8_t nodesConfig) static ErrorCode DoShutdownMessageRouter(void) { uint8_t i; + RemoteService *service = NULL; if (g_routerStatus == ME_STATUS_STOPPED) { return ME_SUCCESS; } @@ -641,7 +657,7 @@ static ErrorCode DoShutdownMessageRouter(void) if (g_servicesIndex[i].remoteService == NULL) { continue; } - RemoteService *service = g_servicesIndex[i].remoteService; + service = g_servicesIndex[i].remoteService; g_servicesIndex[i].remoteService = NULL; g_servicesIndex[i].nodeIndex = NO_SUCH_NODE_INDEX; g_servicesIndex[i].dispatcherId = BAD_DISPATCHER_ID; @@ -666,15 +682,15 @@ static ErrorCode DoShutdownMessageRouter(void) ErrorCode ShutdownMessageRouter() { + HDF_STATUS status; + ErrorCode errCode; HDF_LOGW("%s:Shutdown router...", __func__); - HDF_STATUS status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); + status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); if (status != HDF_SUCCESS) { HDF_LOGE("Unable to get lock!status=%d", status); return ME_ERROR_OPER_MUTEX_FAILED; } - - ErrorCode errCode = DoShutdownMessageRouter(); - + errCode = DoShutdownMessageRouter(); status = OsalMutexUnlock(&g_routerMutex); if (status != HDF_SUCCESS) { HDF_LOGE("Unable to get lock!status=%d", status); @@ -687,13 +703,14 @@ ErrorCode ShutdownMessageRouter() MessageNode *RefMessageNode(const NodeId nodeId, bool isRequireLock) { + MessageNode *node = NULL; + HDF_STATUS status; if (nodeId >= MAX_NODE_COUNT) { HDF_LOGE("Input nodeId >= MAX_NODE_COUNT"); return NULL; } - MessageNode *node = NULL; if (isRequireLock) { - HDF_STATUS status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); + status = OsalMutexTimedLock(&g_routerMutex, HDF_WAIT_FOREVER); if (status != HDF_SUCCESS) { HDF_LOGE("%s:require lock failed!", __func__); return NULL; @@ -705,7 +722,7 @@ MessageNode *RefMessageNode(const NodeId nodeId, bool isRequireLock) } if (isRequireLock) { - HDF_STATUS status = OsalMutexUnlock(&g_routerMutex); + status = OsalMutexUnlock(&g_routerMutex); if (status != HDF_SUCCESS) { HDF_LOGE("%s:Unlock mutex failed!", __func__); } diff --git a/model/network/wifi/platform/src/message/nodes/local_node.c b/model/network/wifi/platform/src/message/nodes/local_node.c index b5b8c89a114ce8d8f986590e1a1fc5aabfd7f385..24b856024f6c57a0a124d6a5229912bc70a3fa6a 100644 --- a/model/network/wifi/platform/src/message/nodes/local_node.c +++ b/model/network/wifi/platform/src/message/nodes/local_node.c @@ -31,13 +31,14 @@ typedef struct LocalNodeService { static void HandleRequestMessage(const RemoteService *service, MessageContext *context) { + LocalNodeService *localNodeService = NULL; + localNodeService = (LocalNodeService *)service; + struct MessageDef messageDef = { NULL, 0 }; + if (context == NULL || service == NULL) { HDF_LOGE("%s:input is NULL", __func__); return; } - LocalNodeService *localNodeService = (LocalNodeService *)service; - - struct MessageDef messageDef = { NULL, 0 }; if (localNodeService->mapper != NULL && context->commandId < localNodeService->mapper->messagesLength) { messageDef = localNodeService->mapper->messages[context->commandId]; } @@ -50,13 +51,14 @@ static void HandleRequestMessage(const RemoteService *service, MessageContext *c static void HandleResponseMessage(const RemoteService *service, MessageContext *context) { + HDF_STATUS status; (void)service; if (context->requestType < MESSAGE_RSP_START) { return; } if (context->requestType == MESSAGE_TYPE_SYNC_RSP) { - HDF_STATUS status = OsalSemPost(&context->rspSemaphore); + status = OsalSemPost(&context->rspSemaphore); if (status != HDF_SUCCESS) { ReleaseMessageContext(context); } @@ -73,6 +75,7 @@ static void HandleResponseMessage(const RemoteService *service, MessageContext * ErrorCode SendMessageLocalNode(const RemoteService *service, MessageContext *context) { + LocalNodeService *localService = NULL; uint8_t pri = HIGHEST_PRIORITY; if (service == NULL || context == NULL) { HDF_LOGE("%s:Input is NULL!", __func__); @@ -87,7 +90,7 @@ ErrorCode SendMessageLocalNode(const RemoteService *service, MessageContext *con (void)OsalSemPost(&context->rspSemaphore); return ME_SUCCESS; } else { - LocalNodeService *localService = (LocalNodeService *)service; + localService = (LocalNodeService *)service; if (localService->dispatcher == NULL || localService->dispatcher->AppendMessage == NULL) { HDF_LOGE("This service has no dispatcher!"); return ME_ERROR_NOT_SUPPORTED; @@ -117,10 +120,11 @@ static void ShutdownLocalService(RemoteService *service) static void DestroyLocalNodeRemoteService(RemoteService *service) { + LocalNodeService *localService = NULL; if (service == NULL) { return; } - LocalNodeService *localService = (LocalNodeService *)service; + localService = (LocalNodeService *)service; if (localService->dispatcher != NULL && localService->dispatcher->Disref != NULL) { localService->dispatcher->Disref(localService->dispatcher); } @@ -131,6 +135,9 @@ static void DestroyLocalNodeRemoteService(RemoteService *service) RemoteService *CreateLocalNodeService(MessageNode *node, MessageDispatcher *dispatcher, struct ServiceDef *mapper) { + LocalNodeService *service = NULL; + ErrorCode errCode; + (void)node; if (mapper == NULL) { return NULL; } @@ -138,14 +145,10 @@ RemoteService *CreateLocalNodeService(MessageNode *node, MessageDispatcher *disp HDF_LOGE("%s:Bad dispatcher found!", __func__); return NULL; } - (void)node; - - LocalNodeService *service = (LocalNodeService *)OsalMemCalloc(sizeof(LocalNodeService)); + service = (LocalNodeService *)OsalMemCalloc(sizeof(LocalNodeService)); if (service == NULL) { return NULL; } - - ErrorCode errCode; do { service->status = ME_STATUS_RUNNING; service->ExecRequestMsg = HandleRequestMessage; @@ -176,16 +179,17 @@ RemoteService *CreateLocalNodeService(MessageNode *node, MessageDispatcher *disp static ErrorCode InitLocalNode(MessageNode *node) { + HDF_STATUS status; + ErrorCode errCode; if (node == NULL) { return ME_ERROR_NULL_PTR; } - HDF_STATUS status = OsalMutexTimedLock(&node->mutex, HDF_WAIT_FOREVER); + status = OsalMutexTimedLock(&node->mutex, HDF_WAIT_FOREVER); if (status != HDF_SUCCESS) { return ME_ERROR_OPER_MUTEX_FAILED; } - - ErrorCode errCode = ME_SUCCESS; + errCode = ME_SUCCESS; do { if (node->status != ME_STATUS_STOPPED) { HDF_LOGE("%s:unexpected status %d", __func__, node->status); @@ -224,10 +228,11 @@ static ErrorCode InitLocalNode(MessageNode *node) static void DestroyLocalNode(MessageNode *node) { + int32_t ret; if (node == NULL) { return; } - int32_t ret = OsalMutexDestroy(&node->mutex); + ret = OsalMutexDestroy(&node->mutex); if (ret != HDF_SUCCESS) { HDF_LOGE("%s:Release mutex failed!ret=%d", __func__, ret); } @@ -236,15 +241,17 @@ static void DestroyLocalNode(MessageNode *node) ErrorCode CreateLocalNode(MessageNode **node) { + int32_t ret; + LocalMessageNode *newNode = NULL; + ErrorCode errCode; if (node == NULL) { return ME_ERROR_NULL_PTR; } HDF_LOGI("Creating local node..."); - LocalMessageNode *newNode = (LocalMessageNode *)OsalMemCalloc(sizeof(LocalMessageNode)); + newNode = (LocalMessageNode *)OsalMemCalloc(sizeof(LocalMessageNode)); if (newNode == NULL) { return ME_ERROR_RES_LAKE; } - ErrorCode errCode; do { newNode->status = ME_STATUS_STOPPED; newNode->Init = InitLocalNode; @@ -253,7 +260,7 @@ ErrorCode CreateLocalNode(MessageNode **node) newNode->NotifyServiceAdd = NULL; newNode->NotifyServiceDel = NULL; - int32_t ret = OsalMutexInit(&newNode->mutex); + ret = OsalMutexInit(&newNode->mutex); if (ret != HDF_SUCCESS) { HDF_LOGE("%s:Init mutex failed!err=%d", __func__, ret); errCode = ME_ERROR_OPER_MUTEX_FAILED; diff --git a/model/network/wifi/platform/src/message/sidecar.c b/model/network/wifi/platform/src/message/sidecar.c index dc8692e93507f1f2ac8fbe159aa901a64fd74e6e..75843c05f0f54c03b5b4b43207c906e7fed198cc 100644 --- a/model/network/wifi/platform/src/message/sidecar.c +++ b/model/network/wifi/platform/src/message/sidecar.c @@ -26,12 +26,13 @@ typedef struct { static ErrorCode MessageInputCheck(const Service *sideCar, ServiceId receiver, struct HdfSBuf *sendData) { + SideCarPrivateData *privateData = NULL; if (sideCar == NULL || sideCar->privateData == NULL) { HDF_LOGE("%s:sideCar or sideCar.privateData is NULL", __func__); return ME_ERROR_NULL_PTR; } - SideCarPrivateData *privateData = (SideCarPrivateData *)sideCar->privateData; + privateData = (SideCarPrivateData *)sideCar->privateData; if (receiver >= MESSAGE_ENGINE_MAX_SERVICE || privateData->serviceId >= MESSAGE_ENGINE_MAX_SERVICE) { return ME_ERROR_NO_SUCH_SERVICE; } @@ -74,6 +75,7 @@ int32_t DispatchToMessage(struct HdfDeviceIoClient *client, int id, struct HdfSB ServiceId serviceId = GetServiceID(id); uint32_t cmd = GetCmd(id); MessageContext *context = NULL; + RemoteService *targetService = NULL; if (client == NULL) { return HDF_ERR_INVALID_PARAM; @@ -88,7 +90,6 @@ int32_t DispatchToMessage(struct HdfDeviceIoClient *client, int id, struct HdfSB context->rspData = rspData; context->requestType = MESSAGE_TYPE_SYNC_REQ; context->client = client; - RemoteService *targetService = NULL; do { targetService = RefRemoteService(serviceId); if (targetService == NULL || targetService->SendMessage == NULL) { @@ -109,18 +110,20 @@ int32_t DispatchToMessage(struct HdfDeviceIoClient *client, int id, struct HdfSB static ErrorCode SideCarSendSyncMessage(const Service *sideCar, ServiceId receiver, uint32_t commandId, struct HdfSBuf *sendData, struct HdfSBuf *recvData) { + SideCarPrivateData *privateData = NULL; + MessageContext *context = NULL; + RemoteService *targetService = NULL; ErrorCode errCode = MessageInputCheck(sideCar, receiver, sendData); if (errCode != ME_SUCCESS) { return errCode; } - SideCarPrivateData *privateData = (SideCarPrivateData *)sideCar->privateData; - MessageContext *context = CreateMessageContext(privateData->serviceId, receiver, commandId, sendData); + privateData = (SideCarPrivateData *)sideCar->privateData; + context = CreateMessageContext(privateData->serviceId, receiver, commandId, sendData); if (context == NULL) { return ME_ERROR_NULL_PTR; } context->rspData = recvData; context->requestType = MESSAGE_TYPE_SYNC_REQ; - RemoteService *targetService = NULL; do { targetService = RefRemoteService(receiver); if (targetService == NULL || targetService->SendMessage == NULL) { @@ -141,17 +144,21 @@ static ErrorCode SideCarSendSyncMessage(const Service *sideCar, ServiceId receiv static ErrorCode SideCarSendAsyncMessageInner(const Service *sideCar, ServiceId receiver, uint32_t commandId, struct HdfSBuf *reqData, MessageCallBack callback) { + SideCarPrivateData *privateData = NULL; + MessageContext *context = NULL; + struct HdfSBuf *rspData = NULL; + RemoteService *targetService = NULL; ErrorCode errCode = MessageInputCheck(sideCar, receiver, reqData); if (errCode != ME_SUCCESS) { return errCode; } - SideCarPrivateData *privateData = (SideCarPrivateData *)sideCar->privateData; - MessageContext *context = CreateMessageContext(privateData->serviceId, receiver, commandId, reqData); + privateData = (SideCarPrivateData *)sideCar->privateData; + context = CreateMessageContext(privateData->serviceId, receiver, commandId, reqData); if (context == NULL) { return ME_ERROR_NULL_PTR; } - struct HdfSBuf *rspData = HdfSBufObtainDefaultSize(); + rspData = HdfSBufObtainDefaultSize(); if (rspData == NULL) { OsalMemFree(context); return HDF_FAILURE; @@ -159,8 +166,6 @@ static ErrorCode SideCarSendAsyncMessageInner(const Service *sideCar, ServiceId context->requestType = MESSAGE_TYPE_ASYNC_REQ; context->callback = callback; context->rspData = rspData; - - RemoteService *targetService = NULL; do { targetService = RefRemoteService(receiver); if (targetService == NULL || targetService->SendMessage == NULL) { @@ -199,6 +204,8 @@ static ErrorCode SideCarSendOneWayMessage(const struct SideCar_ *sideCar, Servic static ErrorCode DestroyService(Service *service) { + SideCarPrivateData *data = NULL; + ErrorCode errCode; if (service == NULL) { return ME_ERROR_NULL_PTR; } @@ -207,10 +214,9 @@ static ErrorCode DestroyService(Service *service) HDF_LOGE("%s:privateData is NULL!", __func__); return ME_ERROR_PARA_WRONG; } - SideCarPrivateData *data = (SideCarPrivateData *)service->privateData; + data = (SideCarPrivateData *)service->privateData; HDF_LOGE("Destroy service! id=%d", data->serviceId); - - ErrorCode errCode = UnregistLocalService(data->dispatcherId, data->serviceId); + errCode = UnregistLocalService(data->dispatcherId, data->serviceId); if (errCode != ME_SUCCESS) { HDF_LOGE("Unregist service failed!ret=%d", errCode); return errCode; @@ -224,6 +230,9 @@ static ErrorCode DestroyService(Service *service) Service *InitService(struct ServiceDef *def, const ServiceCfg *cfg) { + Service *service = NULL; + SideCarPrivateData *privateData = NULL; + ErrorCode errCode; if (cfg == NULL || def == NULL) { return NULL; } @@ -233,7 +242,7 @@ Service *InitService(struct ServiceDef *def, const ServiceCfg *cfg) return NULL; } - Service *service = (Service *)OsalMemCalloc(sizeof(Service)); + service = (Service *)OsalMemCalloc(sizeof(Service)); if (service == NULL) { HDF_LOGE("%s:OsalMemAlloc return NULL!", __func__); return NULL; @@ -243,7 +252,7 @@ Service *InitService(struct ServiceDef *def, const ServiceCfg *cfg) service->SendOneWayMessage = SideCarSendOneWayMessage; service->Destroy = DestroyService; - SideCarPrivateData *privateData = (SideCarPrivateData *)OsalMemCalloc(sizeof(SideCarPrivateData)); + privateData = (SideCarPrivateData *)OsalMemCalloc(sizeof(SideCarPrivateData)); if (privateData == NULL) { OsalMemFree(service); HDF_LOGE("%s:OsalMemAlloc return NULL!", __func__); @@ -254,7 +263,7 @@ Service *InitService(struct ServiceDef *def, const ServiceCfg *cfg) service->privateData = (void *)privateData; privateData = NULL; - ErrorCode errCode = RegistLocalService(cfg->dispatcherId, def); + errCode = RegistLocalService(cfg->dispatcherId, def); if (errCode != ME_SUCCESS) { OsalMemFree(service->privateData); service->privateData = NULL; diff --git a/model/network/wifi/platform/src/qos/flow_control_task.c b/model/network/wifi/platform/src/qos/flow_control_task.c index b51209bd83cdb1089f07f27f402248e1e131cb06..a6f3b7a16713458904bc6dea38f33d8d6664c660 100644 --- a/model/network/wifi/platform/src/qos/flow_control_task.c +++ b/model/network/wifi/platform/src/qos/flow_control_task.c @@ -171,6 +171,7 @@ static void DestroyTask(struct FlowControlModule *fcm, FlowDir dir) int32_t CreateFlowControlTask(struct FlowControlModule *fcm) { + int32_t ret; struct OsalThreadParam config = { .priority = OSAL_THREAD_PRI_HIGHEST, .stackSize = 0, @@ -180,8 +181,7 @@ int32_t CreateFlowControlTask(struct FlowControlModule *fcm) HDF_LOGE("%s fail: fcm = null!", __func__); return HDF_ERR_INVALID_PARAM; } - - int32_t ret = CreateTask(&fcm->txTransferThread, RX_THREAD_NAME, RunWiFiTxFlowControl, &config, fcm); + ret = CreateTask(&fcm->txTransferThread, RX_THREAD_NAME, RunWiFiTxFlowControl, &config, fcm); if (ret == HDF_FAILURE) { fcm->threadStatus[FLOW_TX] = THREAD_INIT_FAIL; return HDF_FAILURE; diff --git a/model/sensor/driver/accel/sensor_accel_driver.c b/model/sensor/driver/accel/sensor_accel_driver.c old mode 100644 new mode 100755 index 7f9a88370b1981c6df87c769e1f84951d23b467d..e63650487078e6856288527a102590f0fb9d6def --- a/model/sensor/driver/accel/sensor_accel_driver.c +++ b/model/sensor/driver/accel/sensor_accel_driver.c @@ -29,6 +29,19 @@ static struct AccelDrvData *AccelGetDrvData(void) static struct SensorRegCfgGroupNode *g_regCfgGroup[SENSOR_GROUP_MAX] = { NULL }; +int32_t SubscribeAccelDataCallbackFunc(GravitySubscribeAccelCallback cb) +{ + CHECK_NULL_PTR_RETURN_VALUE(cb, HDF_ERR_INVALID_PARAM); + + struct AccelDrvData *drvData = AccelGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + drvData->cb = cb; + + return HDF_SUCCESS; +} + int32_t AccelRegisterChipOps(const struct AccelOpsCall *ops) { struct AccelDrvData *drvData = AccelGetDrvData(); @@ -44,6 +57,7 @@ int32_t AccelRegisterChipOps(const struct AccelOpsCall *ops) static void AccelDataWorkEntry(void *arg) { struct AccelDrvData *drvData = NULL; + struct SensorReportEvent event; drvData = (struct AccelDrvData *)arg; CHECK_NULL_PTR_RETURN(drvData); @@ -52,8 +66,19 @@ static void AccelDataWorkEntry(void *arg) HDF_LOGI("%s: Accel ReadData function NULl", __func__); return; } - if (drvData->ops.ReadData(drvData->accelCfg) != HDF_SUCCESS) { + + if (drvData->ops.ReadData(drvData->accelCfg, &event) != HDF_SUCCESS) { HDF_LOGE("%s: Accel read data failed", __func__); + return; + } + + if (ReportSensorEvent(&event) != HDF_SUCCESS) { + HDF_LOGE("%s: report accel data failed", __func__); + return; + } + + if (drvData->cb != NULL) { + drvData->cb((int32_t*)event.data, event.dataLen); } } @@ -246,10 +271,17 @@ static int32_t InitAccelAfterDetected(struct SensorCfgData *config) return HDF_FAILURE; } + if (ParseSensorDirection(config) != HDF_SUCCESS) { + HDF_LOGE("%s: Parse accel direction failed", __func__); + (void)DeleteSensorDevice(&config->sensorInfo); + return HDF_FAILURE; + } + if (ParseSensorRegConfig(config) != HDF_SUCCESS) { HDF_LOGE("%s: Parse sensor register failed", __func__); (void)DeleteSensorDevice(&config->sensorInfo); ReleaseSensorAllRegConfig(config); + ReleaseSensorDirectionConfig(config); return HDF_FAILURE; } return HDF_SUCCESS; @@ -299,7 +331,7 @@ BASE_CONFIG_EXIT: (void)memset_s(&drvData->accelCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo)); (void)memset_s(&drvData->accelCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg)); (void)memset_s(&drvData->accelCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr)); - return NULL; + return drvData->accelCfg; } void AccelReleaseCfgData(struct SensorCfgData *accelCfg) @@ -309,6 +341,7 @@ void AccelReleaseCfgData(struct SensorCfgData *accelCfg) (void)DeleteSensorDevice(&accelCfg->sensorInfo); ReleaseSensorAllRegConfig(accelCfg); (void)ReleaseSensorBusHandle(&accelCfg->busCfg); + ReleaseSensorDirectionConfig(accelCfg); accelCfg->root = NULL; (void)memset_s(&accelCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo)); @@ -334,6 +367,7 @@ int32_t AccelInitDriver(struct HdfDeviceObject *device) } drvData->accelCfg->regCfgGroup = &g_regCfgGroup[0]; + drvData->cb = NULL; HDF_LOGI("%s: Init accel driver success", __func__); return HDF_SUCCESS; @@ -346,7 +380,7 @@ void AccelReleaseDriver(struct HdfDeviceObject *device) struct AccelDrvData *drvData = (struct AccelDrvData *)device->service; CHECK_NULL_PTR_RETURN(drvData); - if (drvData->detectFlag) { + if (drvData->detectFlag && drvData->accelCfg != NULL) { AccelReleaseCfgData(drvData->accelCfg); } diff --git a/model/sensor/driver/accel/sensor_accel_driver.h b/model/sensor/driver/accel/sensor_accel_driver.h old mode 100644 new mode 100755 index 4162ae0ddb69f7555de72a20481c0d6361c0e900..5a7d00448c0649837b7c712606700ca14395cf03 --- a/model/sensor/driver/accel/sensor_accel_driver.h +++ b/model/sensor/driver/accel/sensor_accel_driver.h @@ -32,6 +32,8 @@ enum AccelAxisPart { ACCEL_AXIS_BUTT, }; +typedef int32_t (*GravitySubscribeAccelCallback)(int32_t *rawData, int32_t size); + struct AccelData { int32_t x; int32_t y; @@ -40,7 +42,7 @@ struct AccelData { struct AccelOpsCall { int32_t (*Init)(struct SensorCfgData *data); - int32_t (*ReadData)(struct SensorCfgData *data); + int32_t (*ReadData)(struct SensorCfgData *data, struct SensorReportEvent *event); }; struct AccelDrvData { @@ -54,10 +56,11 @@ struct AccelDrvData { int64_t interval; struct SensorCfgData *accelCfg; struct AccelOpsCall ops; + GravitySubscribeAccelCallback cb; }; int32_t AccelRegisterChipOps(const struct AccelOpsCall *ops); struct SensorCfgData *AccelCreateCfgData(const struct DeviceResourceNode *node); void AccelReleaseCfgData(struct SensorCfgData *sensorCfgData); - +int32_t SubscribeAccelDataCallbackFunc(GravitySubscribeAccelCallback cb); #endif /* SENSOR_ACCEL_DRIVER_H */ diff --git a/model/sensor/driver/accel/sensor_gravity_driver.c b/model/sensor/driver/accel/sensor_gravity_driver.c new file mode 100755 index 0000000000000000000000000000000000000000..a697d7d742d2b2989d3c4e88fc48122a1c1396c1 --- /dev/null +++ b/model/sensor/driver/accel/sensor_gravity_driver.c @@ -0,0 +1,335 @@ +/* + * Copyright (c) 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 "sensor_gravity_driver.h" +#include "sensor_accel_driver.h" +#include +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "osal_math.h" +#include "osal_mem.h" +#include "osal_time.h" +#include "sensor_device_manager.h" +#include "sensor_platform_if.h" + +#define HDF_LOG_TAG sensor_gravity_driver_c + +#define HDF_GRAVITY_WORK_QUEUE_NAME "hdf_gravity_work_queue" + +static struct GravityDrvData *g_gravityDrvData = NULL; +static int32_t g_accelRawData[GRAVITY_AXIS_NUM]; + +static struct GravityDrvData *GravityGetDrvData(void) +{ + return g_gravityDrvData; +} + +static int32_t GravitySubscribeAccelData(int32_t *accelData, int32_t size) +{ + CHECK_NULL_PTR_RETURN_VALUE(accelData, HDF_ERR_INVALID_PARAM); + + if (size > GRAVITY_AXIS_NUM * sizeof(int32_t)) { + HDF_LOGE("%s: size exceed max value", __func__); + return HDF_FAILURE; + } + + g_accelRawData[GRAVITY_X_AXIS] = accelData[GRAVITY_X_AXIS]; + g_accelRawData[GRAVITY_Y_AXIS] = accelData[GRAVITY_Y_AXIS]; + g_accelRawData[GRAVITY_Z_AXIS] = accelData[GRAVITY_Z_AXIS]; + + return HDF_SUCCESS; +} + +static void GravityDataWorkEntry(void *arg) +{ + struct GravityDrvData *drvData = NULL; + static int32_t GravityRawData[GRAVITY_AXIS_NUM]; + struct SensorReportEvent event; + drvData = (struct GravityDrvData *)arg; + CHECK_NULL_PTR_RETURN(drvData); + OsalTimespec time; + + GravityRawData[GRAVITY_X_AXIS] = (g_accelRawData[GRAVITY_X_AXIS] * GRAVITY_UNITS + + GRAVITY_FILTER_UNITS * (GravityRawData[GRAVITY_X_AXIS] - g_accelRawData[GRAVITY_X_AXIS])) / GRAVITY_UNITS; + GravityRawData[GRAVITY_Y_AXIS] = (g_accelRawData[GRAVITY_Y_AXIS] * GRAVITY_UNITS + + GRAVITY_FILTER_UNITS * (GravityRawData[GRAVITY_Y_AXIS] - g_accelRawData[GRAVITY_Y_AXIS])) / GRAVITY_UNITS; + GravityRawData[GRAVITY_Z_AXIS] = (g_accelRawData[GRAVITY_Z_AXIS] * GRAVITY_UNITS + + GRAVITY_FILTER_UNITS * (GravityRawData[GRAVITY_Z_AXIS] - g_accelRawData[GRAVITY_Z_AXIS])) / GRAVITY_UNITS; + + if (OsalGetTime(&time) != HDF_SUCCESS) { + HDF_LOGE("%s: Get time failed", __func__); + return; + } + event.timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * SENSOR_CONVERT_UNIT; /* unit nanosecond */ + event.sensorId = SENSOR_TAG_GRAVITY; + event.option = 0; + event.mode = SENSOR_WORK_MODE_REALTIME; + event.dataLen = sizeof(GravityRawData); + event.data = (uint8_t *)&GravityRawData; + + if (ReportSensorEvent(&event) != HDF_SUCCESS) { + HDF_LOGE("%s: Report gravity data failed", __func__); + } +} + +static void GravityTimerEntry(uintptr_t arg) +{ + int32_t ret; + struct GravityDrvData *drvData = (struct GravityDrvData *)arg; + CHECK_NULL_PTR_RETURN(drvData); + + if (!HdfAddWork(&drvData->gravityWorkQueue, &drvData->gravityWork)) { + HDF_LOGE("%s: Gravity add work queue failed", __func__); + } + + ret = OsalTimerSetTimeout(&drvData->gravityTimer, drvData->interval); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Gravity modify time failed", __func__); + } +} + +static int32_t InitGravityData(struct GravityDrvData *drvData) +{ + if (HdfWorkQueueInit(&drvData->gravityWorkQueue, HDF_GRAVITY_WORK_QUEUE_NAME) != HDF_SUCCESS) { + HDF_LOGE("%s: Gravity init work queue failed", __func__); + return HDF_FAILURE; + } + + if (HdfWorkInit(&drvData->gravityWork, GravityDataWorkEntry, drvData) != HDF_SUCCESS) { + HDF_LOGE("%s: Gravity create thread failed", __func__); + return HDF_FAILURE; + } + + drvData->interval = GRAVITY_TIMER_MAX_TIME; + drvData->enable = false; + + return HDF_SUCCESS; +} + +static int32_t SetGravityEnable(void) +{ + int32_t ret; + struct GravityDrvData *drvData = GravityGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(drvData->gravityCfg, HDF_ERR_INVALID_PARAM); + + if (drvData->enable) { + HDF_LOGE("%s: Gravity sensor is enabled", __func__); + return HDF_SUCCESS; + } + + ret = OsalTimerCreate(&drvData->gravityTimer, GRAVITY_TIMER_MAX_TIME, GravityTimerEntry, (uintptr_t)drvData); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Gravity create timer failed[%d]", __func__, ret); + return ret; + } + + ret = OsalTimerStartLoop(&drvData->gravityTimer); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Gravity start timer failed[%d]", __func__, ret); + return ret; + } + drvData->enable = true; + + return HDF_SUCCESS; +} + +static int32_t SetGravityDisable(void) +{ + int32_t ret; + struct GravityDrvData *drvData = GravityGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(drvData->gravityCfg, HDF_ERR_INVALID_PARAM); + + if (!drvData->enable) { + HDF_LOGE("%s: Gravity sensor had disable", __func__); + return HDF_SUCCESS; + } + + ret = OsalTimerDelete(&drvData->gravityTimer); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Gravity delete timer failed", __func__); + return ret; + } + drvData->enable = false; + + return HDF_SUCCESS; +} + +static int32_t SetGravityBatch(int64_t samplingInterval, int64_t interval) +{ + (void)interval; + + int64_t ms; + struct GravityDrvData *drvData = NULL; + + drvData = GravityGetDrvData(); + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + ms = OsalDivS64(samplingInterval, (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT)); + + drvData->interval = (ms <= GRAVITY_TIMER_MIN_TIME) ? GRAVITY_TIMER_MIN_TIME : GRAVITY_TIMER_MAX_TIME; + + return HDF_SUCCESS; +} + +static int32_t SetGravityMode(int32_t mode) +{ + return (mode == SENSOR_WORK_MODE_REALTIME) ? HDF_SUCCESS : HDF_FAILURE; +} + +static int32_t SetGravityOption(uint32_t option) +{ + (void)option; + return HDF_SUCCESS; +} + +static int32_t DispatchGravity(struct HdfDeviceIoClient *client, + int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)client; + (void)cmd; + (void)data; + (void)reply; + + return HDF_SUCCESS; +} + +int32_t GravityBindDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + + struct GravityDrvData *drvData = (struct GravityDrvData *)OsalMemCalloc(sizeof(*drvData)); + if (drvData == NULL) { + HDF_LOGE("%s: Malloc gravity drv data fail!", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + drvData->ioService.Dispatch = DispatchGravity; + drvData->device = device; + device->service = &drvData->ioService; + g_gravityDrvData = drvData; + return HDF_SUCCESS; +} + +static int32_t InitGravityOps(struct SensorCfgData *config, struct SensorDeviceInfo *deviceInfo) +{ + CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); + + deviceInfo->ops.Enable = SetGravityEnable; + deviceInfo->ops.Disable = SetGravityDisable; + deviceInfo->ops.SetBatch = SetGravityBatch; + deviceInfo->ops.SetMode = SetGravityMode; + deviceInfo->ops.SetOption = SetGravityOption; + + if (memcpy_s(&deviceInfo->sensorInfo, sizeof(deviceInfo->sensorInfo), + &config->sensorInfo, sizeof(config->sensorInfo)) != EOK) { + HDF_LOGE("%s: Copy sensor info failed", __func__); + return HDF_FAILURE; + } + + if (SubscribeAccelDataCallbackFunc(GravitySubscribeAccelData) != HDF_SUCCESS) { + HDF_LOGE("%s: Gravity register accel failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t InitGravityAfterBase(struct SensorCfgData *config) +{ + struct SensorDeviceInfo deviceInfo; + CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); + + if (InitGravityOps(config, &deviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: Init gravity ops failed", __func__); + return HDF_FAILURE; + } + + if (AddSensorDevice(&deviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: Add gravity device failed", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static int32_t GravityCreateCfgData(const struct DeviceResourceNode *node) +{ + struct GravityDrvData *drvData = GravityGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(drvData->gravityCfg, HDF_ERR_INVALID_PARAM); + + if (GetSensorBaseConfigData(node, drvData->gravityCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Get sensor base config failed", __func__); + return HDF_FAILURE; + } + + if (InitGravityAfterBase(drvData->gravityCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Init gravity sensor device failed", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t GravityInitDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + struct GravityDrvData *drvData = (struct GravityDrvData *)device->service; + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + if (InitGravityData(drvData) != HDF_SUCCESS) { + HDF_LOGE("%s: Init gravity config failed", __func__); + return HDF_FAILURE; + } + + drvData->gravityCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->gravityCfg)); + if (drvData->gravityCfg == NULL) { + HDF_LOGE("%s: Malloc gravity config data failed", __func__); + return HDF_FAILURE; + } + + if (GravityCreateCfgData(device->property) != HDF_SUCCESS) { + HDF_LOGE("%s: create gravity device failed", __func__); + OsalMemFree(drvData->gravityCfg); + return HDF_FAILURE; + } + HDF_LOGI("%s: Init gravity driver success", __func__); + return HDF_SUCCESS; +} + +void GravityReleaseDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN(device); + + struct GravityDrvData *drvData = (struct GravityDrvData *)device->service; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->gravityCfg != NULL) { + (void)DeleteSensorDevice(&drvData->gravityCfg->sensorInfo); + OsalMemFree(drvData->gravityCfg); + drvData->gravityCfg = NULL; + } + + HdfWorkDestroy(&drvData->gravityWork); + HdfWorkQueueDestroy(&drvData->gravityWorkQueue); + OsalMemFree(drvData); +} + +struct HdfDriverEntry g_sensorGravityDevEntry = { + .moduleVersion = 1, + .moduleName = "HDF_SENSOR_GRAVITY", + .Bind = GravityBindDriver, + .Init = GravityInitDriver, + .Release = GravityReleaseDriver, +}; + +HDF_INIT(g_sensorGravityDevEntry); \ No newline at end of file diff --git a/model/sensor/driver/accel/sensor_gravity_driver.h b/model/sensor/driver/accel/sensor_gravity_driver.h new file mode 100755 index 0000000000000000000000000000000000000000..30521c1cda8d208388abe49699ea8f9025a8a4d7 --- /dev/null +++ b/model/sensor/driver/accel/sensor_gravity_driver.h @@ -0,0 +1,46 @@ +/* + * Copyright (c) 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 SENSOR_GRAVITY_DRIVER_H +#define SENSOR_GRAVITY_DRIVER_H + +#include "hdf_workqueue.h" +#include "osal_mutex.h" +#include "osal_timer.h" +#include "sensor_config_parser.h" +#include "sensor_platform_if.h" + +#define GRAVITY_TIMER_MIN_TIME 10 +#define GRAVITY_TIMER_MAX_TIME 20 +#define GRAVITY_UNITS 100 +#define GRAVITY_FILTER_UNITS 85 +enum GravityAxisNum { + GRAVITY_X_AXIS = 0, + GRAVITY_Y_AXIS = 1, + GRAVITY_Z_AXIS = 2, + GRAVITY_AXIS_NUM = 3, +}; + +struct GravityData { + int32_t x; + int32_t y; + int32_t z; +}; + +struct GravityDrvData { + struct IDeviceIoService ioService; + struct HdfDeviceObject *device; + HdfWorkQueue gravityWorkQueue; + HdfWork gravityWork; + OsalTimer gravityTimer; + struct SensorCfgData *gravityCfg; + int64_t interval; + bool enable; +}; + +#endif /* SENSOR_GRAVITY_DRIVER_H */ \ No newline at end of file diff --git a/model/sensor/driver/als/sensor_als_driver.c b/model/sensor/driver/als/sensor_als_driver.c new file mode 100755 index 0000000000000000000000000000000000000000..cd91f4aeba4fc6572070f327981c50dda363d287 --- /dev/null +++ b/model/sensor/driver/als/sensor_als_driver.c @@ -0,0 +1,523 @@ +/* + * Copyright (c) 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 "sensor_als_driver.h" +#include +#include "als_bh1745.h" +#include "osal_math.h" +#include "osal_mem.h" +#include "sensor_config_controller.h" +#include "sensor_device_manager.h" +#include "sensor_platform_if.h" + +#define HDF_LOG_TAG sensor_als_driver_c + +#define HDF_ALS_WORK_QUEUE_NAME "hdf_als_work_queue" + +static struct AlsDrvData *g_alsDrvData = NULL; + +static struct AlsDrvData *AlsGetDrvData(void) +{ + return g_alsDrvData; +} + +static struct SensorRegCfgGroupNode *g_regCfgGroup[SENSOR_GROUP_MAX] = { NULL }; +static struct SensorRegCfgGroupNode *g_extendAlsRegCfgGroup[EXTENDED_ALS_GROUP_MAX] = { NULL }; +static char *g_extendedAlsGroupName[EXTENDED_ALS_GROUP_MAX] = { + "time", + "gain", +}; + +int32_t GetTimeByRegValue(uint8_t regValue, struct TimeMap *table, int32_t itemNum) +{ + int32_t i; + + CHECK_NULL_PTR_RETURN_VALUE(table, HDF_FAILURE); + + for (i = 0; i < itemNum; i++) { + if (regValue == table[i].timeRegValue) { + return table[i].timeValue; + } + } + + return HDF_FAILURE; +} + +int32_t GetRegValueByTime(uint32_t timeValue, struct TimeMap *table, int32_t itemNum) +{ + int32_t i; + + CHECK_NULL_PTR_RETURN_VALUE(table, HDF_FAILURE); + + for (i = 0; i < itemNum; i++) { + if (timeValue == table[i].timeValue) { + return table[i].timeRegValue; + } + } + + return HDF_FAILURE; +} + +int32_t GetRegGroupIndexByTime(uint32_t timeValue, struct TimeMap *table, int32_t itemNum) +{ + int32_t i; + + CHECK_NULL_PTR_RETURN_VALUE(table, HDF_FAILURE); + + for (i = 0; i < itemNum; i++) { + if (timeValue == table[i].timeValue) { + return i; + } + } + + return HDF_FAILURE; +} + +int32_t GetGainByRegValue(uint8_t regValue, struct GainMap *table, int32_t itemNum) +{ + int32_t i; + + CHECK_NULL_PTR_RETURN_VALUE(table, HDF_FAILURE); + + for (i = 0; i < itemNum; i++) { + if (regValue == table[i].gainRegValue) { + return table[i].gainValue; + } + } + + return HDF_FAILURE; +} + +static int32_t GetExtendedAlsRegGroupNameIndex(const char *name) +{ + int32_t index; + + CHECK_NULL_PTR_RETURN_VALUE(name, EXTENDED_ALS_GROUP_MAX); + + for (index = 0; index < EXTENDED_ALS_GROUP_MAX; ++index) { + if ((g_extendedAlsGroupName[index] != NULL) && (strcmp(name, g_extendedAlsGroupName[index]) == 0)) { + break; + } + } + + return index; +} + +void ReleaseExtendedAlsRegConfig(struct SensorCfgData *config) +{ + int32_t index; + + CHECK_NULL_PTR_RETURN(config); + CHECK_NULL_PTR_RETURN(config->extendedRegCfgGroup); + + for (index = 0; index < EXTENDED_ALS_GROUP_MAX; ++index) { + if (config->extendedRegCfgGroup[index] != NULL) { + if (config->extendedRegCfgGroup[index]->regCfgItem != NULL) { + OsalMemFree(config->extendedRegCfgGroup[index]->regCfgItem); + config->extendedRegCfgGroup[index]->regCfgItem = NULL; + } + + OsalMemFree(config->extendedRegCfgGroup[index]); + config->extendedRegCfgGroup[index] = NULL; + } + } +} + +int32_t ParseExtendedAlsRegConfig(struct SensorCfgData *config) +{ + int32_t index; + struct DeviceResourceIface *parser = NULL; + const struct DeviceResourceNode *extendedRegCfgNode = NULL; + const struct DeviceResourceAttr *extendedRegAttr = NULL; + + CHECK_NULL_PTR_RETURN_VALUE(config->root, HDF_ERR_INVALID_PARAM); + parser = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + CHECK_NULL_PTR_RETURN_VALUE(parser, HDF_ERR_INVALID_PARAM); + + extendedRegCfgNode = parser->GetChildNode(config->root, "extendAlsRegConfig"); + CHECK_NULL_PTR_RETURN_VALUE(extendedRegCfgNode, HDF_ERR_INVALID_PARAM); + + DEV_RES_NODE_FOR_EACH_ATTR(extendedRegCfgNode, extendedRegAttr) { + if (extendedRegAttr == NULL || extendedRegAttr->name == NULL) { + HDF_LOGE("%s:sensor reg node attr is null", __func__); + break; + } + + index = GetExtendedAlsRegGroupNameIndex(extendedRegAttr->name); + if (index >= EXTENDED_ALS_GROUP_MAX) { + HDF_LOGE("%s: get sensor register group index failed", __func__); + goto ERROR; + } + + if (ParseSensorRegGroup(parser, extendedRegCfgNode, extendedRegAttr->name, + &config->extendedRegCfgGroup[index]) != HDF_SUCCESS) { + HDF_LOGE("%s: parse sensor register group failed", __func__); + goto ERROR; + } + } + + return HDF_SUCCESS; + +ERROR: + ReleaseExtendedAlsRegConfig(config); + HDF_LOGE("%s: parse sensor extend register config failed", __func__); + + return HDF_FAILURE; +} + +int32_t AlsRegisterChipOps(const struct AlsOpsCall *ops) +{ + struct AlsDrvData *drvData = AlsGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(ops, HDF_ERR_INVALID_PARAM); + + drvData->ops.Init = ops->Init; + drvData->ops.ReadData = ops->ReadData; + return HDF_SUCCESS; +} + +static void AlsDataWorkEntry(void *arg) +{ + struct AlsDrvData *drvData = NULL; + + drvData = (struct AlsDrvData *)arg; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->ops.ReadData == NULL) { + HDF_LOGI("%s: Als ReadData function NULl", __func__); + return; + } + if (drvData->ops.ReadData(drvData->alsCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Als read data failed", __func__); + } +} + +static void AlsTimerEntry(uintptr_t arg) +{ + int64_t interval; + int32_t ret; + struct AlsDrvData *drvData = (struct AlsDrvData *)arg; + CHECK_NULL_PTR_RETURN(drvData); + + if (!HdfAddWork(&drvData->alsWorkQueue, &drvData->alsWork)) { + HDF_LOGE("%s: Als add work queue failed", __func__); + } + + interval = OsalDivS64(drvData->interval, (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT)); + interval = (interval < SENSOR_TIMER_MIN_TIME) ? SENSOR_TIMER_MIN_TIME : interval; + ret = OsalTimerSetTimeout(&drvData->alsTimer, interval); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Als modify time failed", __func__); + } +} + +static int32_t InitAlsData(struct AlsDrvData *drvData) +{ + if (HdfWorkQueueInit(&drvData->alsWorkQueue, HDF_ALS_WORK_QUEUE_NAME) != HDF_SUCCESS) { + HDF_LOGE("%s: Als init work queue failed", __func__); + return HDF_FAILURE; + } + + if (HdfWorkInit(&drvData->alsWork, AlsDataWorkEntry, drvData) != HDF_SUCCESS) { + HDF_LOGE("%s: Als create thread failed", __func__); + return HDF_FAILURE; + } + + drvData->interval = SENSOR_TIMER_MIN_TIME; + drvData->enable = false; + drvData->detectFlag = false; + + return HDF_SUCCESS; +} + +static int32_t SetAlsEnable(void) +{ + int32_t ret; + struct AlsDrvData *drvData = AlsGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(drvData->alsCfg, HDF_ERR_INVALID_PARAM); + + if (drvData->enable) { + HDF_LOGE("%s: Als sensor is enabled", __func__); + return HDF_SUCCESS; + } + + ret = SetSensorRegCfgArray(&drvData->alsCfg->busCfg, drvData->alsCfg->regCfgGroup[SENSOR_ENABLE_GROUP]); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Als sensor enable config failed", __func__); + return ret; + } + + ret = OsalTimerCreate(&drvData->alsTimer, SENSOR_TIMER_MIN_TIME, AlsTimerEntry, (uintptr_t)drvData); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Als create timer failed[%d]", __func__, ret); + return ret; + } + + ret = OsalTimerStartLoop(&drvData->alsTimer); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Als start timer failed[%d]", __func__, ret); + return ret; + } + drvData->enable = true; + + return HDF_SUCCESS; +} + +static int32_t SetAlsDisable(void) +{ + int32_t ret; + struct AlsDrvData *drvData = AlsGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(drvData->alsCfg, HDF_ERR_INVALID_PARAM); + + if (!drvData->enable) { + HDF_LOGE("%s: Als sensor had disable", __func__); + return HDF_SUCCESS; + } + + ret = SetSensorRegCfgArray(&drvData->alsCfg->busCfg, drvData->alsCfg->regCfgGroup[SENSOR_DISABLE_GROUP]); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Als sensor disable config failed", __func__); + return ret; + } + + ret = OsalTimerDelete(&drvData->alsTimer); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Als delete timer failed", __func__); + return ret; + } + drvData->enable = false; + + return HDF_SUCCESS; +} + +static int32_t SetAlsBatch(int64_t samplingInterval, int64_t interval) +{ + (void)interval; + + struct AlsDrvData *drvData = NULL; + + drvData = AlsGetDrvData(); + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + drvData->interval = samplingInterval; + + return HDF_SUCCESS; +} + +static int32_t SetAlsMode(int32_t mode) +{ + return (mode == SENSOR_WORK_MODE_REALTIME) ? HDF_SUCCESS : HDF_FAILURE; +} + +static int32_t SetAlsOption(uint32_t option) +{ + (void)option; + return HDF_SUCCESS; +} + +static int32_t DispatchAls(struct HdfDeviceIoClient *client, + int32_t cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)client; + (void)cmd; + (void)data; + (void)reply; + + return HDF_SUCCESS; +} + +int32_t AlsBindDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + + struct AlsDrvData *drvData = (struct AlsDrvData *)OsalMemCalloc(sizeof(*drvData)); + if (drvData == NULL) { + HDF_LOGE("%s: Malloc als drv data fail!", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + drvData->ioService.Dispatch = DispatchAls; + drvData->device = device; + device->service = &drvData->ioService; + g_alsDrvData = drvData; + return HDF_SUCCESS; +} + +static int32_t InitAlsOps(struct SensorCfgData *config, struct SensorDeviceInfo *deviceInfo) +{ + CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); + + deviceInfo->ops.Enable = SetAlsEnable; + deviceInfo->ops.Disable = SetAlsDisable; + deviceInfo->ops.SetBatch = SetAlsBatch; + deviceInfo->ops.SetMode = SetAlsMode; + deviceInfo->ops.SetOption = SetAlsOption; + + if (memcpy_s(&deviceInfo->sensorInfo, sizeof(deviceInfo->sensorInfo), + &config->sensorInfo, sizeof(config->sensorInfo)) != EOK) { + HDF_LOGE("%s: Copy sensor info failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t InitAlsAfterDetected(struct SensorCfgData *config) +{ + struct SensorDeviceInfo deviceInfo; + CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); + + if (InitAlsOps(config, &deviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: Init als ops failed", __func__); + return HDF_FAILURE; + } + + if (AddSensorDevice(&deviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: Add als device failed", __func__); + return HDF_FAILURE; + } + + if (ParseSensorRegConfig(config) != HDF_SUCCESS) { + HDF_LOGE("%s: Parse sensor register failed", __func__); + goto SENSOR_REG_CONFIG_EXIT; + } + + if (ParseExtendedAlsRegConfig(config) != HDF_SUCCESS) { + HDF_LOGE("%s: Parse sensor extendedRegCfgGroup register failed", __func__); + goto EXTENDED_ALS_REG_CONFIG_EXIT; + } + + return HDF_SUCCESS; + +EXTENDED_ALS_REG_CONFIG_EXIT: + ReleaseSensorAllRegConfig(config); +SENSOR_REG_CONFIG_EXIT: + (void)DeleteSensorDevice(&config->sensorInfo); + + return HDF_FAILURE; +} + +struct SensorCfgData *AlsCreateCfgData(const struct DeviceResourceNode *node) +{ + struct AlsDrvData *drvData = AlsGetDrvData(); + + if (drvData == NULL || node == NULL) { + HDF_LOGE("%s: Als node pointer NULL", __func__); + return NULL; + } + + if (drvData->detectFlag) { + HDF_LOGE("%s: Als sensor have detected", __func__); + return NULL; + } + + if (drvData->alsCfg == NULL) { + HDF_LOGE("%s: Als alsCfg pointer NULL", __func__); + return NULL; + } + + if (GetSensorBaseConfigData(node, drvData->alsCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Get sensor base config failed", __func__); + goto BASE_CONFIG_EXIT; + } + + if (DetectSensorDevice(drvData->alsCfg) != HDF_SUCCESS) { + HDF_LOGI("%s: Als sensor detect device no exist", __func__); + drvData->detectFlag = false; + goto BASE_CONFIG_EXIT; + } + + drvData->detectFlag = true; + if (InitAlsAfterDetected(drvData->alsCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Als sensor detect device no exist", __func__); + goto INIT_EXIT; + } + + return drvData->alsCfg; + +INIT_EXIT: + (void)ReleaseSensorBusHandle(&drvData->alsCfg->busCfg); +BASE_CONFIG_EXIT: + drvData->alsCfg->root = NULL; + (void)memset_s(&drvData->alsCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo)); + (void)memset_s(&drvData->alsCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg)); + (void)memset_s(&drvData->alsCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr)); + return drvData->alsCfg; +} + +void AlsReleaseCfgData(struct SensorCfgData *alsCfg) +{ + CHECK_NULL_PTR_RETURN(alsCfg); + + (void)DeleteSensorDevice(&alsCfg->sensorInfo); + ReleaseSensorAllRegConfig(alsCfg); + ReleaseExtendedAlsRegConfig(alsCfg); + (void)ReleaseSensorBusHandle(&alsCfg->busCfg); + + alsCfg->root = NULL; + (void)memset_s(&alsCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo)); + (void)memset_s(&alsCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg)); + (void)memset_s(&alsCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr)); +} + +int32_t AlsInitDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + struct AlsDrvData *drvData = (struct AlsDrvData *)device->service; + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + if (InitAlsData(drvData) != HDF_SUCCESS) { + HDF_LOGE("%s: Init als config failed", __func__); + return HDF_FAILURE; + } + + drvData->alsCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->alsCfg)); + if (drvData->alsCfg == NULL) { + HDF_LOGE("%s: Malloc als config data failed", __func__); + return HDF_FAILURE; + } + + drvData->alsCfg->regCfgGroup = &g_regCfgGroup[0]; + drvData->alsCfg->extendedRegCfgGroup = &g_extendAlsRegCfgGroup[0]; + + return HDF_SUCCESS; +} + +void AlsReleaseDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN(device); + + struct AlsDrvData *drvData = (struct AlsDrvData *)device->service; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->detectFlag && drvData->alsCfg != NULL) { + AlsReleaseCfgData(drvData->alsCfg); + } + + OsalMemFree(drvData->alsCfg); + drvData->alsCfg = NULL; + + HdfWorkDestroy(&drvData->alsWork); + HdfWorkQueueDestroy(&drvData->alsWorkQueue); + OsalMemFree(drvData); +} + +struct HdfDriverEntry g_sensorAlsDevEntry = { + .moduleVersion = 1, + .moduleName = "HDF_SENSOR_ALS", + .Bind = AlsBindDriver, + .Init = AlsInitDriver, + .Release = AlsReleaseDriver, +}; + +HDF_INIT(g_sensorAlsDevEntry); diff --git a/model/sensor/driver/als/sensor_als_driver.h b/model/sensor/driver/als/sensor_als_driver.h new file mode 100755 index 0000000000000000000000000000000000000000..6f02f9f1536814078a2b1ecae2fdf96a40398c87 --- /dev/null +++ b/model/sensor/driver/als/sensor_als_driver.h @@ -0,0 +1,94 @@ +/* + * Copyright (c) 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 SENSOR_ALS_DRIVER_H +#define SENSOR_ALS_DRIVER_H + +#include "hdf_workqueue.h" +#include "osal_timer.h" +#include "sensor_config_parser.h" +#include "sensor_platform_if.h" + +#define ALS_DEFAULT_SAMPLING_200_MS 200000000 +#define ALS_CHIP_NAME_BH1745 "bh1745" + +enum ExtendedAlsRegGroupType { + EXTENDED_ALS_TIME_GROUP = 0, + EXTENDED_ALS_GAIN_GROUP, + EXTENDED_ALS_GROUP_MAX, +}; + +enum AlsLightNum { + ALS_R = 0, + ALS_G = 1, + ALS_B = 2, + ALS_C = 3, + ALS_LIGHT_NUM = 4, +}; + +enum AlsLightPart { + ALS_R_LSB = 0, + ALS_R_MSB = 1, + ALS_G_LSB = 2, + ALS_G_MSB = 3, + ALS_B_LSB = 4, + ALS_B_MSB = 5, + ALS_C_LSB = 6, + ALS_C_MSB = 7, + ALS_LIGHT_BUTT = 8, +}; + +struct AlsReportData { + int32_t als; + int32_t cct; + int32_t irData; +}; + +struct TimeMap { + uint8_t timeRegValue; + uint32_t timeValue; +}; + +struct GainMap { + uint8_t gainRegValue; + uint32_t gainValue; +}; + +struct AlsData { + int32_t red; + int32_t green; + int32_t blue; + int32_t clear; +}; + +struct AlsOpsCall { + int32_t (*Init)(struct SensorCfgData *data); + int32_t (*ReadData)(struct SensorCfgData *data); +}; + +struct AlsDrvData { + struct IDeviceIoService ioService; + struct HdfDeviceObject *device; + HdfWorkQueue alsWorkQueue; + HdfWork alsWork; + OsalTimer alsTimer; + bool detectFlag; + bool enable; + int64_t interval; + struct SensorCfgData *alsCfg; + struct AlsOpsCall ops; +}; + +int32_t AlsRegisterChipOps(const struct AlsOpsCall *ops); +struct SensorCfgData *AlsCreateCfgData(const struct DeviceResourceNode *node); +void AlsReleaseCfgData(struct SensorCfgData *sensorCfgData); +int32_t GetTimeByRegValue(uint8_t regValue, struct TimeMap *table, int32_t itemNum); +int32_t GetRegValueByTime(uint32_t timeValue, struct TimeMap *table, int32_t itemNum); +int32_t GetRegGroupIndexByTime(uint32_t timeValue, struct TimeMap *table, int32_t itemNum); +int32_t GetGainByRegValue(uint8_t regValue, struct GainMap *table, int32_t itemNum); +#endif /* SENSOR_ALS_DRIVER_H */ diff --git a/model/sensor/driver/barometer/sensor_barometer_driver.c b/model/sensor/driver/barometer/sensor_barometer_driver.c index 988ea0333181f33bd0d562ce3e9c26bacec41003..79f5d38f610c3c1cb2a52050e2d0286a02813034 100644 --- a/model/sensor/driver/barometer/sensor_barometer_driver.c +++ b/model/sensor/driver/barometer/sensor_barometer_driver.c @@ -1,370 +1,370 @@ -/* - * Copyright (c) 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 "sensor_barometer_driver.h" -#include -#include "hdf_base.h" -#include "hdf_device_desc.h" -#include "osal_math.h" -#include "osal_mem.h" -#include "sensor_config_controller.h" -#include "sensor_device_manager.h" -#include "sensor_platform_if.h" - -#define HDF_LOG_TAG sensor_barometer_driver_c - -#define HDF_BAROMETER_WORK_QUEUE_NAME "hdf_barometer_work_queue" - -static struct BarometerDrvData *g_barometerDrvData = NULL; - -static struct BarometerDrvData *BarometerGetDrvData(void) -{ - return g_barometerDrvData; -} - -static struct SensorRegCfgGroupNode *g_regCfgGroup[SENSOR_GROUP_MAX] = { NULL }; - -int32_t BarometerRegisterChipOps(const struct BarometerOpsCall *ops) -{ - struct BarometerDrvData *drvData = BarometerGetDrvData(); - - CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(ops, HDF_ERR_INVALID_PARAM); - - drvData->ops.Init = ops->Init; - drvData->ops.ReadData = ops->ReadData; - return HDF_SUCCESS; -} - -static void BarometerDataWorkEntry(void *arg) -{ - struct BarometerDrvData *drvData = NULL; - - drvData = (struct BarometerDrvData *)arg; - CHECK_NULL_PTR_RETURN(drvData); - - if (drvData->ops.ReadData == NULL) { - HDF_LOGI("%s: Barometer ReadData function NULl", __func__); - return; - } - if (drvData->ops.ReadData(drvData->barometerCfg) != HDF_SUCCESS) { - HDF_LOGE("%s: Barometer read data failed", __func__); - } -} - -static void BarometerTimerEntry(uintptr_t arg) -{ - int64_t interval; - int32_t ret; - struct BarometerDrvData *drvData = (struct BarometerDrvData *)arg; - CHECK_NULL_PTR_RETURN(drvData); - - if (!HdfAddWork(&drvData->barometerWorkQueue, &drvData->barometerWork)) { - HDF_LOGE("%s: barometer add work queue failed", __func__); - } - - interval = OsalDivS64(drvData->interval, (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT)); - interval = (interval < SENSOR_TIMER_MIN_TIME) ? SENSOR_TIMER_MIN_TIME : interval; - ret = OsalTimerSetTimeout(&drvData->barometerTimer, interval); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: barometer modify time failed", __func__); - } -} - -static int32_t InitBarometerData(struct BarometerDrvData *drvData) -{ - if (HdfWorkQueueInit(&drvData->barometerWorkQueue, HDF_BAROMETER_WORK_QUEUE_NAME) != HDF_SUCCESS) { - HDF_LOGE("%s: barometer init work queue failed", __func__); - return HDF_FAILURE; - } - - if (HdfWorkInit(&drvData->barometerWork, BarometerDataWorkEntry, drvData) != HDF_SUCCESS) { - HDF_LOGE("%s: barometer create thread failed", __func__); - return HDF_FAILURE; - } - - drvData->interval = SENSOR_TIMER_MIN_TIME; - drvData->enable = false; - drvData->detectFlag = false; - - return HDF_SUCCESS; -} - -static int32_t SetBarometerEnable(void) -{ - int32_t ret; - struct BarometerDrvData *drvData = BarometerGetDrvData(); - - CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(drvData->barometerCfg, HDF_ERR_INVALID_PARAM); - - if (drvData->enable) { - HDF_LOGE("%s: barometer sensor is enabled", __func__); - return HDF_SUCCESS; - } - - ret = SetSensorRegCfgArray(&drvData->barometerCfg->busCfg, drvData->barometerCfg->regCfgGroup[SENSOR_ENABLE_GROUP]); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: barometer sensor enable config failed", __func__); - return ret; - } - - ret = OsalTimerCreate(&drvData->barometerTimer, SENSOR_TIMER_MIN_TIME, BarometerTimerEntry, (uintptr_t)drvData); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: barometer create timer failed[%d]", __func__, ret); - return ret; - } - - ret = OsalTimerStartLoop(&drvData->barometerTimer); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: barometer start timer failed[%d]", __func__, ret); - return ret; - } - drvData->enable = true; - - return HDF_SUCCESS; -} - -static int32_t SetBarometerDisable(void) -{ - int32_t ret; - struct BarometerDrvData *drvData = BarometerGetDrvData(); - - CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(drvData->barometerCfg, HDF_ERR_INVALID_PARAM); - - if (!drvData->enable) { - HDF_LOGE("%s: barometer sensor had disable", __func__); - return HDF_SUCCESS; - } - - ret = SetSensorRegCfgArray(&drvData->barometerCfg->busCfg, - drvData->barometerCfg->regCfgGroup[SENSOR_DISABLE_GROUP]); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: barometer sensor disable config failed", __func__); - return ret; - } - - ret = OsalTimerDelete(&drvData->barometerTimer); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: barometer delete timer failed", __func__); - return ret; - } - drvData->enable = false; - return HDF_SUCCESS; -} - -static int32_t SetBarometerBatch(int64_t samplingInterval, int64_t interval) -{ - (void)interval; - - struct BarometerDrvData *drvData = NULL; - - drvData = BarometerGetDrvData(); - CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); - - drvData->interval = samplingInterval; - - return HDF_SUCCESS; -} - -static int32_t SetBarometerMode(int32_t mode) -{ - return (mode == SENSOR_WORK_MODE_REALTIME) ? HDF_SUCCESS : HDF_FAILURE; -} - -static int32_t SetBarometerOption(uint32_t option) -{ - (void)option; - return HDF_SUCCESS; -} - -static int32_t DispatchBarometer(struct HdfDeviceIoClient *client, - int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) -{ - (void)client; - (void)cmd; - (void)data; - (void)reply; - - return HDF_SUCCESS; -} - -int32_t BarometerBindDriver(struct HdfDeviceObject *device) -{ - CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); - - struct BarometerDrvData *drvData = (struct BarometerDrvData *)OsalMemCalloc(sizeof(*drvData)); - if (drvData == NULL) { - HDF_LOGE("%s: malloc barometer drv data fail!", __func__); - return HDF_ERR_MALLOC_FAIL; - } - - drvData->ioService.Dispatch = DispatchBarometer; - drvData->device = device; - device->service = &drvData->ioService; - g_barometerDrvData = drvData; - return HDF_SUCCESS; -} - -static int32_t InitBarometerOps(struct SensorCfgData *config, struct SensorDeviceInfo *deviceInfo) -{ - CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); - - deviceInfo->ops.Enable = SetBarometerEnable; - deviceInfo->ops.Disable = SetBarometerDisable; - deviceInfo->ops.SetBatch = SetBarometerBatch; - deviceInfo->ops.SetMode = SetBarometerMode; - deviceInfo->ops.SetOption = SetBarometerOption; - - if (memcpy_s(&deviceInfo->sensorInfo, sizeof(deviceInfo->sensorInfo), - &config->sensorInfo, sizeof(config->sensorInfo)) != EOK) { - HDF_LOGE("%s: copy sensor info failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -static int32_t InitBarometerAfterDetected(struct SensorCfgData *config) -{ - struct SensorDeviceInfo deviceInfo; - CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); - - if (InitBarometerOps(config, &deviceInfo) != HDF_SUCCESS) { - HDF_LOGE("%s: Init barometer ops failed", __func__); - return HDF_FAILURE; - } - - if (AddSensorDevice(&deviceInfo) != HDF_SUCCESS) { - HDF_LOGE("%s: Add barometer device failed", __func__); - return HDF_FAILURE; - } - - if (ParseSensorRegConfig(config) != HDF_SUCCESS) { - HDF_LOGE("%s: Parse sensor register failed", __func__); - (void)DeleteSensorDevice(&config->sensorInfo); - ReleaseSensorAllRegConfig(config); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -struct SensorCfgData *BarometerCreateCfgData(const struct DeviceResourceNode *node) -{ - struct BarometerDrvData *drvData = BarometerGetDrvData(); - - if (drvData == NULL || node == NULL) { - HDF_LOGE("%s: Barometer node pointer NULL", __func__); - return NULL; - } - - if (drvData->detectFlag) { - HDF_LOGE("%s: Barometer sensor have detected", __func__); - return NULL; - } - - if (drvData->barometerCfg == NULL) { - HDF_LOGE("%s: Barometer barometerCfg pointer NULL", __func__); - return NULL; - } - - if (GetSensorBaseConfigData(node, drvData->barometerCfg) != HDF_SUCCESS) { - HDF_LOGE("%s: Get sensor base config failed", __func__); - goto BASE_CONFIG_EXIT; - } - - if (DetectSensorDevice(drvData->barometerCfg) != HDF_SUCCESS) { - HDF_LOGI("%s: Barometer sensor detect device no exist", __func__); - drvData->detectFlag = false; - goto BASE_CONFIG_EXIT; - } - - drvData->detectFlag = true; - if (InitBarometerAfterDetected(drvData->barometerCfg) != HDF_SUCCESS) { - HDF_LOGE("%s: Barometer sensor detect device no exist", __func__); - goto INIT_EXIT; - } - return drvData->barometerCfg; - -INIT_EXIT: - (void)ReleaseSensorBusHandle(&drvData->barometerCfg->busCfg); -BASE_CONFIG_EXIT: - drvData->barometerCfg->root = NULL; - (void)memset_s(&drvData->barometerCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, - sizeof(struct SensorBasicInfo)); - (void)memset_s(&drvData->barometerCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg)); - (void)memset_s(&drvData->barometerCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr)); - return NULL; -} - -void BarometerReleaseCfgData(struct SensorCfgData *barometerCfg) -{ - CHECK_NULL_PTR_RETURN(barometerCfg); - - (void)DeleteSensorDevice(&barometerCfg->sensorInfo); - ReleaseSensorAllRegConfig(barometerCfg); - (void)ReleaseSensorBusHandle(&barometerCfg->busCfg); - - barometerCfg->root = NULL; - (void)memset_s(&barometerCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo)); - (void)memset_s(&barometerCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg)); - (void)memset_s(&barometerCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr)); -} - -int32_t BarometerInitDriver(struct HdfDeviceObject *device) -{ - CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); - struct BarometerDrvData *drvData = (struct BarometerDrvData *)device->service; - CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); - - if (InitBarometerData(drvData) != HDF_SUCCESS) { - HDF_LOGE("%s: Init barometer config failed", __func__); - return HDF_FAILURE; - } - - drvData->barometerCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->barometerCfg)); - if (drvData->barometerCfg == NULL) { - HDF_LOGE("%s: Malloc barometer config data failed", __func__); - return HDF_FAILURE; - } - - drvData->barometerCfg->regCfgGroup = &g_regCfgGroup[0]; - - HDF_LOGI("%s: Init barometer driver success", __func__); - return HDF_SUCCESS; -} - -void BarometerReleaseDriver(struct HdfDeviceObject *device) -{ - CHECK_NULL_PTR_RETURN(device); - - struct BarometerDrvData *drvData = (struct BarometerDrvData *)device->service; - CHECK_NULL_PTR_RETURN(drvData); - - if (drvData->detectFlag) { - BarometerReleaseCfgData(drvData->barometerCfg); - } - - OsalMemFree(drvData->barometerCfg); - drvData->barometerCfg = NULL; - - HdfWorkDestroy(&drvData->barometerWork); - HdfWorkQueueDestroy(&drvData->barometerWorkQueue); - OsalMemFree(drvData); -} - -struct HdfDriverEntry g_sensorBarometerDevEntry = { - .moduleVersion = 1, - .moduleName = "HDF_SENSOR_BAROMETER", - .Bind = BarometerBindDriver, - .Init = BarometerInitDriver, - .Release = BarometerReleaseDriver, -}; - +/* + * Copyright (c) 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 "sensor_barometer_driver.h" +#include +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "osal_math.h" +#include "osal_mem.h" +#include "sensor_config_controller.h" +#include "sensor_device_manager.h" +#include "sensor_platform_if.h" + +#define HDF_LOG_TAG sensor_barometer_driver_c + +#define HDF_BAROMETER_WORK_QUEUE_NAME "hdf_barometer_work_queue" + +static struct BarometerDrvData *g_barometerDrvData = NULL; + +static struct BarometerDrvData *BarometerGetDrvData(void) +{ + return g_barometerDrvData; +} + +static struct SensorRegCfgGroupNode *g_regCfgGroup[SENSOR_GROUP_MAX] = { NULL }; + +int32_t BarometerRegisterChipOps(const struct BarometerOpsCall *ops) +{ + struct BarometerDrvData *drvData = BarometerGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(ops, HDF_ERR_INVALID_PARAM); + + drvData->ops.Init = ops->Init; + drvData->ops.ReadData = ops->ReadData; + return HDF_SUCCESS; +} + +static void BarometerDataWorkEntry(void *arg) +{ + struct BarometerDrvData *drvData = NULL; + + drvData = (struct BarometerDrvData *)arg; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->ops.ReadData == NULL) { + HDF_LOGI("%s: Barometer ReadData function NULl", __func__); + return; + } + if (drvData->ops.ReadData(drvData->barometerCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Barometer read data failed", __func__); + } +} + +static void BarometerTimerEntry(uintptr_t arg) +{ + int64_t interval; + int32_t ret; + struct BarometerDrvData *drvData = (struct BarometerDrvData *)arg; + CHECK_NULL_PTR_RETURN(drvData); + + if (!HdfAddWork(&drvData->barometerWorkQueue, &drvData->barometerWork)) { + HDF_LOGE("%s: barometer add work queue failed", __func__); + } + + interval = OsalDivS64(drvData->interval, (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT)); + interval = (interval < SENSOR_TIMER_MIN_TIME) ? SENSOR_TIMER_MIN_TIME : interval; + ret = OsalTimerSetTimeout(&drvData->barometerTimer, interval); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: barometer modify time failed", __func__); + } +} + +static int32_t InitBarometerData(struct BarometerDrvData *drvData) +{ + if (HdfWorkQueueInit(&drvData->barometerWorkQueue, HDF_BAROMETER_WORK_QUEUE_NAME) != HDF_SUCCESS) { + HDF_LOGE("%s: barometer init work queue failed", __func__); + return HDF_FAILURE; + } + + if (HdfWorkInit(&drvData->barometerWork, BarometerDataWorkEntry, drvData) != HDF_SUCCESS) { + HDF_LOGE("%s: barometer create thread failed", __func__); + return HDF_FAILURE; + } + + drvData->interval = SENSOR_TIMER_MIN_TIME; + drvData->enable = false; + drvData->detectFlag = false; + + return HDF_SUCCESS; +} + +static int32_t SetBarometerEnable(void) +{ + int32_t ret; + struct BarometerDrvData *drvData = BarometerGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(drvData->barometerCfg, HDF_ERR_INVALID_PARAM); + + if (drvData->enable) { + HDF_LOGE("%s: barometer sensor is enabled", __func__); + return HDF_SUCCESS; + } + + ret = SetSensorRegCfgArray(&drvData->barometerCfg->busCfg, drvData->barometerCfg->regCfgGroup[SENSOR_ENABLE_GROUP]); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: barometer sensor enable config failed", __func__); + return ret; + } + + ret = OsalTimerCreate(&drvData->barometerTimer, SENSOR_TIMER_MIN_TIME, BarometerTimerEntry, (uintptr_t)drvData); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: barometer create timer failed[%d]", __func__, ret); + return ret; + } + + ret = OsalTimerStartLoop(&drvData->barometerTimer); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: barometer start timer failed[%d]", __func__, ret); + return ret; + } + drvData->enable = true; + + return HDF_SUCCESS; +} + +static int32_t SetBarometerDisable(void) +{ + int32_t ret; + struct BarometerDrvData *drvData = BarometerGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(drvData->barometerCfg, HDF_ERR_INVALID_PARAM); + + if (!drvData->enable) { + HDF_LOGE("%s: barometer sensor had disable", __func__); + return HDF_SUCCESS; + } + + ret = SetSensorRegCfgArray(&drvData->barometerCfg->busCfg, + drvData->barometerCfg->regCfgGroup[SENSOR_DISABLE_GROUP]); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: barometer sensor disable config failed", __func__); + return ret; + } + + ret = OsalTimerDelete(&drvData->barometerTimer); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: barometer delete timer failed", __func__); + return ret; + } + drvData->enable = false; + return HDF_SUCCESS; +} + +static int32_t SetBarometerBatch(int64_t samplingInterval, int64_t interval) +{ + (void)interval; + + struct BarometerDrvData *drvData = NULL; + + drvData = BarometerGetDrvData(); + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + drvData->interval = samplingInterval; + + return HDF_SUCCESS; +} + +static int32_t SetBarometerMode(int32_t mode) +{ + return (mode == SENSOR_WORK_MODE_REALTIME) ? HDF_SUCCESS : HDF_FAILURE; +} + +static int32_t SetBarometerOption(uint32_t option) +{ + (void)option; + return HDF_SUCCESS; +} + +static int32_t DispatchBarometer(struct HdfDeviceIoClient *client, + int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)client; + (void)cmd; + (void)data; + (void)reply; + + return HDF_SUCCESS; +} + +int32_t BarometerBindDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + + struct BarometerDrvData *drvData = (struct BarometerDrvData *)OsalMemCalloc(sizeof(*drvData)); + if (drvData == NULL) { + HDF_LOGE("%s: malloc barometer drv data fail!", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + drvData->ioService.Dispatch = DispatchBarometer; + drvData->device = device; + device->service = &drvData->ioService; + g_barometerDrvData = drvData; + return HDF_SUCCESS; +} + +static int32_t InitBarometerOps(struct SensorCfgData *config, struct SensorDeviceInfo *deviceInfo) +{ + CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); + + deviceInfo->ops.Enable = SetBarometerEnable; + deviceInfo->ops.Disable = SetBarometerDisable; + deviceInfo->ops.SetBatch = SetBarometerBatch; + deviceInfo->ops.SetMode = SetBarometerMode; + deviceInfo->ops.SetOption = SetBarometerOption; + + if (memcpy_s(&deviceInfo->sensorInfo, sizeof(deviceInfo->sensorInfo), + &config->sensorInfo, sizeof(config->sensorInfo)) != EOK) { + HDF_LOGE("%s: copy sensor info failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t InitBarometerAfterDetected(struct SensorCfgData *config) +{ + struct SensorDeviceInfo deviceInfo; + CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); + + if (InitBarometerOps(config, &deviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: Init barometer ops failed", __func__); + return HDF_FAILURE; + } + + if (AddSensorDevice(&deviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: Add barometer device failed", __func__); + return HDF_FAILURE; + } + + if (ParseSensorRegConfig(config) != HDF_SUCCESS) { + HDF_LOGE("%s: Parse sensor register failed", __func__); + (void)DeleteSensorDevice(&config->sensorInfo); + ReleaseSensorAllRegConfig(config); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +struct SensorCfgData *BarometerCreateCfgData(const struct DeviceResourceNode *node) +{ + struct BarometerDrvData *drvData = BarometerGetDrvData(); + + if (drvData == NULL || node == NULL) { + HDF_LOGE("%s: Barometer node pointer NULL", __func__); + return NULL; + } + + if (drvData->detectFlag) { + HDF_LOGE("%s: Barometer sensor have detected", __func__); + return NULL; + } + + if (drvData->barometerCfg == NULL) { + HDF_LOGE("%s: Barometer barometerCfg pointer NULL", __func__); + return NULL; + } + + if (GetSensorBaseConfigData(node, drvData->barometerCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Get sensor base config failed", __func__); + goto BASE_CONFIG_EXIT; + } + + if (DetectSensorDevice(drvData->barometerCfg) != HDF_SUCCESS) { + HDF_LOGI("%s: Barometer sensor detect device no exist", __func__); + drvData->detectFlag = false; + goto BASE_CONFIG_EXIT; + } + + drvData->detectFlag = true; + if (InitBarometerAfterDetected(drvData->barometerCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Barometer sensor detect device no exist", __func__); + goto INIT_EXIT; + } + return drvData->barometerCfg; + +INIT_EXIT: + (void)ReleaseSensorBusHandle(&drvData->barometerCfg->busCfg); +BASE_CONFIG_EXIT: + drvData->barometerCfg->root = NULL; + (void)memset_s(&drvData->barometerCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, + sizeof(struct SensorBasicInfo)); + (void)memset_s(&drvData->barometerCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg)); + (void)memset_s(&drvData->barometerCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr)); + return drvData->barometerCfg; +} + +void BarometerReleaseCfgData(struct SensorCfgData *barometerCfg) +{ + CHECK_NULL_PTR_RETURN(barometerCfg); + + (void)DeleteSensorDevice(&barometerCfg->sensorInfo); + ReleaseSensorAllRegConfig(barometerCfg); + (void)ReleaseSensorBusHandle(&barometerCfg->busCfg); + + barometerCfg->root = NULL; + (void)memset_s(&barometerCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo)); + (void)memset_s(&barometerCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg)); + (void)memset_s(&barometerCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr)); +} + +int32_t BarometerInitDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + struct BarometerDrvData *drvData = (struct BarometerDrvData *)device->service; + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + if (InitBarometerData(drvData) != HDF_SUCCESS) { + HDF_LOGE("%s: Init barometer config failed", __func__); + return HDF_FAILURE; + } + + drvData->barometerCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->barometerCfg)); + if (drvData->barometerCfg == NULL) { + HDF_LOGE("%s: Malloc barometer config data failed", __func__); + return HDF_FAILURE; + } + + drvData->barometerCfg->regCfgGroup = &g_regCfgGroup[0]; + + HDF_LOGI("%s: Init barometer driver success", __func__); + return HDF_SUCCESS; +} + +void BarometerReleaseDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN(device); + + struct BarometerDrvData *drvData = (struct BarometerDrvData *)device->service; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->detectFlag && drvData->barometerCfg != NULL) { + BarometerReleaseCfgData(drvData->barometerCfg); + } + + OsalMemFree(drvData->barometerCfg); + drvData->barometerCfg = NULL; + + HdfWorkDestroy(&drvData->barometerWork); + HdfWorkQueueDestroy(&drvData->barometerWorkQueue); + OsalMemFree(drvData); +} + +struct HdfDriverEntry g_sensorBarometerDevEntry = { + .moduleVersion = 1, + .moduleName = "HDF_SENSOR_BAROMETER", + .Bind = BarometerBindDriver, + .Init = BarometerInitDriver, + .Release = BarometerReleaseDriver, +}; + HDF_INIT(g_sensorBarometerDevEntry); \ No newline at end of file diff --git a/model/sensor/driver/barometer/sensor_barometer_driver.h b/model/sensor/driver/barometer/sensor_barometer_driver.h index 0888955f087f48496def8d655dbb27eea56fc331..03ba8234d33b63241cf1a033be30846807a715b3 100644 --- a/model/sensor/driver/barometer/sensor_barometer_driver.h +++ b/model/sensor/driver/barometer/sensor_barometer_driver.h @@ -1,120 +1,119 @@ -/* - * Copyright (c) 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 SENSOR_BAROMETER_DRIVER_H -#define SENSOR_BAROMETER_DRIVER_H - -#include "hdf_workqueue.h" -#include "osal_mutex.h" -#include "osal_timer.h" -#include "sensor_config_parser.h" -#include "sensor_platform_if.h" - -#define BAR_DEFAULT_SAMPLING_200_MS 200000000 -#define BAROMETER_CHIP_NAME_BMP180 "bmp180" - -enum BarometerEeprom { - BAROMETER_AC1_MSB = 0, - BAROMETER_AC1_LSB = 1, - BAROMETER_AC2_MSB = 2, - BAROMETER_AC2_LSB = 3, - BAROMETER_AC3_MSB = 4, - BAROMETER_AC3_LSB = 5, - BAROMETER_AC4_MSB = 6, - BAROMETER_AC4_LSB = 7, - BAROMETER_AC5_MSB = 8, - BAROMETER_AC5_LSB = 9, - BAROMETER_AC6_MSB = 10, - BAROMETER_AC6_LSB = 11, - BAROMETER_B1_MSB = 12, - BAROMETER_B1_LSB = 13, - BAROMETER_B2_MSB = 14, - BAROMETER_B2_LSB = 15, - BAROMETER_MB_MSB = 16, - BAROMETER_MB_LSB = 17, - BAROMETER_MC_MSB = 18, - BAROMETER_MC_LSB = 19, - BAROMETER_MD_MSB = 20, - BAROMETER_MD_LSB = 21, - BAROMETER_EEPROM_SUM, -}; - -struct BarometerEepromData { - int32_t ac1; - int32_t ac2; - int32_t ac3; - int32_t b1; - int32_t b2; - int32_t mb; - int32_t mc; - int32_t md; - uint32_t ac4; - uint32_t ac5; - uint32_t ac6; -}; - -struct Coefficient { - int32_t b3; - int32_t b5; - int32_t b6; - int32_t x1; - int32_t x2; - int32_t x3; - int32_t p; - uint32_t b4; - uint32_t b7; -}; - -enum Temperature { - BAROMETER_TEM_MSB = 0, - BAROMETER_TEM_LSB = 1, - BAROMETER_TEM_SUM, -}; - -enum Barometer { - BAROMETER_BAR_MSB = 0, - BAROMETER_BAR_LSB = 1, - BAROMETER_BAR_XLSB = 2, - BAROMETER_BAR_SUM, -}; - -struct BarometerRawData { - int32_t unpensatePre; - int32_t unpensateTemp; -}; - -enum BarometerData { - BAROMETER_BAROMETER = 0, - BAROMETER_TEMPERATURE = 1, - BAROMETER_ALTITUDE = 2, - BAROMETER_SUM, -}; - -struct BarometerOpsCall { - int32_t (*Init)(struct SensorCfgData *data); - int32_t (*ReadData)(struct SensorCfgData *data); -}; - -struct BarometerDrvData { - struct IDeviceIoService ioService; - struct HdfDeviceObject *device; - HdfWorkQueue barometerWorkQueue; - HdfWork barometerWork; - OsalTimer barometerTimer; - bool detectFlag; - bool enable; - int64_t interval; - struct SensorCfgData *barometerCfg; - struct BarometerOpsCall ops; -}; - -int32_t BarometerRegisterChipOps(const struct BarometerOpsCall *ops); -struct SensorCfgData *BarometerCreateCfgData(const struct DeviceResourceNode *node); -void BarometerReleaseCfgData(struct SensorCfgData *sensorCfgData); - -#endif /* SENSOR_BAROMETER_DRIVER_H */ \ No newline at end of file +/* + * Copyright (c) 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 SENSOR_BAROMETER_DRIVER_H +#define SENSOR_BAROMETER_DRIVER_H + +#include "hdf_workqueue.h" +#include "osal_timer.h" +#include "sensor_config_parser.h" +#include "sensor_platform_if.h" + +#define BAR_DEFAULT_SAMPLING_200_MS 200000000 +#define BAROMETER_CHIP_NAME_BMP180 "bmp180" + +enum BarometerEeprom { + BAROMETER_AC1_MSB = 0, + BAROMETER_AC1_LSB = 1, + BAROMETER_AC2_MSB = 2, + BAROMETER_AC2_LSB = 3, + BAROMETER_AC3_MSB = 4, + BAROMETER_AC3_LSB = 5, + BAROMETER_AC4_MSB = 6, + BAROMETER_AC4_LSB = 7, + BAROMETER_AC5_MSB = 8, + BAROMETER_AC5_LSB = 9, + BAROMETER_AC6_MSB = 10, + BAROMETER_AC6_LSB = 11, + BAROMETER_B1_MSB = 12, + BAROMETER_B1_LSB = 13, + BAROMETER_B2_MSB = 14, + BAROMETER_B2_LSB = 15, + BAROMETER_MB_MSB = 16, + BAROMETER_MB_LSB = 17, + BAROMETER_MC_MSB = 18, + BAROMETER_MC_LSB = 19, + BAROMETER_MD_MSB = 20, + BAROMETER_MD_LSB = 21, + BAROMETER_EEPROM_SUM, +}; + +struct BarometerEepromData { + int32_t ac1; + int32_t ac2; + int32_t ac3; + int32_t b1; + int32_t b2; + int32_t mb; + int32_t mc; + int32_t md; + uint32_t ac4; + uint32_t ac5; + uint32_t ac6; +}; + +struct Coefficient { + int32_t b3; + int32_t b5; + int32_t b6; + int32_t x1; + int32_t x2; + int32_t x3; + int32_t p; + uint32_t b4; + uint32_t b7; +}; + +enum Temperature { + BAROMETER_TEM_MSB = 0, + BAROMETER_TEM_LSB = 1, + BAROMETER_TEM_SUM, +}; + +enum Barometer { + BAROMETER_BAR_MSB = 0, + BAROMETER_BAR_LSB = 1, + BAROMETER_BAR_XLSB = 2, + BAROMETER_BAR_SUM, +}; + +struct BarometerRawData { + int32_t unpensatePre; + int32_t unpensateTemp; +}; + +enum BarometerData { + BAROMETER_BAROMETER = 0, + BAROMETER_TEMPERATURE = 1, + BAROMETER_ALTITUDE = 2, + BAROMETER_SUM, +}; + +struct BarometerOpsCall { + int32_t (*Init)(struct SensorCfgData *data); + int32_t (*ReadData)(struct SensorCfgData *data); +}; + +struct BarometerDrvData { + struct IDeviceIoService ioService; + struct HdfDeviceObject *device; + HdfWorkQueue barometerWorkQueue; + HdfWork barometerWork; + OsalTimer barometerTimer; + bool detectFlag; + bool enable; + int64_t interval; + struct SensorCfgData *barometerCfg; + struct BarometerOpsCall ops; +}; + +int32_t BarometerRegisterChipOps(const struct BarometerOpsCall *ops); +struct SensorCfgData *BarometerCreateCfgData(const struct DeviceResourceNode *node); +void BarometerReleaseCfgData(struct SensorCfgData *sensorCfgData); + +#endif /* SENSOR_BAROMETER_DRIVER_H */ diff --git a/model/sensor/driver/chipset/accel/accel_bmi160.c b/model/sensor/driver/chipset/accel/accel_bmi160.c old mode 100644 new mode 100755 index b39d7bc4c13c3a981e52d25a6fc3fd90abd6972f..33f791e3cfb44c3f965aa129d17dd02cc5c92f27 --- a/model/sensor/driver/chipset/accel/accel_bmi160.c +++ b/model/sensor/driver/chipset/accel/accel_bmi160.c @@ -79,24 +79,24 @@ static int32_t ReadBmi160RawData(struct SensorCfgData *data, struct AccelData *r return HDF_SUCCESS; } -int32_t ReadBmi160Data(struct SensorCfgData *data) +int32_t ReadBmi160Data(struct SensorCfgData *cfg, struct SensorReportEvent *event) { int32_t ret; struct AccelData rawData = { 0, 0, 0 }; - int32_t tmp[ACCEL_AXIS_NUM]; - struct SensorReportEvent event; + static int32_t tmp[ACCEL_AXIS_NUM]; - (void)memset_s(&event, sizeof(event), 0, sizeof(event)); + CHECK_NULL_PTR_RETURN_VALUE(cfg, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(event, HDF_ERR_INVALID_PARAM); - ret = ReadBmi160RawData(data, &rawData, &event.timestamp); + ret = ReadBmi160RawData(cfg, &rawData, &event->timestamp); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: BMI160 read raw data failed", __func__); return HDF_FAILURE; } - event.sensorId = SENSOR_TAG_ACCELEROMETER; - event.option = 0; - event.mode = SENSOR_WORK_MODE_REALTIME; + event->sensorId = SENSOR_TAG_ACCELEROMETER; + event->option = 0; + event->mode = SENSOR_WORK_MODE_REALTIME; rawData.x = rawData.x * BMI160_ACC_SENSITIVITY_2G; rawData.y = rawData.y * BMI160_ACC_SENSITIVITY_2G; @@ -106,12 +106,15 @@ int32_t ReadBmi160Data(struct SensorCfgData *data) tmp[ACCEL_Y_AXIS] = (rawData.y * SENSOR_1K_UNIT) / SENSOR_CONVERT_UNIT; tmp[ACCEL_Z_AXIS] = (rawData.z * SENSOR_1K_UNIT) / SENSOR_CONVERT_UNIT; - event.dataLen = sizeof(tmp); - event.data = (uint8_t *)&tmp; - ret = ReportSensorEvent(&event); + ret = SensorRawDataToRemapData(cfg->direction, tmp, sizeof(tmp) / sizeof(tmp[0])); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: BMI160 report data failed", __func__); + HDF_LOGE("%s: BMI160 convert raw data failed", __func__); + return HDF_FAILURE; } + + event->dataLen = sizeof(tmp); + event->data = (uint8_t *)&tmp; + return ret; } @@ -187,7 +190,8 @@ int32_t Bmi160InitDriver(struct HdfDeviceObject *device) } drvData->sensorCfg = AccelCreateCfgData(device->property); - if (drvData->sensorCfg == NULL) { + if (drvData->sensorCfg == NULL || drvData->sensorCfg->root == NULL) { + HDF_LOGD("%s: Creating accelcfg failed because detection failed", __func__); return HDF_ERR_NOT_SUPPORT; } @@ -215,8 +219,10 @@ void Bmi160ReleaseDriver(struct HdfDeviceObject *device) struct Bmi160DrvData *drvData = (struct Bmi160DrvData *)device->service; CHECK_NULL_PTR_RETURN(drvData); - AccelReleaseCfgData(drvData->sensorCfg); - drvData->sensorCfg = NULL; + if (drvData->sensorCfg != NULL) { + AccelReleaseCfgData(drvData->sensorCfg); + drvData->sensorCfg = NULL; + } OsalMemFree(drvData); } diff --git a/model/sensor/driver/chipset/accel/accel_bmi160.h b/model/sensor/driver/chipset/accel/accel_bmi160.h old mode 100644 new mode 100755 index 1f1fb4de934c6609a58bc33abe768609bf6eef27..49ad6b05d15abc0ff6cc0a94764d2eac4e209ccf --- a/model/sensor/driver/chipset/accel/accel_bmi160.h +++ b/model/sensor/driver/chipset/accel/accel_bmi160.h @@ -59,8 +59,7 @@ #define BMI160_ACCEL_DATA_READY_MASK 0x80 int32_t DetectAccelBim160Chip(struct SensorCfgData *data); -int32_t ReadBmi160Data(struct SensorCfgData *data); - +int32_t ReadBmi160Data(struct SensorCfgData *cfg, struct SensorReportEvent *event); struct Bmi160DrvData { struct IDeviceIoService ioService; struct HdfDeviceObject *device; diff --git a/model/sensor/driver/chipset/als/als_bh1745.c b/model/sensor/driver/chipset/als/als_bh1745.c new file mode 100755 index 0000000000000000000000000000000000000000..4555a71b95918d9cfc00423c545b7d46a09a8410 --- /dev/null +++ b/model/sensor/driver/chipset/als/als_bh1745.c @@ -0,0 +1,376 @@ +/* + * Copyright (c) 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 "als_bh1745.h" +#include +#include "osal_mem.h" +#include "osal_time.h" +#include "sensor_als_driver.h" +#include "sensor_config_controller.h" +#include "sensor_device_manager.h" + +/* IO config for int-pin and I2C-pin */ +#define SENSOR_I2C6_DATA_REG_ADDR 0x114f004c +#define SENSOR_I2C6_CLK_REG_ADDR 0x114f0048 +#define SENSOR_I2C_REG_CFG 0x403 + +static struct Bh1745DrvData *g_bh1745DrvData = NULL; +static uint32_t g_timeMap_flag = 1; + +static struct TimeMap g_timeMap[EXTENDED_ALS_TIME_GROUP_INDEX_MAX] = { + { EXTENDED_ALS_TIME_GROUP_ATTR_VALUE_0, BH1745_TIME_160MSEC }, + { EXTENDED_ALS_TIME_GROUP_ATTR_VALUE_1, BH1745_TIME_320MSEC }, + { EXTENDED_ALS_TIME_GROUP_ATTR_VALUE_2, BH1745_TIME_640MSEC }, + { EXTENDED_ALS_TIME_GROUP_ATTR_VALUE_3, BH1745_TIME_1280MSEC }, + { EXTENDED_ALS_TIME_GROUP_ATTR_VALUE_4, BH1745_TIME_2560MSEC }, + { EXTENDED_ALS_TIME_GROUP_ATTR_VALUE_5, BH1745_TIME_5120MSEC } +}; + +static struct GainMap g_gainMap[EXTENDED_ALS_GAIN_GROUP_INDEX_MAX] = { + { EXTENDED_ALS_GAIN_GROUP_ATTR_VALUE_0, BH1745_GAIN_1X }, + { EXTENDED_ALS_GAIN_GROUP_ATTR_VALUE_1, BH1745_GAIN_2X }, + { EXTENDED_ALS_GAIN_GROUP_ATTR_VALUE_2, BH1745_GAIN_16X } +}; + +static uint32_t g_red[BH1745_COEFFICIENT_RED] = { + BH1745_COEFFICIENT_RED_LEVEL_0, + BH1745_COEFFICIENT_RED_LEVEL_1 +}; + +static uint32_t g_green[BH1745_COEFFICIENT_GREEN] = { + BH1745_COEFFICIENT_GREEN_LEVEL_0, + BH1745_COEFFICIENT_GREEN_LEVEL_1 +}; + +struct Bh1745DrvData *Bh1745GetDrvData(void) +{ + return g_bh1745DrvData; +} + +static int32_t DynamicRangCovert(struct SensorCfgData *CfgData, uint32_t *rgbcData) +{ + uint8_t regValue; + uint32_t temp; + uint8_t timeItemNum; + struct SensorRegCfgGroupNode *timeGroupNode = NULL; + int32_t index = EXTENDED_ALS_TIME_GROUP_INDEX_0; + + timeGroupNode = CfgData->extendedRegCfgGroup[EXTENDED_ALS_TIME_GROUP]; + timeItemNum = timeGroupNode->itemNum; + if (timeItemNum > EXTENDED_ALS_TIME_GROUP_INDEX_MAX) { + HDF_LOGE("%s: TimeItemNum out of range ", __func__); + return HDF_FAILURE; + } + + ReadSensorRegCfgArray(&CfgData->busCfg, timeGroupNode, index, ®Value, sizeof(uint8_t)); + regValue &= timeGroupNode->regCfgItem->mask; + + temp = GetTimeByRegValue(regValue, g_timeMap, timeItemNum); + index = GetRegGroupIndexByTime(temp, g_timeMap, timeItemNum); + if (index < 0) { + HDF_LOGE("%s: Index out of range ", __func__); + return HDF_FAILURE; + } + + if (((rgbcData[ALS_R] * BH1745_MULTIPLE_100 > BH1745_TIME_MAX) || + (rgbcData[ALS_G] * BH1745_MULTIPLE_100 > BH1745_TIME_MAX)) && (temp >= BH1745_TIME_320MSEC)) { + g_timeMap_flag = 1; + index = GetRegGroupIndexByTime(temp, g_timeMap, timeItemNum); + index--; + + WriteSensorRegCfgArray(&CfgData->busCfg, timeGroupNode, index, sizeof(uint8_t)); + } else if ((g_timeMap_flag == 1) && ((rgbcData[ALS_R] * BH1745_MULTIPLE_100 < BH1745_TIME_MIN) || + (rgbcData[ALS_G] * BH1745_MULTIPLE_100 < BH1745_TIME_MIN))) { + g_timeMap_flag = 0; + index = GetRegGroupIndexByTime(temp, g_timeMap, timeItemNum); + index++; + if (index >= timeItemNum) { + HDF_LOGE("%s: Index out of range ", __func__); + return HDF_FAILURE; + } + + WriteSensorRegCfgArray(&CfgData->busCfg, timeGroupNode, index, sizeof(uint8_t)); + } + return HDF_SUCCESS; +} + +static uint32_t CalLux(struct SensorCfgData *CfgData, uint32_t *rgbcData) +{ + uint32_t time; + uint32_t gain; + uint8_t regValue; + uint32_t index = 1; + uint32_t luxTemp; + uint8_t itemNum; + struct SensorRegCfgGroupNode *GroupNode = NULL; + int32_t timeIndex = EXTENDED_ALS_TIME_GROUP_INDEX_0; + int32_t gainIndex = EXTENDED_ALS_GAIN_GROUP_INDEX_0; + + if (rgbcData[ALS_G] < 1) { + return 0; + } + + if (BH1745_MULTIPLE_100 * rgbcData[ALS_C] / rgbcData[ALS_G] < BH1745_COEFFICIENT_JUDGE) { + index = 0; + } + + luxTemp = g_red[index] * rgbcData[ALS_R] + g_green[index] * rgbcData[ALS_G]; + + GroupNode = CfgData->extendedRegCfgGroup[EXTENDED_ALS_TIME_GROUP]; + itemNum = GroupNode->itemNum; + if (itemNum > EXTENDED_ALS_TIME_GROUP_INDEX_MAX) { + HDF_LOGE("%s: ItemNum out of range ", __func__); + return HDF_FAILURE; + } + + ReadSensorRegCfgArray(&CfgData->busCfg, GroupNode, timeIndex, ®Value, sizeof(uint8_t)); + regValue &= GroupNode->regCfgItem->mask; + time = GetTimeByRegValue(regValue, g_timeMap, itemNum); + + regValue = 0; + GroupNode = CfgData->extendedRegCfgGroup[EXTENDED_ALS_GAIN_GROUP]; + itemNum = GroupNode->itemNum; + if (itemNum > EXTENDED_ALS_GAIN_GROUP_INDEX_MAX) { + HDF_LOGE("%s: ItemNum out of range ", __func__); + return HDF_FAILURE; + } + + ReadSensorRegCfgArray(&CfgData->busCfg, GroupNode, gainIndex, ®Value, sizeof(uint8_t)); + regValue &= GroupNode->regCfgItem->mask; + gain = GetGainByRegValue(regValue, g_gainMap, itemNum); + + return (((luxTemp * BH1745_TIME_160MSEC * BH1745_GAIN_16X) / gain) / time); +} + +static int32_t RawDataConvert(struct SensorCfgData *CfgData, struct AlsReportData *reportData, uint32_t* rgbcData) +{ + int ret; + + reportData->als = (uint32_t)CalLux(CfgData, rgbcData); + reportData->als = (reportData->als > 0) ? reportData->als : 0; + + ret = DynamicRangCovert(CfgData, rgbcData); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "DynamicRangCovert"); + + return HDF_SUCCESS; +} + +static int32_t ReadBh1745RawData(struct SensorCfgData *data, struct AlsData *rawData, int64_t *timestamp) +{ + uint8_t status = 0; + uint8_t reg[ALS_LIGHT_BUTT]; + OsalTimespec time; + + (void)memset_s(&time, sizeof(time), 0, sizeof(time)); + (void)memset_s(reg, sizeof(reg), 0, sizeof(reg)); + + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + + if (OsalGetTime(&time) != HDF_SUCCESS) { + HDF_LOGE("%s: Get time failed", __func__); + return HDF_FAILURE; + } + *timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * SENSOR_CONVERT_UNIT; /* unit nanosecond */ + + int32_t ret = ReadSensor(&data->busCfg, BH1745_MODECONTROL3_ADDR, &status, sizeof(uint8_t)); + if (!(status & BH1745_ALS_DATA_READY_MASK) || (ret != HDF_SUCCESS)) { + HDF_LOGE("%s: data status [%u] ret [%d]", __func__, status, ret); + return HDF_FAILURE; + } + + ret = ReadSensor(&data->busCfg, BH1745_ALS_R_LSB_ADDR, ®[ALS_R_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BH1745_ALS_R_MSB_ADDR, ®[ALS_R_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BH1745_ALS_G_LSB_ADDR, ®[ALS_G_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BH1745_ALS_G_MSB_ADDR, ®[ALS_G_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BH1745_ALS_B_LSB_ADDR, ®[ALS_B_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BH1745_ALS_B_MSB_ADDR, ®[ALS_B_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BH1745_ALS_C_LSB_ADDR, ®[ALS_C_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BH1745_ALS_C_MSB_ADDR, ®[ALS_C_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + rawData->red = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[ALS_R_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[ALS_R_LSB]); + rawData->green = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[ALS_G_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[ALS_G_LSB]); + rawData->blue = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[ALS_B_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[ALS_B_LSB]); + rawData->clear = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[ALS_C_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[ALS_C_LSB]); + + return HDF_SUCCESS; +} + +int32_t ReadBh1745Data(struct SensorCfgData *data) +{ + int32_t ret; + struct AlsData rawData = { 0, 0, 0, 0 }; + uint32_t tmp[ALS_LIGHT_NUM]; + struct SensorReportEvent event; + struct AlsReportData reportData; + + (void)memset_s(&event, sizeof(event), 0, sizeof(event)); + ret = ReadBh1745RawData(data, &rawData, &event.timestamp); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: BH1745 read raw data failed", __func__); + return HDF_FAILURE; + } + + event.sensorId = SENSOR_TAG_AMBIENT_LIGHT; + event.option = 0; + event.mode = SENSOR_WORK_MODE_REALTIME; + + tmp[ALS_R] = rawData.red; + tmp[ALS_G] = rawData.green; + tmp[ALS_B] = rawData.blue; + tmp[ALS_C] = rawData.clear; + + ret = RawDataConvert(data, &reportData, tmp); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "RawDataConvert"); + + event.dataLen = sizeof(reportData.als); + event.data = (uint8_t *)&reportData.als; + + ret = ReportSensorEvent(&event); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: BH1745 report data failed", __func__); + } + return ret; +} + +static int32_t InitBh1745(struct SensorCfgData *data) +{ + int32_t ret; + + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + ret = SetSensorRegCfgArray(&data->busCfg, data->regCfgGroup[SENSOR_INIT_GROUP]); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: BH1745 sensor init config failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t InitAlsPreConfig(void) +{ + if (SetSensorPinMux(SENSOR_I2C6_DATA_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_I2C_REG_CFG) != HDF_SUCCESS) { + HDF_LOGE("%s: Data write mux pin failed", __func__); + return HDF_FAILURE; + } + if (SetSensorPinMux(SENSOR_I2C6_CLK_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_I2C_REG_CFG) != HDF_SUCCESS) { + HDF_LOGE("%s: Clk write mux pin failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t DispatchBH1745(struct HdfDeviceIoClient *client, + int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)client; + (void)cmd; + (void)data; + (void)reply; + + return HDF_SUCCESS; +} + +int32_t Bh1745BindDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + + struct Bh1745DrvData *drvData = (struct Bh1745DrvData *)OsalMemCalloc(sizeof(*drvData)); + if (drvData == NULL) { + HDF_LOGE("%s: Malloc Bh1745 drv data fail", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + drvData->ioService.Dispatch = DispatchBH1745; + drvData->device = device; + device->service = &drvData->ioService; + g_bh1745DrvData = drvData; + + return HDF_SUCCESS; +} + +int32_t Bh1745InitDriver(struct HdfDeviceObject *device) +{ + int32_t ret; + struct AlsOpsCall ops; + + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + struct Bh1745DrvData *drvData = (struct Bh1745DrvData *)device->service; + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + ret = InitAlsPreConfig(); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Init BH1745 bus mux config", __func__); + return HDF_FAILURE; + } + + drvData->sensorCfg = AlsCreateCfgData(device->property); + if (drvData->sensorCfg == NULL || drvData->sensorCfg->root == NULL) { + HDF_LOGD("%s: Creating alscfg failed because detection failed", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + ops.Init = NULL; + ops.ReadData = ReadBh1745Data; + ret = AlsRegisterChipOps(&ops); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Register BH1745 als failed", __func__); + return HDF_FAILURE; + } + + ret = InitBh1745(drvData->sensorCfg); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Init BH1745 als failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +void Bh1745ReleaseDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN(device); + + struct Bh1745DrvData *drvData = (struct Bh1745DrvData *)device->service; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->sensorCfg != NULL) { + AlsReleaseCfgData(drvData->sensorCfg); + drvData->sensorCfg = NULL; + } + OsalMemFree(drvData); +} + +struct HdfDriverEntry g_alsBh1745DevEntry = { + .moduleVersion = 1, + .moduleName = "HDF_SENSOR_ALS_BH1745", + .Bind = Bh1745BindDriver, + .Init = Bh1745InitDriver, + .Release = Bh1745ReleaseDriver, +}; + +HDF_INIT(g_alsBh1745DevEntry); diff --git a/model/sensor/driver/chipset/als/als_bh1745.h b/model/sensor/driver/chipset/als/als_bh1745.h new file mode 100755 index 0000000000000000000000000000000000000000..34105dee4b1a5ff62e9907ead1c853c1af11276c --- /dev/null +++ b/model/sensor/driver/chipset/als/als_bh1745.h @@ -0,0 +1,95 @@ +/* + * Copyright (c) 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 ALS_BH1745_H +#define ALS_BH1745_H + +#include "sensor_als_driver.h" +#include "sensor_config_parser.h" + +/* ALS DATA REGISTERS ADDR */ +#define BH1745_ALS_R_LSB_ADDR 0X50 +#define BH1745_ALS_R_MSB_ADDR 0X51 +#define BH1745_ALS_G_LSB_ADDR 0X52 +#define BH1745_ALS_G_MSB_ADDR 0X53 +#define BH1745_ALS_B_LSB_ADDR 0X54 +#define BH1745_ALS_B_MSB_ADDR 0X55 +#define BH1745_ALS_C_LSB_ADDR 0X56 +#define BH1745_ALS_C_MSB_ADDR 0X57 +#define BH1745_MODECONTROL3_ADDR 0X44 + +/* ALS DATA READY */ +#define BH1745_ALS_DATA_READY_MASK 0X02 + +/* ALS MULTIPLE */ +#define BH1745_MULTIPLE_100 100 + +/* ALS COEFFICIENT */ +#define BH1745_COEFFICIENT_RED 2 +#define BH1745_COEFFICIENT_GREEN 2 +#define BH1745_COEFFICIENT_RED_LEVEL_0 77300 // 7.73 * 10000 +#define BH1745_COEFFICIENT_RED_LEVEL_1 92715 // 9.2715 * 10000 +#define BH1745_COEFFICIENT_GREEN_LEVEL_0 131920 // 1.3192 * 10000 +#define BH1745_COEFFICIENT_GREEN_LEVEL_1 214770 // 2.1477 * 10000 +#define BH1745_COEFFICIENT_JUDGE 78 // 0.78*100 + +/* ALS TIME */ +#define BH1745_TIME_160MSEC 160 +#define BH1745_TIME_320MSEC 320 +#define BH1745_TIME_640MSEC 640 +#define BH1745_TIME_1280MSEC 1280 +#define BH1745_TIME_2560MSEC 2560 +#define BH1745_TIME_5120MSEC 5120 +#define BH1745_TIME_MAX 5570475 // 65535*0.85*100 +#define BH1745_TIME_MIN 1638375 // 65535*0.25*100 + +/* ALS GAIN */ +#define BH1745_GAIN_1X 1 +#define BH1745_GAIN_2X 2 +#define BH1745_GAIN_16X 16 + +/* ALS TIME REG VALUE */ +#define EXTENDED_ALS_TIME_GROUP_ATTR_VALUE_0 0x00 +#define EXTENDED_ALS_TIME_GROUP_ATTR_VALUE_1 0x01 +#define EXTENDED_ALS_TIME_GROUP_ATTR_VALUE_2 0x02 +#define EXTENDED_ALS_TIME_GROUP_ATTR_VALUE_3 0x03 +#define EXTENDED_ALS_TIME_GROUP_ATTR_VALUE_4 0x04 +#define EXTENDED_ALS_TIME_GROUP_ATTR_VALUE_5 0x05 + +/* ALS GAIN REG VALUE */ +#define EXTENDED_ALS_GAIN_GROUP_ATTR_VALUE_0 0x00 +#define EXTENDED_ALS_GAIN_GROUP_ATTR_VALUE_1 0x01 +#define EXTENDED_ALS_GAIN_GROUP_ATTR_VALUE_2 0x02 + +enum ExtendedAlsTimeRegGroupIdex { + EXTENDED_ALS_TIME_GROUP_INDEX_0 = 0, + EXTENDED_ALS_TIME_GROUP_INDEX_1, + EXTENDED_ALS_TIME_GROUP_INDEX_2, + EXTENDED_ALS_TIME_GROUP_INDEX_3, + EXTENDED_ALS_TIME_GROUP_INDEX_4, + EXTENDED_ALS_TIME_GROUP_INDEX_5, + EXTENDED_ALS_TIME_GROUP_INDEX_MAX, +}; + +enum ExtendedAlsGainRegGroupIdex { + EXTENDED_ALS_GAIN_GROUP_INDEX_0 = 0, + EXTENDED_ALS_GAIN_GROUP_INDEX_1, + EXTENDED_ALS_GAIN_GROUP_INDEX_2, + EXTENDED_ALS_GAIN_GROUP_INDEX_MAX, +}; + +int32_t DetectAlsBim160Chip(struct SensorCfgData *data); +int32_t ReadBh1745Data(struct SensorCfgData *data); + +struct Bh1745DrvData { + struct IDeviceIoService ioService; + struct HdfDeviceObject *device; + struct SensorCfgData *sensorCfg; +}; + +#endif /* ALS_BH1745_H */ diff --git a/model/sensor/driver/chipset/barometer/barometer_bmp180.c b/model/sensor/driver/chipset/barometer/barometer_bmp180.c index 298684807b3ba09db2e44bb823c81378c0a3bce9..3c5f150e1cd641448bceb1a792416510e856c031 100644 --- a/model/sensor/driver/chipset/barometer/barometer_bmp180.c +++ b/model/sensor/driver/chipset/barometer/barometer_bmp180.c @@ -1,411 +1,414 @@ -/* - * Copyright (c) 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 "barometer_bmp180.h" -#include -#include "osal_mem.h" -#include "osal_time.h" -#include "sensor_barometer_driver.h" -#include "sensor_config_controller.h" -#include "sensor_device_manager.h" -#include "sensor_platform_if.h" - -static struct Bmp180DrvData *g_bmp180DrvData = NULL; - -struct Bmp180DrvData *Bmp180GetDrvData(void) -{ - return g_bmp180DrvData; -} - -/* IO config for int-pin and I2C-pin */ -#define SENSOR_I2C6_DATA_REG_ADDR 0x114f004c -#define SENSOR_I2C6_CLK_REG_ADDR 0x114f0048 -#define SENSOR_I2C_REG_CFG 0x403 - -static struct BarometerEepromData g_calibraData = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; - -static int32_t ReadEepromRawData(struct SensorCfgData *data, uint8_t rfg[BAROMETER_EEPROM_SUM]) -{ - int32_t ret; - - ret = ReadSensor(&data->busCfg, BMP180_AC1_MSB_ADDR, &rfg[BAROMETER_AC1_MSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_AC1_LSB_ADDR, &rfg[BAROMETER_AC1_LSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_AC2_MSB_ADDR, &rfg[BAROMETER_AC2_MSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_AC2_LSB_ADDR, &rfg[BAROMETER_AC2_LSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_AC3_MSB_ADDR, &rfg[BAROMETER_AC3_MSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_AC3_LSB_ADDR, &rfg[BAROMETER_AC3_LSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_AC4_MSB_ADDR, &rfg[BAROMETER_AC4_MSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_AC4_LSB_ADDR, &rfg[BAROMETER_AC4_LSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_AC5_MSB_ADDR, &rfg[BAROMETER_AC5_MSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_AC5_LSB_ADDR, &rfg[BAROMETER_AC5_LSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_AC6_MSB_ADDR, &rfg[BAROMETER_AC6_MSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - ret = ReadSensor(&data->busCfg, BMP180_AC6_LSB_ADDR, &rfg[BAROMETER_AC6_LSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_B1_MSB_ADDR, &rfg[BAROMETER_B1_MSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_B1_LSB_ADDR, &rfg[BAROMETER_B1_LSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_B2_MSB_ADDR, &rfg[BAROMETER_B2_MSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_B2_LSB_ADDR, &rfg[BAROMETER_B2_LSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_MB_MSB_ADDR, &rfg[BAROMETER_MB_MSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_MB_LSB_ADDR, &rfg[BAROMETER_MB_LSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_MC_MSB_ADDR, &rfg[BAROMETER_MC_MSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_MC_LSB_ADDR, &rfg[BAROMETER_MC_LSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_MD_MSB_ADDR, &rfg[BAROMETER_MD_MSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_MD_LSB_ADDR, &rfg[BAROMETER_MD_LSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - return ret; -} - -static int32_t ReadEepromData(struct SensorCfgData *data, struct BarometerEepromData *g_calibraData) -{ - int32_t ret; - uint8_t reg[BAROMETER_EEPROM_SUM]; - - (void)memset_s(reg, sizeof(reg), 0, sizeof(reg)); - - CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); - - ret = ReadEepromRawData(data, reg); - if (ret != HDF_SUCCESS) { - return HDF_FAILURE; - } - - g_calibraData->ac1 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC1_MSB], SENSOR_DATA_WIDTH_8_BIT) | - reg[BAROMETER_AC1_LSB]); - g_calibraData->ac2 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC2_MSB], SENSOR_DATA_WIDTH_8_BIT) | - reg[BAROMETER_AC2_LSB]); - g_calibraData->ac3 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC3_MSB], SENSOR_DATA_WIDTH_8_BIT) | - reg[BAROMETER_AC3_LSB]); - g_calibraData->ac4 = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC4_MSB], SENSOR_DATA_WIDTH_8_BIT) | - reg[BAROMETER_AC4_LSB]); - g_calibraData->ac5 = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC5_MSB], SENSOR_DATA_WIDTH_8_BIT) | - reg[BAROMETER_AC5_LSB]); - g_calibraData->ac6 = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC6_MSB], SENSOR_DATA_WIDTH_8_BIT) | - reg[BAROMETER_AC6_LSB]); - g_calibraData->b1 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_B1_MSB], SENSOR_DATA_WIDTH_8_BIT) | - reg[BAROMETER_B1_LSB]); - g_calibraData->b2 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_B2_MSB], SENSOR_DATA_WIDTH_8_BIT) | - reg[BAROMETER_B2_LSB]); - g_calibraData->mb = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_MB_MSB], SENSOR_DATA_WIDTH_8_BIT) | - reg[BAROMETER_MB_LSB]); - g_calibraData->mc = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_MC_MSB], SENSOR_DATA_WIDTH_8_BIT) | - reg[BAROMETER_MC_LSB]); - g_calibraData->md = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_MD_MSB], SENSOR_DATA_WIDTH_8_BIT) | - reg[BAROMETER_MD_LSB]); - - return ret; -} - -static int32_t ReadTempData(struct SensorCfgData *data, struct BarometerRawData *Temp) -{ - int32_t ret; - uint8_t status = 0; - uint8_t reg[BAROMETER_TEM_SUM]; - uint8_t value[SENSOR_VALUE_BUTT]; - value[SENSOR_ADDR_INDEX] = BMP180_CONTROL_REG_ADDR; - value[SENSOR_VALUE_INDEX] = BMP180_COVERT_TEMP; - - (void)memset_s(reg, sizeof(reg), 0, sizeof(reg)); - - CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); - - ret = ReadSensor(&data->busCfg, BMP180_COVERT_PRES_3, &status, sizeof(uint8_t)); - if ((status & BMP180_STATUS_ADDR) == BMP180_STATUS_JUDGE) { - WriteSensor(&data->busCfg, value, sizeof(value)); - OsalMDelay(DELAY_0); - ret = ReadSensor(&data->busCfg, BMP180_OUT_MSB_ADDR, ®[BAROMETER_TEM_MSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_OUT_LSB_ADDR, ®[BAROMETER_TEM_LSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - Temp->unpensateTemp = (int32_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_TEM_MSB], SENSOR_DATA_WIDTH_8_BIT) | - reg[BAROMETER_TEM_LSB]); - } - return ret; -} - -static int32_t ReadBarometerData(struct SensorCfgData *data, struct BarometerRawData *Barom) -{ - int32_t ret; - uint8_t status = 0; - uint8_t reg[BAROMETER_BAR_SUM]; - uint8_t value[SENSOR_VALUE_BUTT]; - value[SENSOR_ADDR_INDEX] = BMP180_CONTROL_REG_ADDR; - value[SENSOR_VALUE_INDEX] = BMP180_COVERT_PRES_1; - - (void)memset_s(reg, sizeof(reg), 0, sizeof(reg)); - - CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); - - ret = ReadSensor(&data->busCfg, BMP180_COVERT_PRES_3, &status, sizeof(uint8_t)); - if ((status & BMP180_STATUS_ADDR) == BMP180_STATUS_JUDGE) { - WriteSensor(&data->busCfg, value, sizeof(value)); - OsalMDelay(DELAY_1); - ret = ReadSensor(&data->busCfg, BMP180_OUT_MSB_ADDR, ®[BAROMETER_BAR_MSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_OUT_LSB_ADDR, ®[BAROMETER_BAR_LSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - ret = ReadSensor(&data->busCfg, BMP180_OUT_XLSB_ADDR, ®[BAROMETER_BAR_XLSB], sizeof(uint8_t)); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); - - Barom->unpensatePre = (int32_t)(SENSOR_DATA_SHIFT_RIGHT( - (SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_BAR_MSB], SENSOR_DATA_WIDTH_16_BIT) | - SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_BAR_LSB], SENSOR_DATA_WIDTH_8_BIT) | reg[BAROMETER_BAR_XLSB]), - (BMP180_CONSTANT_4 - OSSETTING))); - } - return ret; -} - -static int32_t CalcBarometerData(struct BarometerRawData *barometerData, int32_t tnp[BAROMETER_SUM]) -{ - struct Coefficient coefficientData = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; - - // Calculated temperature - - coefficientData.x1 = ((barometerData->unpensateTemp - g_calibraData.ac6) * (g_calibraData.ac5)) - >> BMP180_CONSTANT_8; - coefficientData.x2 = (g_calibraData.mc << BMP180_CONSTANT_5) / (coefficientData.x1 + g_calibraData.md); - coefficientData.b5 = coefficientData.x1 + coefficientData.x2; - tnp[BAROMETER_TEMPERATURE] = (coefficientData.b5 + BMP180_CONSTANT_4) >> BMP180_CONSTANT_3; - - // Calculated pressure - - coefficientData.b6 = coefficientData.b5 - BMP180_CONSTANT_12; - coefficientData.x1 = (g_calibraData.b2 * ((coefficientData.b6 * coefficientData.b6) >> BMP180_CONSTANT_6)) - >> BMP180_CONSTANT_5; - coefficientData.x2 = (g_calibraData.ac2 * coefficientData.b6) >> BMP180_CONSTANT_5; - coefficientData.x3 = coefficientData.x1 + coefficientData.x2; - coefficientData.b3 = (((((int32_t)g_calibraData.ac1) * BMP180_CONSTANT_3 + coefficientData.x3) << OSSETTING) - + BMP180_CONSTANT_2) >> BMP180_CONSTANT_2; - coefficientData.x1 = (g_calibraData.ac3 * coefficientData.b6) >> BMP180_CONSTANT_7; - coefficientData.x2 = (g_calibraData.b1 * ((coefficientData.b6 * coefficientData.b6) >> BMP180_CONSTANT_6)) - >> BMP180_CONSTANT_9; - coefficientData.x3 = ((coefficientData.x1 + coefficientData.x2) + BMP180_CONSTANT_2) >> BMP180_CONSTANT_2; - coefficientData.b4 = (g_calibraData.ac4 * (uint32_t)(coefficientData.x3 + BMP180_CONSTANT_13)) - >> BMP180_CONSTANT_8; - coefficientData.b7 = ((uint32_t)(barometerData->unpensatePre) - (uint32_t)coefficientData.b3) - * (BMP180_CONSTANT_14 >> OSSETTING); - if (coefficientData.b7 < BMP180_CONSTANT_15) { - coefficientData.p = (coefficientData.b7 << BMP180_CONSTANT_1) / coefficientData.b4; - } else { - coefficientData.p = (coefficientData.b7 / coefficientData.b4) << BMP180_CONSTANT_1; - } - coefficientData.x1 = (coefficientData.p >> BMP180_CONSTANT_4) * (coefficientData.p >> BMP180_CONSTANT_4); - coefficientData.x1 = (coefficientData.x1 * BMP180_CONSTANT_10) >> BMP180_CONSTANT_9; - coefficientData.x2 = (BMP180_CONSTANT_0 * coefficientData.p) >> BMP180_CONSTANT_9; - tnp[BAROMETER_BAROMETER] = coefficientData.p + ((coefficientData.x1 + coefficientData.x2 - + BMP180_CONSTANT_11) >> BMP180_CONSTANT_3); - - return HDF_SUCCESS; -} - -int32_t ReadBmp180Data(struct SensorCfgData *data) -{ - int32_t ret; - int32_t tmp[BAROMETER_SUM]; - struct BarometerRawData barometerData = {0, 0}; - OsalTimespec time; - struct SensorReportEvent event; - - (void)memset_s(&time, sizeof(time), 0, sizeof(time)); - (void)memset_s(&event, sizeof(event), 0, sizeof(event)); - - if (OsalGetTime(&time) != HDF_SUCCESS) { - HDF_LOGE("%s: Get time failed", __func__); - return HDF_FAILURE; - } - event.timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * SENSOR_CONVERT_UNIT; - - ret = ReadTempData(data, &barometerData); - if (ret != HDF_SUCCESS) { - return HDF_FAILURE; - } - - ret = ReadBarometerData(data, &barometerData); - if (ret != HDF_SUCCESS) { - return HDF_FAILURE; - } - - ret = CalcBarometerData(&barometerData, tmp); - if (ret != HDF_SUCCESS) { - return HDF_FAILURE; - } - - event.sensorId = SENSOR_TAG_BAROMETER; - event.option = 0; - event.mode = SENSOR_WORK_MODE_REALTIME; - event.dataLen = sizeof(tmp); - event.data = (uint8_t *)&tmp; - ret = ReportSensorEvent(&event); - return ret; -} - -static int32_t InitBmp180(struct SensorCfgData *data) -{ - int32_t ret; - CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); - struct SensorReportEvent event; - - (void)memset_s(&event, sizeof(event), 0, sizeof(event)); - - ret = ReadEepromData(data, &g_calibraData); - if (ret != HDF_SUCCESS) { - return HDF_FAILURE; - } - ret = SetSensorRegCfgArray(&data->busCfg, data->regCfgGroup[SENSOR_INIT_GROUP]); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: BMP180 sensor init config failed", __func__); - return HDF_FAILURE; - } - return HDF_SUCCESS; -} - -static int32_t InitBarometerPreConfig(void) -{ - if (SetSensorPinMux(SENSOR_I2C6_DATA_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_I2C_REG_CFG) != HDF_SUCCESS) { - HDF_LOGE("%s: Data write mux pin failed", __func__); - return HDF_FAILURE; - } - if (SetSensorPinMux(SENSOR_I2C6_CLK_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_I2C_REG_CFG) != HDF_SUCCESS) { - HDF_LOGE("%s: Clk write mux pin failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -static int32_t DispatchBMP180(struct HdfDeviceIoClient *client, - int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) -{ - (void)client; - (void)cmd; - (void)data; - (void)reply; - - return HDF_SUCCESS; -} - -int32_t Bmp180BindDriver(struct HdfDeviceObject *device) -{ - CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); - - struct Bmp180DrvData *drvData = (struct Bmp180DrvData *)OsalMemCalloc(sizeof(*drvData)); - if (drvData == NULL) { - HDF_LOGE("%s: Malloc Bmi160 drv data fail", __func__); - return HDF_ERR_MALLOC_FAIL; - } - - drvData->ioService.Dispatch = DispatchBMP180; - drvData->device = device; - device->service = &drvData->ioService; - g_bmp180DrvData = drvData; - - return HDF_SUCCESS; -} - -int32_t Bmp180InitDriver(struct HdfDeviceObject *device) -{ - int32_t ret; - struct BarometerOpsCall ops; - - CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); - struct Bmp180DrvData *drvData = (struct Bmp180DrvData *)device->service; - CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); - - ret = InitBarometerPreConfig(); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: Init BMp180 bus mux config", __func__); - return HDF_FAILURE; - } - - drvData->sensorCfg = BarometerCreateCfgData(device->property); - if (drvData->sensorCfg == NULL) { - return HDF_ERR_NOT_SUPPORT; - } - - ops.Init = NULL; - ops.ReadData = ReadBmp180Data; - ret = BarometerRegisterChipOps(&ops); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: Register BMp180 barometer failed", __func__); - return HDF_FAILURE; - } - - ret = InitBmp180(drvData->sensorCfg); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: Init BMP180 barometer failed", __func__); - return HDF_FAILURE; - } - - return HDF_SUCCESS; -} - -void Bmp180ReleaseDriver(struct HdfDeviceObject *device) -{ - CHECK_NULL_PTR_RETURN(device); - - struct Bmp180DrvData *drvData = (struct Bmp180DrvData *)device->service; - CHECK_NULL_PTR_RETURN(drvData); - - BarometerReleaseCfgData(drvData->sensorCfg); - drvData->sensorCfg = NULL; - OsalMemFree(drvData); -} - -struct HdfDriverEntry g_barometerBmp180DevEntry = { - .moduleVersion = 1, - .moduleName = "HDF_SENSOR_BAROMETER_BMP180", - .Bind = Bmp180BindDriver, - .Init = Bmp180InitDriver, - .Release = Bmp180ReleaseDriver, -}; - +/* + * Copyright (c) 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 "barometer_bmp180.h" +#include +#include "osal_mem.h" +#include "osal_time.h" +#include "sensor_barometer_driver.h" +#include "sensor_config_controller.h" +#include "sensor_device_manager.h" +#include "sensor_platform_if.h" + +static struct Bmp180DrvData *g_bmp180DrvData = NULL; + +struct Bmp180DrvData *Bmp180GetDrvData(void) +{ + return g_bmp180DrvData; +} + +/* IO config for int-pin and I2C-pin */ +#define SENSOR_I2C6_DATA_REG_ADDR 0x114f004c +#define SENSOR_I2C6_CLK_REG_ADDR 0x114f0048 +#define SENSOR_I2C_REG_CFG 0x403 + +static struct BarometerEepromData g_calibraData = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; + +static int32_t ReadEepromRawData(struct SensorCfgData *data, uint8_t rfg[BAROMETER_EEPROM_SUM]) +{ + int32_t ret; + + ret = ReadSensor(&data->busCfg, BMP180_AC1_MSB_ADDR, &rfg[BAROMETER_AC1_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_AC1_LSB_ADDR, &rfg[BAROMETER_AC1_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_AC2_MSB_ADDR, &rfg[BAROMETER_AC2_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_AC2_LSB_ADDR, &rfg[BAROMETER_AC2_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_AC3_MSB_ADDR, &rfg[BAROMETER_AC3_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_AC3_LSB_ADDR, &rfg[BAROMETER_AC3_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_AC4_MSB_ADDR, &rfg[BAROMETER_AC4_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_AC4_LSB_ADDR, &rfg[BAROMETER_AC4_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_AC5_MSB_ADDR, &rfg[BAROMETER_AC5_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_AC5_LSB_ADDR, &rfg[BAROMETER_AC5_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_AC6_MSB_ADDR, &rfg[BAROMETER_AC6_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + ret = ReadSensor(&data->busCfg, BMP180_AC6_LSB_ADDR, &rfg[BAROMETER_AC6_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_B1_MSB_ADDR, &rfg[BAROMETER_B1_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_B1_LSB_ADDR, &rfg[BAROMETER_B1_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_B2_MSB_ADDR, &rfg[BAROMETER_B2_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_B2_LSB_ADDR, &rfg[BAROMETER_B2_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_MB_MSB_ADDR, &rfg[BAROMETER_MB_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_MB_LSB_ADDR, &rfg[BAROMETER_MB_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_MC_MSB_ADDR, &rfg[BAROMETER_MC_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_MC_LSB_ADDR, &rfg[BAROMETER_MC_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_MD_MSB_ADDR, &rfg[BAROMETER_MD_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_MD_LSB_ADDR, &rfg[BAROMETER_MD_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + return ret; +} + +static int32_t ReadEepromData(struct SensorCfgData *data, struct BarometerEepromData *g_calibraData) +{ + int32_t ret; + uint8_t reg[BAROMETER_EEPROM_SUM]; + + (void)memset_s(reg, sizeof(reg), 0, sizeof(reg)); + + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + + ret = ReadEepromRawData(data, reg); + if (ret != HDF_SUCCESS) { + return HDF_FAILURE; + } + + g_calibraData->ac1 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC1_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[BAROMETER_AC1_LSB]); + g_calibraData->ac2 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC2_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[BAROMETER_AC2_LSB]); + g_calibraData->ac3 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC3_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[BAROMETER_AC3_LSB]); + g_calibraData->ac4 = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC4_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[BAROMETER_AC4_LSB]); + g_calibraData->ac5 = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC5_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[BAROMETER_AC5_LSB]); + g_calibraData->ac6 = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_AC6_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[BAROMETER_AC6_LSB]); + g_calibraData->b1 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_B1_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[BAROMETER_B1_LSB]); + g_calibraData->b2 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_B2_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[BAROMETER_B2_LSB]); + g_calibraData->mb = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_MB_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[BAROMETER_MB_LSB]); + g_calibraData->mc = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_MC_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[BAROMETER_MC_LSB]); + g_calibraData->md = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_MD_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[BAROMETER_MD_LSB]); + + return ret; +} + +static int32_t ReadTempData(struct SensorCfgData *data, struct BarometerRawData *Temp) +{ + int32_t ret; + uint8_t status = 0; + uint8_t reg[BAROMETER_TEM_SUM]; + uint8_t value[SENSOR_VALUE_BUTT]; + value[SENSOR_ADDR_INDEX] = BMP180_CONTROL_REG_ADDR; + value[SENSOR_VALUE_INDEX] = BMP180_COVERT_TEMP; + + (void)memset_s(reg, sizeof(reg), 0, sizeof(reg)); + + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + + ret = ReadSensor(&data->busCfg, BMP180_COVERT_PRES_3, &status, sizeof(uint8_t)); + if ((status & BMP180_STATUS_ADDR) == BMP180_STATUS_JUDGE) { + WriteSensor(&data->busCfg, value, sizeof(value)); + OsalMDelay(DELAY_0); + ret = ReadSensor(&data->busCfg, BMP180_OUT_MSB_ADDR, ®[BAROMETER_TEM_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_OUT_LSB_ADDR, ®[BAROMETER_TEM_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + Temp->unpensateTemp = (int32_t)(SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_TEM_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[BAROMETER_TEM_LSB]); + } + return ret; +} + +static int32_t ReadBarometerData(struct SensorCfgData *data, struct BarometerRawData *Barom) +{ + int32_t ret; + uint8_t status = 0; + uint8_t reg[BAROMETER_BAR_SUM]; + uint8_t value[SENSOR_VALUE_BUTT]; + value[SENSOR_ADDR_INDEX] = BMP180_CONTROL_REG_ADDR; + value[SENSOR_VALUE_INDEX] = BMP180_COVERT_PRES_1; + + (void)memset_s(reg, sizeof(reg), 0, sizeof(reg)); + + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + + ret = ReadSensor(&data->busCfg, BMP180_COVERT_PRES_3, &status, sizeof(uint8_t)); + if ((status & BMP180_STATUS_ADDR) == BMP180_STATUS_JUDGE) { + WriteSensor(&data->busCfg, value, sizeof(value)); + OsalMDelay(DELAY_1); + ret = ReadSensor(&data->busCfg, BMP180_OUT_MSB_ADDR, ®[BAROMETER_BAR_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_OUT_LSB_ADDR, ®[BAROMETER_BAR_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, BMP180_OUT_XLSB_ADDR, ®[BAROMETER_BAR_XLSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + Barom->unpensatePre = (int32_t)(SENSOR_DATA_SHIFT_RIGHT( + (SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_BAR_MSB], SENSOR_DATA_WIDTH_16_BIT) | + SENSOR_DATA_SHIFT_LEFT(reg[BAROMETER_BAR_LSB], SENSOR_DATA_WIDTH_8_BIT) | reg[BAROMETER_BAR_XLSB]), + (BMP180_CONSTANT_4 - OSSETTING))); + } + return ret; +} + +static int32_t CalcBarometerData(struct BarometerRawData *barometerData, int32_t tnp[BAROMETER_SUM]) +{ + struct Coefficient coefficientData = { 0, 0, 0, 0, 0, 0, 0, 0, 0 }; + + // Calculated temperature + + coefficientData.x1 = ((barometerData->unpensateTemp - g_calibraData.ac6) * (g_calibraData.ac5)) + >> BMP180_CONSTANT_8; + coefficientData.x2 = (g_calibraData.mc << BMP180_CONSTANT_5) / (coefficientData.x1 + g_calibraData.md); + coefficientData.b5 = coefficientData.x1 + coefficientData.x2; + tnp[BAROMETER_TEMPERATURE] = (coefficientData.b5 + BMP180_CONSTANT_4) >> BMP180_CONSTANT_3; + + // Calculated pressure + + coefficientData.b6 = coefficientData.b5 - BMP180_CONSTANT_12; + coefficientData.x1 = (g_calibraData.b2 * ((coefficientData.b6 * coefficientData.b6) >> BMP180_CONSTANT_6)) + >> BMP180_CONSTANT_5; + coefficientData.x2 = (g_calibraData.ac2 * coefficientData.b6) >> BMP180_CONSTANT_5; + coefficientData.x3 = coefficientData.x1 + coefficientData.x2; + coefficientData.b3 = (((((int32_t)g_calibraData.ac1) * BMP180_CONSTANT_3 + coefficientData.x3) << OSSETTING) + + BMP180_CONSTANT_2) >> BMP180_CONSTANT_2; + coefficientData.x1 = (g_calibraData.ac3 * coefficientData.b6) >> BMP180_CONSTANT_7; + coefficientData.x2 = (g_calibraData.b1 * ((coefficientData.b6 * coefficientData.b6) >> BMP180_CONSTANT_6)) + >> BMP180_CONSTANT_9; + coefficientData.x3 = ((coefficientData.x1 + coefficientData.x2) + BMP180_CONSTANT_2) >> BMP180_CONSTANT_2; + coefficientData.b4 = (g_calibraData.ac4 * (uint32_t)(coefficientData.x3 + BMP180_CONSTANT_13)) + >> BMP180_CONSTANT_8; + coefficientData.b7 = ((uint32_t)(barometerData->unpensatePre) - (uint32_t)coefficientData.b3) + * (BMP180_CONSTANT_14 >> OSSETTING); + if (coefficientData.b7 < BMP180_CONSTANT_15) { + coefficientData.p = (coefficientData.b7 << BMP180_CONSTANT_1) / coefficientData.b4; + } else { + coefficientData.p = (coefficientData.b7 / coefficientData.b4) << BMP180_CONSTANT_1; + } + coefficientData.x1 = (coefficientData.p >> BMP180_CONSTANT_4) * (coefficientData.p >> BMP180_CONSTANT_4); + coefficientData.x1 = (coefficientData.x1 * BMP180_CONSTANT_10) >> BMP180_CONSTANT_9; + coefficientData.x2 = (BMP180_CONSTANT_0 * coefficientData.p) >> BMP180_CONSTANT_9; + tnp[BAROMETER_BAROMETER] = coefficientData.p + ((coefficientData.x1 + coefficientData.x2 + + BMP180_CONSTANT_11) >> BMP180_CONSTANT_3); + + return HDF_SUCCESS; +} + +int32_t ReadBmp180Data(struct SensorCfgData *data) +{ + int32_t ret; + int32_t tmp[BAROMETER_SUM]; + struct BarometerRawData barometerData = {0, 0}; + OsalTimespec time; + struct SensorReportEvent event; + + (void)memset_s(&time, sizeof(time), 0, sizeof(time)); + (void)memset_s(&event, sizeof(event), 0, sizeof(event)); + + if (OsalGetTime(&time) != HDF_SUCCESS) { + HDF_LOGE("%s: Get time failed", __func__); + return HDF_FAILURE; + } + event.timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * SENSOR_CONVERT_UNIT; + + ret = ReadTempData(data, &barometerData); + if (ret != HDF_SUCCESS) { + return HDF_FAILURE; + } + + ret = ReadBarometerData(data, &barometerData); + if (ret != HDF_SUCCESS) { + return HDF_FAILURE; + } + + ret = CalcBarometerData(&barometerData, tmp); + if (ret != HDF_SUCCESS) { + return HDF_FAILURE; + } + + event.sensorId = SENSOR_TAG_BAROMETER; + event.option = 0; + event.mode = SENSOR_WORK_MODE_REALTIME; + event.dataLen = sizeof(tmp); + event.data = (uint8_t *)&tmp; + ret = ReportSensorEvent(&event); + return ret; +} + +static int32_t InitBmp180(struct SensorCfgData *data) +{ + int32_t ret; + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + struct SensorReportEvent event; + + (void)memset_s(&event, sizeof(event), 0, sizeof(event)); + + ret = ReadEepromData(data, &g_calibraData); + if (ret != HDF_SUCCESS) { + return HDF_FAILURE; + } + ret = SetSensorRegCfgArray(&data->busCfg, data->regCfgGroup[SENSOR_INIT_GROUP]); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: BMP180 sensor init config failed", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static int32_t InitBarometerPreConfig(void) +{ + if (SetSensorPinMux(SENSOR_I2C6_DATA_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_I2C_REG_CFG) != HDF_SUCCESS) { + HDF_LOGE("%s: Data write mux pin failed", __func__); + return HDF_FAILURE; + } + if (SetSensorPinMux(SENSOR_I2C6_CLK_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_I2C_REG_CFG) != HDF_SUCCESS) { + HDF_LOGE("%s: Clk write mux pin failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t DispatchBMP180(struct HdfDeviceIoClient *client, + int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)client; + (void)cmd; + (void)data; + (void)reply; + + return HDF_SUCCESS; +} + +int32_t Bmp180BindDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + + struct Bmp180DrvData *drvData = (struct Bmp180DrvData *)OsalMemCalloc(sizeof(*drvData)); + if (drvData == NULL) { + HDF_LOGE("%s: Malloc Bmi160 drv data fail", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + drvData->ioService.Dispatch = DispatchBMP180; + drvData->device = device; + device->service = &drvData->ioService; + g_bmp180DrvData = drvData; + + return HDF_SUCCESS; +} + +int32_t Bmp180InitDriver(struct HdfDeviceObject *device) +{ + int32_t ret; + struct BarometerOpsCall ops; + + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + struct Bmp180DrvData *drvData = (struct Bmp180DrvData *)device->service; + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + ret = InitBarometerPreConfig(); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Init BMp180 bus mux config", __func__); + return HDF_FAILURE; + } + + drvData->sensorCfg = BarometerCreateCfgData(device->property); + if (drvData->sensorCfg == NULL || drvData->sensorCfg->root == NULL) { + HDF_LOGD("%s: Creating barometercfg failed because detection failed", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + ops.Init = NULL; + ops.ReadData = ReadBmp180Data; + ret = BarometerRegisterChipOps(&ops); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Register BMp180 barometer failed", __func__); + return HDF_FAILURE; + } + + ret = InitBmp180(drvData->sensorCfg); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Init BMP180 barometer failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +void Bmp180ReleaseDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN(device); + + struct Bmp180DrvData *drvData = (struct Bmp180DrvData *)device->service; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->sensorCfg != NULL) { + BarometerReleaseCfgData(drvData->sensorCfg); + drvData->sensorCfg = NULL; + } + OsalMemFree(drvData); +} + +struct HdfDriverEntry g_barometerBmp180DevEntry = { + .moduleVersion = 1, + .moduleName = "HDF_SENSOR_BAROMETER_BMP180", + .Bind = Bmp180BindDriver, + .Init = Bmp180InitDriver, + .Release = Bmp180ReleaseDriver, +}; + HDF_INIT(g_barometerBmp180DevEntry); \ No newline at end of file diff --git a/model/sensor/driver/chipset/barometer/barometer_bmp180.h b/model/sensor/driver/chipset/barometer/barometer_bmp180.h index a361405bfa00f6f941624da4e8b1241d93f480b8..c62e1aa1f3fbf5a4e40843368064cffbc60a0a50 100644 --- a/model/sensor/driver/chipset/barometer/barometer_bmp180.h +++ b/model/sensor/driver/chipset/barometer/barometer_bmp180.h @@ -1,96 +1,96 @@ -/* - * Copyright (c) 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 BAROMETER_BMP180_H -#define BAROMETER_BMP180_H - -#include "sensor_barometer_driver.h" -#include "sensor_config_parser.h" - -#define BMP180_REG_CHIP_ID 0xD0 - -// i2c slave address - -#define BMP180_ADDR 0x77 - -// Define calibration register address - -#define BMP180_AC1_MSB_ADDR 0xAA -#define BMP180_AC1_LSB_ADDR 0xAB -#define BMP180_AC2_MSB_ADDR 0xAC -#define BMP180_AC2_LSB_ADDR 0xAD -#define BMP180_AC3_MSB_ADDR 0xAE -#define BMP180_AC3_LSB_ADDR 0xAF -#define BMP180_AC4_MSB_ADDR 0xB0 -#define BMP180_AC4_LSB_ADDR 0xB1 -#define BMP180_AC5_MSB_ADDR 0xB2 -#define BMP180_AC5_LSB_ADDR 0xB3 -#define BMP180_AC6_MSB_ADDR 0xB4 -#define BMP180_AC6_LSB_ADDR 0xB5 -#define BMP180_B1_MSB_ADDR 0xB6 -#define BMP180_B1_LSB_ADDR 0xB7 -#define BMP180_B2_MSB_ADDR 0xB8 -#define BMP180_B2_LSB_ADDR 0xB9 -#define BMP180_MB_MSB_ADDR 0xBA -#define BMP180_MB_LSB_ADDR 0xBB -#define BMP180_MC_MSB_ADDR 0xBC -#define BMP180_MC_LSB_ADDR 0xBD -#define BMP180_MD_MSB_ADDR 0xBE -#define BMP180_MD_LSB_ADDR 0xBf - -// Control register - -#define BMP180_CONTROL_REG_ADDR 0xF4 -#define BMP180_COVERT_TEMP 0x2E -#define BMP180_COVERT_PRES_0 0x34 -#define BMP180_COVERT_PRES_1 0x74 -#define BMP180_COVERT_PRES_2 0xB4 -#define BMP180_COVERT_PRES_3 0xF4 - -#define BMP180_OUT_MSB_ADDR 0xF6 -#define BMP180_OUT_LSB_ADDR 0xF7 -#define BMP180_OUT_XLSB_ADDR 0xF8 - -#define BMP180_STATUS_ADDR 0X20 -#define BMP180_STATUS_JUDGE 0X00 - -#define SENSOR_DATA_WIDTH_16_BIT 16 - -#define OSSETTING 1 -#define DELAY_0 5 -#define DELAY_1 8 -#define OSS_TIME_MS 26 - -#define BMP180_CONSTANT_0 (-7357) -#define BMP180_CONSTANT_1 1 -#define BMP180_CONSTANT_2 2 -#define BMP180_CONSTANT_3 4 -#define BMP180_CONSTANT_4 8 -#define BMP180_CONSTANT_5 11 -#define BMP180_CONSTANT_6 12 -#define BMP180_CONSTANT_7 13 -#define BMP180_CONSTANT_8 15 -#define BMP180_CONSTANT_9 16 -#define BMP180_CONSTANT_10 3038 -#define BMP180_CONSTANT_11 3791 -#define BMP180_CONSTANT_12 4000 -#define BMP180_CONSTANT_13 32768 -#define BMP180_CONSTANT_14 50000 -#define BMP180_CONSTANT_15 0x80000000 - - -int32_t DetectBarometerBmp180Chip(struct SensorCfgData *data); -int32_t ReadBmp180Data(struct SensorCfgData *data); - -struct Bmp180DrvData { - struct IDeviceIoService ioService; - struct HdfDeviceObject *device; - struct SensorCfgData *sensorCfg; -}; - +/* + * Copyright (c) 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 BAROMETER_BMP180_H +#define BAROMETER_BMP180_H + +#include "sensor_barometer_driver.h" +#include "sensor_config_parser.h" + +#define BMP180_REG_CHIP_ID 0xD0 + +// i2c slave address + +#define BMP180_ADDR 0x77 + +// Define calibration register address + +#define BMP180_AC1_MSB_ADDR 0xAA +#define BMP180_AC1_LSB_ADDR 0xAB +#define BMP180_AC2_MSB_ADDR 0xAC +#define BMP180_AC2_LSB_ADDR 0xAD +#define BMP180_AC3_MSB_ADDR 0xAE +#define BMP180_AC3_LSB_ADDR 0xAF +#define BMP180_AC4_MSB_ADDR 0xB0 +#define BMP180_AC4_LSB_ADDR 0xB1 +#define BMP180_AC5_MSB_ADDR 0xB2 +#define BMP180_AC5_LSB_ADDR 0xB3 +#define BMP180_AC6_MSB_ADDR 0xB4 +#define BMP180_AC6_LSB_ADDR 0xB5 +#define BMP180_B1_MSB_ADDR 0xB6 +#define BMP180_B1_LSB_ADDR 0xB7 +#define BMP180_B2_MSB_ADDR 0xB8 +#define BMP180_B2_LSB_ADDR 0xB9 +#define BMP180_MB_MSB_ADDR 0xBA +#define BMP180_MB_LSB_ADDR 0xBB +#define BMP180_MC_MSB_ADDR 0xBC +#define BMP180_MC_LSB_ADDR 0xBD +#define BMP180_MD_MSB_ADDR 0xBE +#define BMP180_MD_LSB_ADDR 0xBf + +// Control register + +#define BMP180_CONTROL_REG_ADDR 0xF4 +#define BMP180_COVERT_TEMP 0x2E +#define BMP180_COVERT_PRES_0 0x34 +#define BMP180_COVERT_PRES_1 0x74 +#define BMP180_COVERT_PRES_2 0xB4 +#define BMP180_COVERT_PRES_3 0xF4 + +#define BMP180_OUT_MSB_ADDR 0xF6 +#define BMP180_OUT_LSB_ADDR 0xF7 +#define BMP180_OUT_XLSB_ADDR 0xF8 + +#define BMP180_STATUS_ADDR 0X20 +#define BMP180_STATUS_JUDGE 0X00 + +#define SENSOR_DATA_WIDTH_16_BIT 16 + +#define OSSETTING 1 +#define DELAY_0 5 +#define DELAY_1 8 +#define OSS_TIME_MS 26 + +#define BMP180_CONSTANT_0 (-7357) +#define BMP180_CONSTANT_1 1 +#define BMP180_CONSTANT_2 2 +#define BMP180_CONSTANT_3 4 +#define BMP180_CONSTANT_4 8 +#define BMP180_CONSTANT_5 11 +#define BMP180_CONSTANT_6 12 +#define BMP180_CONSTANT_7 13 +#define BMP180_CONSTANT_8 15 +#define BMP180_CONSTANT_9 16 +#define BMP180_CONSTANT_10 3038 +#define BMP180_CONSTANT_11 3791 +#define BMP180_CONSTANT_12 4000 +#define BMP180_CONSTANT_13 32768 +#define BMP180_CONSTANT_14 50000 +#define BMP180_CONSTANT_15 0x80000000 + + +int32_t DetectBarometerBmp180Chip(struct SensorCfgData *data); +int32_t ReadBmp180Data(struct SensorCfgData *data); + +struct Bmp180DrvData { + struct IDeviceIoService ioService; + struct HdfDeviceObject *device; + struct SensorCfgData *sensorCfg; +}; + #endif /* BAROMETER_BMP180_H */ \ No newline at end of file diff --git a/model/sensor/driver/chipset/gyro/gyro_bmi160.c b/model/sensor/driver/chipset/gyro/gyro_bmi160.c index e4a8c366509ab6055b0fffc0a81da4741903f480..7f2abdb40a0a97b6acc5cfeda2a57c6916ba3dde 100644 --- a/model/sensor/driver/chipset/gyro/gyro_bmi160.c +++ b/model/sensor/driver/chipset/gyro/gyro_bmi160.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * 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. @@ -8,11 +8,21 @@ #include "gyro_bmi160.h" #include +#include "osal_mem.h" #include "osal_time.h" #include "sensor_gyro_driver.h" #include "sensor_config_controller.h" #include "sensor_device_manager.h" +#define HDF_LOG_TAG gyro_bmi160_c + +static struct Bmi160DrvData *g_bmi160DrvData = NULL; + +struct Bmi160DrvData *GyroBmi160GetDrvData(void) +{ + return g_bmi160DrvData; +} + /* IO config for int-pin and I2C-pin */ #define SENSOR_I2C6_DATA_REG_ADDR 0x114f004c #define SENSOR_I2C6_CLK_REG_ADDR 0x114f0048 @@ -90,13 +100,18 @@ int32_t ReadBmi160GyroData(struct SensorCfgData *data) tmp[GYRO_Y_AXIS] = rawData.y * BMI160_GYRO_SENSITIVITY_2000DPS; tmp[GYRO_Z_AXIS] = rawData.z * BMI160_GYRO_SENSITIVITY_2000DPS; + ret = SensorRawDataToRemapData(data->direction, tmp, sizeof(tmp) / sizeof(tmp[0])); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: BMI160 convert raw data failed", __func__); + return HDF_FAILURE; + } + event.dataLen = sizeof(tmp); event.data = (uint8_t *)&tmp; ret = ReportSensorEvent(&event); return ret; } - -static int32_t InitBmi160Gyro(struct SensorCfgData *data) +static int32_t InitBmi160(struct SensorCfgData *data) { int32_t ret; @@ -123,30 +138,94 @@ static int32_t InitGyroPreConfig(void) return HDF_SUCCESS; } -int32_t DetectGyroBim160Chip(struct SensorCfgData *data) +static int32_t DispatchBMI160(struct HdfDeviceIoClient *client, + int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)client; + (void)cmd; + (void)data; + (void)reply; + + return HDF_SUCCESS; +} + +int32_t GyroBmi160BindDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + + struct Bmi160DrvData *drvData = (struct Bmi160DrvData *)OsalMemCalloc(sizeof(*drvData)); + if (drvData == NULL) { + HDF_LOGE("%s: Malloc Bmi160 drv data fail", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + drvData->ioService.Dispatch = DispatchBMI160; + drvData->device = device; + device->service = &drvData->ioService; + g_bmi160DrvData = drvData; + + return HDF_SUCCESS; +} + +int32_t GyroBmi160InitDriver(struct HdfDeviceObject *device) { int32_t ret; struct GyroOpsCall ops; - CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); - if (strcmp(GYRO_CHIP_NAME_BMI160, data->sensorAttr.chipName) != 0) { - return HDF_SUCCESS; - } + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + struct Bmi160DrvData *drvData = (struct Bmi160DrvData *)device->service; + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + ret = InitGyroPreConfig(); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: init BMI160 bus mux config", __func__); + HDF_LOGE("%s: Init BMI160 bus mux config", __func__); return HDF_FAILURE; } - if (DetectSensorDevice(data) != HDF_SUCCESS) { - return HDF_FAILURE; + + drvData->sensorCfg = GyroCreateCfgData(device->property); + if (drvData->sensorCfg == NULL || drvData->sensorCfg->root == NULL) { + HDF_LOGD("%s: Creating gyrocfg failed because detection failed", __func__); + return HDF_ERR_NOT_SUPPORT; } - ops.Init = InitBmi160Gyro; + + ops.Init = NULL; ops.ReadData = ReadBmi160GyroData; - ret = RegisterGyroChipOps(&ops); + ret = GyroRegisterChipOps(&ops); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Register BMI160 gyro failed", __func__); + return HDF_FAILURE; + } + + ret = InitBmi160(drvData->sensorCfg); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: register BMI160 gyro failed", __func__); - (void)ReleaseSensorBusHandle(&data->busCfg); + HDF_LOGE("%s: Init BMI160 gyro failed", __func__); return HDF_FAILURE; } + return HDF_SUCCESS; } + +void GyroBmi160ReleaseDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN(device); + + struct Bmi160DrvData *drvData = (struct Bmi160DrvData *)device->service; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->sensorCfg != NULL) { + GyroReleaseCfgData(drvData->sensorCfg); + drvData->sensorCfg = NULL; + } + + OsalMemFree(drvData); +} + +struct HdfDriverEntry g_gyroBmi160DevEntry = { + .moduleVersion = 1, + .moduleName = "HDF_SENSOR_GYRO_BMI160", + .Bind = GyroBmi160BindDriver, + .Init = GyroBmi160InitDriver, + .Release = GyroBmi160ReleaseDriver, +}; + +HDF_INIT(g_gyroBmi160DevEntry); diff --git a/model/sensor/driver/chipset/gyro/gyro_bmi160.h b/model/sensor/driver/chipset/gyro/gyro_bmi160.h index 5e71e306f2d6ab772499221421910212ef2461a4..564952c8443808801dc07795da6283e992ffa753 100644 --- a/model/sensor/driver/chipset/gyro/gyro_bmi160.h +++ b/model/sensor/driver/chipset/gyro/gyro_bmi160.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * 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. @@ -9,6 +9,7 @@ #ifndef GYRO_BMI160_H #define GYRO_BMI160_H +#include "sensor_gyro_driver.h" #include "sensor_config_parser.h" /* GYRO DATA REGISTERS ADDR */ @@ -51,4 +52,10 @@ int32_t DetectGyroBim160Chip(struct SensorCfgData *data); int32_t ReadBmi160Data(struct SensorCfgData *data); +struct Bmi160DrvData { + struct IDeviceIoService ioService; + struct HdfDeviceObject *device; + struct SensorCfgData *sensorCfg; +}; + #endif /* GYRO_BMI160_H */ diff --git a/model/sensor/driver/chipset/hall/hall_ak8789.c b/model/sensor/driver/chipset/hall/hall_ak8789.c index adbd7838b506f8042219477d9a77f7ea673565aa..ba51bf0eb19bfd820b01a6c0d2389646ff39d10a 100755 --- a/model/sensor/driver/chipset/hall/hall_ak8789.c +++ b/model/sensor/driver/chipset/hall/hall_ak8789.c @@ -7,7 +7,6 @@ */ #include "hall_ak8789.h" -#include #include "osal_irq.h" #include "osal_mem.h" #include "osal_time.h" @@ -29,37 +28,6 @@ struct Ak8789DrvData *Ak8789GetDrvData(void) #define SENSOR_HALL_CLK_REG_ADDR 0x114f0044 #define SENSOR_HALL_REG_CFG 0x400 -int32_t ReadAk8789Data(struct SensorCfgData *data) -{ - int32_t ret; - uint8_t tmp = 1; - OsalTimespec time; - struct SensorReportEvent event; - - CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); - - (void)memset_s(&event, sizeof(event), 0, sizeof(event)); - (void)memset_s(&time, sizeof(time), 0, sizeof(time)); - if (OsalGetTime(&time) != HDF_SUCCESS) { - HDF_LOGE("%s: Get time failed", __func__); - return HDF_FAILURE; - } - - event.timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * - SENSOR_CONVERT_UNIT; /* unit nanosecond */ - event.sensorId = SENSOR_TAG_HALL; - event.version = 0; - event.option = 0; - event.mode = SENSOR_WORK_MODE_ON_CHANGE; - event.dataLen = sizeof(tmp); - event.data = (uint8_t *)&tmp; - ret = ReportSensorEvent(&event); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AK8789 report data failed", __func__); - } - return ret; -} - static int32_t InitHallPreConfig(void) { if (SetSensorPinMux(SENSOR_HALL_DATA_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_HALL_REG_CFG) != HDF_SUCCESS) { @@ -122,7 +90,7 @@ int32_t AK8789InitDriver(struct HdfDeviceObject *device) } ops.Init = NULL; - ops.ReadData = ReadAk8789Data; + ops.ReadData = NULL; ret = HallRegisterChipOps(&ops); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: Register AK8789 hall failed", __func__); diff --git a/model/sensor/driver/chipset/magnetic/magnetic_lsm303.c b/model/sensor/driver/chipset/magnetic/magnetic_lsm303.c new file mode 100755 index 0000000000000000000000000000000000000000..d006e14e81f3d2c0db02e9ad8255fd7e7f56a8fa --- /dev/null +++ b/model/sensor/driver/chipset/magnetic/magnetic_lsm303.c @@ -0,0 +1,241 @@ +/* + * Copyright (c) 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 "magnetic_lsm303.h" +#include +#include "osal_mem.h" +#include "osal_time.h" +#include "sensor_config_controller.h" +#include "sensor_device_manager.h" +#include "sensor_magnetic_driver.h" + +static struct Lsm303DrvData *g_lsm303DrvData = NULL; + +struct Lsm303DrvData *Lsm303GetDrvData(void) +{ + return g_lsm303DrvData; +} + +/* IO config for int-pin and I2C-pin */ +#define SENSOR_I2C6_DATA_REG_ADDR 0x114f004c +#define SENSOR_I2C6_CLK_REG_ADDR 0x114f0048 +#define SENSOR_I2C_REG_CFG 0x403 + +static int32_t ReadLsm303RawData(struct SensorCfgData *data, struct MagneticData *rawData, int64_t *timestamp) +{ + uint8_t status = 0; + uint8_t reg[MAGNETIC_AXIS_BUTT]; + OsalTimespec time; + + (void)memset_s(&time, sizeof(time), 0, sizeof(time)); + (void)memset_s(reg, sizeof(reg), 0, sizeof(reg)); + + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + + if (OsalGetTime(&time) != HDF_SUCCESS) { + HDF_LOGE("%s: Get time failed", __func__); + return HDF_FAILURE; + } + *timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * SENSOR_CONVERT_UNIT; /* unit nanosecond */ + + int32_t ret = ReadSensor(&data->busCfg, LSM303_STATUS_ADDR, &status, sizeof(uint8_t)); + if (!(status & LSM303_DATA_READY_MASK) || (ret != HDF_SUCCESS)) { + HDF_LOGE("%s: data status [%u] ret [%d]", __func__, status, ret); + + return HDF_FAILURE; + } + + ret = ReadSensor(&data->busCfg, LSM303_MAGNETIC_X_MSB_ADDR, ®[MAGNETIC_X_AXIS_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, LSM303_MAGNETIC_X_LSB_ADDR, ®[MAGNETIC_X_AXIS_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, LSM303_MAGNETIC_Y_MSB_ADDR, ®[MAGNETIC_Y_AXIS_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, LSM303_MAGNETIC_Y_LSB_ADDR, ®[MAGNETIC_Y_AXIS_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, LSM303_MAGNETIC_Z_MSB_ADDR, ®[MAGNETIC_Z_AXIS_MSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + ret = ReadSensor(&data->busCfg, LSM303_MAGNETIC_Z_LSB_ADDR, ®[MAGNETIC_Z_AXIS_LSB], sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + rawData->x = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[MAGNETIC_X_AXIS_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[MAGNETIC_X_AXIS_LSB]); + rawData->y = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[MAGNETIC_Y_AXIS_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[MAGNETIC_Y_AXIS_LSB]); + rawData->z = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[MAGNETIC_Z_AXIS_MSB], SENSOR_DATA_WIDTH_8_BIT) | + reg[MAGNETIC_Z_AXIS_LSB]); + + return HDF_SUCCESS; +} + +int32_t ReadLsm303Data(struct SensorCfgData *data) +{ + struct MagneticData rawData = { 0, 0, 0 }; + int32_t tmp[MAGNETIC_AXIS_NUM]; + struct SensorReportEvent event; + + (void)memset_s(&event, sizeof(event), 0, sizeof(event)); + (void)memset_s(tmp, sizeof(tmp), 0, sizeof(tmp)); + + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + + int32_t ret = ReadLsm303RawData(data, &rawData, &event.timestamp); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: LSM303 read raw data failed", __func__); + + return HDF_FAILURE; + } + + event.sensorId = SENSOR_TAG_MAGNETIC_FIELD; + event.option = 0; + event.mode = SENSOR_WORK_MODE_REALTIME; + + tmp[MAGNETIC_X_AXIS] = rawData.x * LSM303_MAGNETIC_GIN / LSM303DLHC_SENSITIVITY_XY47GA; + tmp[MAGNETIC_Y_AXIS] = rawData.y * LSM303_MAGNETIC_GIN / LSM303DLHC_SENSITIVITY_XY47GA; + tmp[MAGNETIC_Z_AXIS] = rawData.z * LSM303_MAGNETIC_GIN / LSM303DLHC_SENSITIVITY_Z47GA; + + ret = SensorRawDataToRemapData(data->direction, tmp, sizeof(tmp) / sizeof(tmp[0])); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: LSM303 convert raw data failed", __func__); + return HDF_FAILURE; + } + + event.dataLen = sizeof(tmp); + event.data = (uint8_t *)&tmp; + ret = ReportSensorEvent(&event); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: LSM303 report data failed", __func__); + } + + return ret; +} + +static int32_t InitLsm303(struct SensorCfgData *data) +{ + int32_t ret; + + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + + ret = SetSensorRegCfgArray(&data->busCfg, data->regCfgGroup[SENSOR_INIT_GROUP]); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Lsm303 sensor init config failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t InitMagneticPreConfig(void) +{ + if (SetSensorPinMux(SENSOR_I2C6_DATA_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_I2C_REG_CFG) != HDF_SUCCESS) { + HDF_LOGE("%s: Data write mux pin failed", __func__); + return HDF_FAILURE; + } + if (SetSensorPinMux(SENSOR_I2C6_CLK_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_I2C_REG_CFG) != HDF_SUCCESS) { + HDF_LOGE("%s: Clk write mux pin failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t DispatchLsm303(struct HdfDeviceIoClient *client, + int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)client; + (void)cmd; + (void)data; + (void)reply; + + return HDF_SUCCESS; +} + +int32_t Lsm303BindDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + + struct Lsm303DrvData *drvData = (struct Lsm303DrvData *)OsalMemCalloc(sizeof(*drvData)); + if (drvData == NULL) { + HDF_LOGE("%s: Malloc Lsm303 drv data fail", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + drvData->ioService.Dispatch = DispatchLsm303; + drvData->device = device; + device->service = &drvData->ioService; + g_lsm303DrvData = drvData; + + return HDF_SUCCESS; +} + +int32_t Lsm303InitDriver(struct HdfDeviceObject *device) +{ + int32_t ret; + struct MagneticOpsCall ops; + + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + struct Lsm303DrvData *drvData = (struct Lsm303DrvData *)device->service; + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + ret = InitMagneticPreConfig(); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Init Lsm303 bus mux config", __func__); + return HDF_FAILURE; + } + + drvData->sensorCfg = MagneticCreateCfgData(device->property); + if (drvData->sensorCfg == NULL || drvData->sensorCfg->root == NULL) { + HDF_LOGD("%s: Creating magneticcfg failed because detection failed", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + ops.Init = NULL; + ops.ReadData = ReadLsm303Data; + ret = MagneticRegisterChipOps(&ops); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Register lsm303 magnetic failed", __func__); + return HDF_FAILURE; + } + + ret = InitLsm303(drvData->sensorCfg); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Init lsm303 magnetic failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +void Lsm303ReleaseDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN(device); + + struct Lsm303DrvData *drvData = (struct Lsm303DrvData *)device->service; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->sensorCfg != NULL) { + MagneticReleaseCfgData(drvData->sensorCfg); + drvData->sensorCfg = NULL; + } + OsalMemFree(drvData); +} + +struct HdfDriverEntry g_magneticLsm303DevEntry = { + .moduleVersion = 1, + .moduleName = "HDF_SENSOR_MAGNETIC_LSM303", + .Bind = Lsm303BindDriver, + .Init = Lsm303InitDriver, + .Release = Lsm303ReleaseDriver, +}; + +HDF_INIT(g_magneticLsm303DevEntry); \ No newline at end of file diff --git a/model/sensor/driver/chipset/magnetic/magnetic_lsm303.h b/model/sensor/driver/chipset/magnetic/magnetic_lsm303.h new file mode 100755 index 0000000000000000000000000000000000000000..6d20e19682b738632ac268446b19dbed5f2f551d --- /dev/null +++ b/model/sensor/driver/chipset/magnetic/magnetic_lsm303.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 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 MAGNETIC_LSM303_H +#define MAGNETIC_LSM303_H + +#include "sensor_config_parser.h" +#include "sensor_magnetic_driver.h" + +#define LSM303_MAGNETIC_GIN 1000 + +/* MAGNETIC SET RATE AND MODE ADDR */ +#define LSM303_CRA_REG_ADDR 0X00 +#define LSM303_CRB_REG_ADDR 0X01 +#define LSM303_MR_REG_ADDR 0X02 + +/* MAGNETIC DATA REGISTERS ADDR */ +#define LSM303_MAGNETIC_X_MSB_ADDR 0X03 +#define LSM303_MAGNETIC_X_LSB_ADDR 0X04 +#define LSM303_MAGNETIC_Y_MSB_ADDR 0X05 +#define LSM303_MAGNETIC_Y_LSB_ADDR 0X06 +#define LSM303_MAGNETIC_Z_MSB_ADDR 0X07 +#define LSM303_MAGNETIC_Z_LSB_ADDR 0X08 +#define LSM303_STATUS_ADDR 0X09 + +/* MAGNETIC DATA RATE CONFIG HZ */ +#define LSM303_DATA_RATE_0 0X00 +#define LSM303_DATA_RATE_1 0X04 +#define LSM303_DATA_RATE_2 0X08 +#define LSM303_DATA_RATE_3 0X0C +#define LSM303_DATA_RATE_4 0X10 +#define LSM303_DATA_RATE_5 0X14 +#define LSM303_DATA_RATE_6 0X18 +#define LSM303_DATA_RATE_7 0X1C + +/* MAGNETIC GAIN CONFIG GAUSS */ +#define LSM303_GAIN_RATE_0 0X20 +#define LSM303_GAIN_RATE_1 0X40 +#define LSM303_GAIN_RATE_2 0X60 +#define LSM303_GAIN_RATE_3 0X80 +#define LSM303_GAIN_RATE_4 0XA0 +#define LSM303_GAIN_RATE_5 0XC0 +#define LSM303_GAIN_RATE_6 0XE0 + +/* MAGNETIC GAIN SENSITIVITY RANGE */ +#define LSM303DLHC_SENSITIVITY_XY13GA 1100 +#define LSM303DLHC_SENSITIVITY_XY19GA 855 +#define LSM303DLHC_SENSITIVITY_XY25GA 670 +#define LSM303DLHC_SENSITIVITY_XY40GA 450 +#define LSM303DLHC_SENSITIVITY_XY47GA 400 +#define LSM303DLHC_SENSITIVITY_XY56GA 330 +#define LSM303DLHC_SENSITIVITY_XY81GA 230 +#define LSM303DLHC_SENSITIVITY_Z13GA 980 +#define LSM303DLHC_SENSITIVITY_Z19GA 760 +#define LSM303DLHC_SENSITIVITY_Z25GA 600 +#define LSM303DLHC_SENSITIVITY_Z40GA 400 +#define LSM303DLHC_SENSITIVITY_Z47GA 355 +#define LSM303DLHC_SENSITIVITY_Z56GA 295 +#define LSM303DLHC_SENSITIVITY_Z81GA 205 + +/* MAGNETIC MODE CONFIG */ +#define LSM303_OPERATING_MODE_1 0X00 +#define LSM303_OPERATING_MODE_2 0X01 +#define LSM303_OPERATING_MODE_3 0X02 +#define LSM303_OPERATING_MODE_4 0X03 + +/* MAGNETIC DATA READY */ +#define LSM303_DATA_READY_MASK 0x01 + +int32_t DetectMagneticLsm303Chip(struct SensorCfgData *data); +int32_t ReadLsm303Data(struct SensorCfgData *data); + +struct Lsm303DrvData { + struct IDeviceIoService ioService; + struct HdfDeviceObject *device; + struct SensorCfgData *sensorCfg; +}; + +#endif /* MAGNETIC_LSM303_H */ \ No newline at end of file diff --git a/model/sensor/driver/chipset/proximity/proximity_apds9960.c b/model/sensor/driver/chipset/proximity/proximity_apds9960.c new file mode 100644 index 0000000000000000000000000000000000000000..d3eb9598cca18d72c1dd33e14f9a9cfbe7fd55c8 --- /dev/null +++ b/model/sensor/driver/chipset/proximity/proximity_apds9960.c @@ -0,0 +1,205 @@ +/* + * Copyright (c) 2021 xu + * + * 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 "proximity_apds9960.h" +#include +#include "osal_mem.h" +#include "osal_time.h" +#include "sensor_config_controller.h" +#include "sensor_device_manager.h" +#include "sensor_proximity_driver.h" + +#define HDF_LOG_TAG proximity_apds9960_c + +#define PROXIMITY_STATE_FAR 5 +#define PROXIMITY_STATE_NEAR 0 + +static struct Apds9960DrvData *g_apds9960DrvData = NULL; + +struct Apds9960DrvData *Apds9960GetDrvData(void) +{ + return g_apds9960DrvData; +} + +/* IO config for int-pin and I2C-pin */ +#define SENSOR_I2C6_DATA_REG_ADDR 0x114f004c +#define SENSOR_I2C6_CLK_REG_ADDR 0x114f0048 +#define SENSOR_I2C_REG_CFG 0x403 + +static int32_t ReadApds9960RawData(struct SensorCfgData *data, struct ProximityData *rawData, int64_t *timestamp) +{ + OsalTimespec time; + + (void)memset_s(&time, sizeof(time), 0, sizeof(time)); + + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + + if (OsalGetTime(&time) != HDF_SUCCESS) { + HDF_LOGE("%s: Get time failed", __func__); + return HDF_FAILURE; + } + *timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * SENSOR_CONVERT_UNIT; /* unit nanosecond */ + + int32_t ret = ReadSensor(&data->busCfg, APDS9960_PROXIMITY_DATA_ADDR, &rawData->stateFlag, sizeof(uint8_t)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read data"); + + return ret; +} + +int32_t ReadApds9960Data(struct SensorCfgData *data) +{ + int32_t ret; + int32_t tmp; + struct ProximityData rawData = { 5 }; + struct SensorReportEvent event; + + (void)memset_s(&event, sizeof(event), 0, sizeof(event)); + + ret = ReadApds9960RawData(data, &rawData, &event.timestamp); + if (ret != HDF_SUCCESS) { + return HDF_FAILURE; + } + + event.sensorId = SENSOR_TAG_PROXIMITY; + event.option = 0; + event.mode = SENSOR_WORK_MODE_ON_CHANGE; + + if (rawData.stateFlag <= APDS9960_PROXIMITY_THRESHOLD) { + tmp = PROXIMITY_STATE_FAR; + } else { + tmp = PROXIMITY_STATE_NEAR; + } + + event.dataLen = sizeof(tmp); + event.data = (uint8_t *)&tmp; + ret = ReportSensorEvent(&event); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: APDS9960 report data failed", __func__); + } + + return ret; +} + +static int32_t InitApda9960(struct SensorCfgData *data) +{ + int32_t ret; + + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + ret = SetSensorRegCfgArray(&data->busCfg, data->regCfgGroup[SENSOR_INIT_GROUP]); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: APDS9960 sensor init config failed", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static int32_t InitProximityPreConfig(void) +{ + if (SetSensorPinMux(SENSOR_I2C6_DATA_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_I2C_REG_CFG) != HDF_SUCCESS) { + HDF_LOGE("%s: Data write mux pin failed", __func__); + return HDF_FAILURE; + } + if (SetSensorPinMux(SENSOR_I2C6_CLK_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_I2C_REG_CFG) != HDF_SUCCESS) { + HDF_LOGE("%s: Clk write mux pin failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t DispatchApds9960(struct HdfDeviceIoClient *client, + int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)client; + (void)cmd; + (void)data; + (void)reply; + + return HDF_SUCCESS; +} + +int32_t Apds9960BindDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + + struct Apds9960DrvData *drvData = (struct Apds9960DrvData *)OsalMemCalloc(sizeof(*drvData)); + if (drvData == NULL) { + HDF_LOGE("%s: Malloc Apds9960 drv data fail", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + drvData->ioService.Dispatch = DispatchApds9960; + drvData->device = device; + device->service = &drvData->ioService; + g_apds9960DrvData = drvData; + + return HDF_SUCCESS; +} + +int32_t Apds996InitDriver(struct HdfDeviceObject *device) +{ + int32_t ret; + struct ProximityOpsCall ops; + + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + struct Apds9960DrvData *drvData = (struct Apds9960DrvData *)device->service; + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + ret = InitProximityPreConfig(); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Init APDS9960 bus mux config", __func__); + return HDF_FAILURE; + } + + drvData->sensorCfg = ProximityCreateCfgData(device->property); + if (drvData->sensorCfg == NULL || drvData->sensorCfg->root == NULL) { + HDF_LOGD("%s: Creating proximitycfg failed because detection failed", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + ops.Init = NULL; + ops.ReadData = ReadApds9960Data; + ret = ProximityRegisterChipOps(&ops); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Register APDS9960 proximity failed", __func__); + return HDF_FAILURE; + } + + ret = InitApda9960(drvData->sensorCfg); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Init APDS9960 proximity failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + + +void Apds996ReleaseDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN(device); + + struct Apds9960DrvData *drvData = (struct Apds9960DrvData *)device->service; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->sensorCfg != NULL) { + ProximityReleaseCfgData(drvData->sensorCfg); + drvData->sensorCfg = NULL; + } + OsalMemFree(drvData); +} + +struct HdfDriverEntry g_proximityApds9960DevEntry = { + .moduleVersion = 1, + .moduleName = "HDF_SENSOR_PROXIMITY_APDS9960", + .Bind = Apds9960BindDriver, + .Init = Apds996InitDriver, + .Release = Apds996ReleaseDriver, +}; + +HDF_INIT(g_proximityApds9960DevEntry); \ No newline at end of file diff --git a/model/sensor/driver/chipset/proximity/proximity_apds9960.h b/model/sensor/driver/chipset/proximity/proximity_apds9960.h new file mode 100644 index 0000000000000000000000000000000000000000..d1c1eece5bb4f9168a7006dd0bde6fb1b816902d --- /dev/null +++ b/model/sensor/driver/chipset/proximity/proximity_apds9960.h @@ -0,0 +1,28 @@ +/* + * Copyright (c) 2021 xu + * + * 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 PROXIMITY_APDS9960_H +#define PROXIMITY_APDS9960_H + +#include "sensor_config_parser.h" +#include "sensor_proximity_driver.h" + +#define APDS9960_PROXIMITY_DATA_ADDR 0X9C // Proximity Data + +#define APDS9960_PROXIMITY_THRESHOLD 7 // threshold + +int32_t DetectProximityApds9960Chip(struct SensorCfgData *data); +int32_t ReadApds9960Data(struct SensorCfgData *data); + +struct Apds9960DrvData { + struct IDeviceIoService ioService; + struct HdfDeviceObject *device; + struct SensorCfgData *sensorCfg; +}; + +#endif /* PROXIMITY_APDS9960_H */ \ No newline at end of file diff --git a/model/sensor/driver/common/include/sensor_config_controller.h b/model/sensor/driver/common/include/sensor_config_controller.h index 9521f7dc5f53391f3da72752b108145ab546a2dd..07165e1971516ba10c63682c25c1d696bc5eaaf1 100644 --- a/model/sensor/driver/common/include/sensor_config_controller.h +++ b/model/sensor/driver/common/include/sensor_config_controller.h @@ -11,6 +11,8 @@ #include "sensor_config_parser.h" +#define LENGTH_NUMBER 32 + enum SensorCalculateType { SENSOR_CFG_CALC_TYPE_NONE = 0, SENSOR_CFG_CALC_TYPE_SET = 1, // To Support:1.Bitwise AND "&" 2.Bitwise OR "|" @@ -26,6 +28,8 @@ enum SensorOpsType { SENSOR_OPS_TYPE_WRITE = 2, SENSOR_OPS_TYPE_READ_CHECK = 3, SENSOR_OPS_TYPE_UPDATE_BITWISE = 4, + SENSOR_OPS_TYPE_EXTBUFF_READ = 5, + SENSOR_OPS_TYPE_EXTBUFF_WRITE = 6, }; struct SensorOpsCall { @@ -34,5 +38,10 @@ struct SensorOpsCall { }; int32_t SetSensorRegCfgArray(struct SensorBusCfg *busCfg, const struct SensorRegCfgGroupNode *group); - -#endif /* SENSOR_CONFIG_CONTROLLER_H */ +int32_t SetSensorRegCfgArrayByBuff(struct SensorBusCfg *busCfg, const struct SensorRegCfgGroupNode *group, + uint8_t *buff, int16_t len); +int32_t ReadSensorRegCfgArray(struct SensorBusCfg *busCfg, const struct SensorRegCfgGroupNode *group, + int32_t index, uint8_t *buf, int32_t len); +int32_t WriteSensorRegCfgArray(struct SensorBusCfg *busCfg, const struct SensorRegCfgGroupNode *group, + int32_t index, int32_t len); +#endif /* SENSOR_CONFIG_CONTROLLER_H */ \ No newline at end of file diff --git a/model/sensor/driver/common/include/sensor_config_parser.h b/model/sensor/driver/common/include/sensor_config_parser.h index 27ff0b1c4a06531e3cb7a2fb0b84fd5a8aebe84e..127add386296cadcd6cb37d66fb931848aff2ec7 100644 --- a/model/sensor/driver/common/include/sensor_config_parser.h +++ b/model/sensor/driver/common/include/sensor_config_parser.h @@ -17,6 +17,8 @@ #include "spi_if.h" #define SENSOR_CONFIG_MAX_ITEM 100 +#define MAX_SENSOR_INDEX_NUM 48 +#define MAX_SENSOR_AXIS_NUM 3 enum SensorRegOpsType { SENSOR_INIT_GROUP = 0, @@ -47,7 +49,10 @@ enum SensorRegCfgIndex { struct SensorRegCfg { uint16_t regAddr; - uint16_t value; + union { + uint16_t value; + uint8_t *buff; + }; uint16_t mask; uint16_t len; uint32_t delay : 12; @@ -63,12 +68,35 @@ struct SensorRegCfgGroupNode { struct SensorRegCfg *regCfgItem; }; +struct SensorDirection { + uint32_t sign[MAX_SENSOR_AXIS_NUM]; + uint32_t map[MAX_SENSOR_AXIS_NUM]; +}; + +enum SensorDirectionIndex { + SIGN_X_INDEX = 0, + SIGN_Y_INDEX, + SIGN_Z_INDEX, + AXIS_X_INDEX, + AXIS_Y_INDEX, + AXIS_Z_INDEX, + AXIS_INDEX_MAX, +}; + +enum AxisNum { + AXIS_X = 0, + AXIS_Y = 1, + AXIS_Z = 2, +}; + struct SensorCfgData { struct SensorBusCfg busCfg; struct SensorBasicInfo sensorInfo; struct SensorAttr sensorAttr; struct SensorRegCfgGroupNode **regCfgGroup; + struct SensorRegCfgGroupNode **extendedRegCfgGroup; const struct DeviceResourceNode *root; + struct SensorDirection *direction; }; int32_t GetSensorBaseConfigData(const struct DeviceResourceNode *node, struct SensorCfgData *config); @@ -77,5 +105,10 @@ void ReleaseSensorAllRegConfig(struct SensorCfgData *config); int32_t GetSensorBusHandle(struct SensorBusCfg *busCfg); int32_t ReleaseSensorBusHandle(struct SensorBusCfg *busCfg); int32_t DetectSensorDevice(struct SensorCfgData *config); +int32_t SensorRawDataToRemapData(struct SensorDirection *direction, int32_t *remapData, uint32_t num); +void ReleaseSensorDirectionConfig(struct SensorCfgData *config); +int32_t ParseSensorDirection(struct SensorCfgData *config); +int32_t ParseSensorRegGroup(struct DeviceResourceIface *parser, const struct DeviceResourceNode *regCfgNode, + const char *groupName, struct SensorRegCfgGroupNode **groupNode); #endif /* SENSOR_CONFIG_PARSER_H */ diff --git a/model/sensor/driver/common/src/sensor_config_controller.c b/model/sensor/driver/common/src/sensor_config_controller.c index d0e7c07f8f0e4e065391b5e45e3f9996aef961ad..c70b641a7609e5499fcd2aea19a4ea87753c5864 100644 --- a/model/sensor/driver/common/src/sensor_config_controller.c +++ b/model/sensor/driver/common/src/sensor_config_controller.c @@ -52,25 +52,20 @@ static uint32_t GetSensorRegRealValueMask(struct SensorRegCfg *cfgItem, uint32_t static int32_t SensorOpsWrite(struct SensorBusCfg *busCfg, struct SensorRegCfg *cfgItem) { - uint8_t calType = cfgItem->calType; uint8_t value[SENSOR_VALUE_BUTT]; - int32_t ret = HDF_FAILURE; + int32_t ret; + uint32_t originValue; + uint32_t busMask; + uint32_t mask; + + busMask = (busCfg->i2cCfg.regWidth == SENSOR_ADDR_WIDTH_1_BYTE) ? 0x00ff : 0xffff; + mask = GetSensorRegRealValueMask(cfgItem, &originValue, busMask); value[SENSOR_ADDR_INDEX] = cfgItem->regAddr; - value[SENSOR_VALUE_INDEX] = cfgItem->value; + value[SENSOR_VALUE_INDEX] = originValue & mask; - switch (calType) { - case SENSOR_CFG_CALC_TYPE_NONE: - ret = WriteSensor(busCfg, value, sizeof(value)); - break; - case SENSOR_CFG_CALC_TYPE_SET: - case SENSOR_CFG_CALC_TYPE_REVERT: - case SENSOR_CFG_CALC_TYPE_XOR: - case SENSOR_CFG_CALC_TYPE_LEFT_SHIFT: - case SENSOR_CFG_CALC_TYPE_RIGHT_SHIFT: - default: - break; - } + ret = WriteSensor(busCfg, value, sizeof(value)); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "write i2c reg"); return ret; } @@ -106,8 +101,9 @@ static int32_t SensorBitwiseCalculate(struct SensorRegCfg *cfgItem, uint32_t *va uint32_t tmp; mask = GetSensorRegRealValueMask(cfgItem, &originValue, valueMask); - switch ((enum SensorCalculateType)cfgItem->calType) - { + switch ((enum SensorCalculateType)cfgItem->calType) { + case SENSOR_CFG_CALC_TYPE_NONE: + break; case SENSOR_CFG_CALC_TYPE_SET: *value &= ~mask; *value |= (originValue & mask); @@ -117,10 +113,18 @@ static int32_t SensorBitwiseCalculate(struct SensorRegCfg *cfgItem, uint32_t *va *value = ~(*value & mask); *value = tmp | (*value & mask); break; + case SENSOR_CFG_CALC_TYPE_XOR: + tmp = *value & (~mask); + originValue = originValue & mask; + *value = *value & mask; + *value ^= originValue; + *value = tmp | (*value); + break; default: HDF_LOGE("%s: unsupported cal type", __func__); break; } + return 0; } @@ -151,12 +155,63 @@ static int32_t SensorOpsUpdateBitwise(struct SensorBusCfg *busCfg, struct Sensor return HDF_SUCCESS; } +static int32_t SensorOpsExtBuffRead(struct SensorBusCfg *busCfg, struct SensorRegCfg *cfgItem) +{ + int32_t ret; + + CHECK_NULL_PTR_RETURN_VALUE(busCfg, HDF_FAILURE); + CHECK_NULL_PTR_RETURN_VALUE(cfgItem, HDF_FAILURE); + CHECK_NULL_PTR_RETURN_VALUE(cfgItem->buff, HDF_FAILURE); + + if (busCfg->busType == SENSOR_BUS_I2C) { + ret = ReadSensor(busCfg, cfgItem->regAddr, cfgItem->buff, cfgItem->len); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read i2c reg"); + } + + return HDF_SUCCESS; +} + +static int32_t SensorOpsExtBuffWrite(struct SensorBusCfg *busCfg, struct SensorRegCfg *cfgItem) +{ + int32_t ret; + uint8_t *value = NULL; + + CHECK_NULL_PTR_RETURN_VALUE(busCfg, HDF_FAILURE); + CHECK_NULL_PTR_RETURN_VALUE(cfgItem, HDF_FAILURE); + + if (cfgItem->len > LENGTH_NUMBER) { + return HDF_FAILURE; + } + value = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * (cfgItem->len + 1)); + CHECK_NULL_PTR_RETURN_VALUE(value, HDF_FAILURE); + + value[SENSOR_ADDR_INDEX] = cfgItem->regAddr; + if (memcpy_s(&value[SENSOR_VALUE_INDEX], cfgItem->len, cfgItem->buff, cfgItem->len) != EOK) { + HDF_LOGE("%s: Cpy value failed", __func__); + OsalMemFree(value); + return HDF_FAILURE; + } + + if (busCfg->busType == SENSOR_BUS_I2C) { + ret = WriteSensor(busCfg, value, cfgItem->len); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: write ext register failed", __func__); + OsalMemFree(value); + return HDF_FAILURE; + } + } + OsalMemFree(value); + return HDF_SUCCESS; +} + static struct SensorOpsCall g_doOpsCall[] = { { SENSOR_OPS_TYPE_NOP, SensorOpsNop }, { SENSOR_OPS_TYPE_READ, SensorOpsRead }, { SENSOR_OPS_TYPE_WRITE, SensorOpsWrite }, { SENSOR_OPS_TYPE_READ_CHECK, SensorOpsReadCheck }, { SENSOR_OPS_TYPE_UPDATE_BITWISE, SensorOpsUpdateBitwise }, + { SENSOR_OPS_TYPE_EXTBUFF_READ, SensorOpsExtBuffRead }, + { SENSOR_OPS_TYPE_EXTBUFF_WRITE, SensorOpsExtBuffWrite }, }; int32_t SetSensorRegCfgArray(struct SensorBusCfg *busCfg, const struct SensorRegCfgGroupNode *group) @@ -166,7 +221,12 @@ int32_t SetSensorRegCfgArray(struct SensorBusCfg *busCfg, const struct SensorReg struct SensorRegCfg *cfgItem = NULL; CHECK_NULL_PTR_RETURN_VALUE(busCfg, HDF_FAILURE); - CHECK_NULL_PTR_RETURN_VALUE(group, HDF_FAILURE); + + if (group == NULL) { + HDF_LOGI("%s: Pointer group is null", __func__); + return HDF_SUCCESS; + } + CHECK_NULL_PTR_RETURN_VALUE(group->regCfgItem, HDF_FAILURE); count = sizeof(g_doOpsCall) / sizeof(g_doOpsCall[0]); @@ -177,7 +237,7 @@ int32_t SetSensorRegCfgArray(struct SensorBusCfg *busCfg, const struct SensorReg HDF_LOGE("%s: cfg item para invalid", __func__); break; } - if (g_doOpsCall[cfgItem->opsType].ops != NULL) { + if ((g_doOpsCall[cfgItem->opsType].ops != NULL) && (cfgItem->opsType <= SENSOR_OPS_TYPE_UPDATE_BITWISE)) { if (g_doOpsCall[cfgItem->opsType].ops(busCfg, cfgItem) != HDF_SUCCESS) { HDF_LOGE("%s: malloc sensor reg config item data failed", __func__); return HDF_FAILURE; @@ -191,3 +251,94 @@ int32_t SetSensorRegCfgArray(struct SensorBusCfg *busCfg, const struct SensorReg return HDF_SUCCESS; } + +int32_t SetSensorRegCfgArrayByBuff(struct SensorBusCfg *busCfg, const struct SensorRegCfgGroupNode *group, + uint8_t *buff, int16_t len) +{ + int32_t num = 0; + uint32_t count; + uint8_t buffOffset = 0; + struct SensorRegCfg *cfgItem = NULL; + + CHECK_NULL_PTR_RETURN_VALUE(busCfg, HDF_FAILURE); + CHECK_NULL_PTR_RETURN_VALUE(group, HDF_FAILURE); + CHECK_NULL_PTR_RETURN_VALUE(group->regCfgItem, HDF_FAILURE); + CHECK_NULL_PTR_RETURN_VALUE(buff, HDF_FAILURE); + + count = sizeof(g_doOpsCall) / sizeof(g_doOpsCall[0]); + + while (num < group->itemNum) { + cfgItem = (group->regCfgItem + num); + if (cfgItem->opsType >= count) { + HDF_LOGE("%s: cfg item para invalid", __func__); + return HDF_FAILURE; + } + + if ((g_doOpsCall[cfgItem->opsType].ops != NULL) && (cfgItem->opsType >= SENSOR_OPS_TYPE_EXTBUFF_READ)) { + cfgItem->buff = buff + buffOffset; + len -= (int16_t)cfgItem->len; + if (len < 0) { + HDF_LOGE("%s: cfg item para invalid", __func__); + return HDF_FAILURE; + } + if (g_doOpsCall[cfgItem->opsType].ops(busCfg, cfgItem) != HDF_SUCCESS) { + HDF_LOGE("%s: extbuff is read and write failed", __func__); + return HDF_FAILURE; + } + buffOffset += cfgItem->len; + if (cfgItem->delay != 0) { + OsalMDelay(cfgItem->delay); + } + } + + num++; + } + + return HDF_SUCCESS; +} + +int32_t ReadSensorRegCfgArray(struct SensorBusCfg *busCfg, const struct SensorRegCfgGroupNode *group, + int32_t index, uint8_t *buf, int32_t len) +{ + int32_t ret; + struct SensorRegCfg *cfgItem = NULL; + + CHECK_NULL_PTR_RETURN_VALUE(busCfg, HDF_FAILURE); + CHECK_NULL_PTR_RETURN_VALUE(group, HDF_FAILURE); + CHECK_NULL_PTR_RETURN_VALUE(group->regCfgItem, HDF_FAILURE); + + if ((index >= group->itemNum) || index < 0) { + HDF_LOGE("%s: Index is invalid parameter", __func__); + return HDF_FAILURE; + } + + cfgItem = group->regCfgItem + index; + len = (cfgItem->len > len) ? len : cfgItem->len; + + ret = ReadSensor(busCfg, cfgItem->regAddr, buf, len); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "read i2c reg"); + + return HDF_SUCCESS; +} + +int32_t WriteSensorRegCfgArray(struct SensorBusCfg *busCfg, const struct SensorRegCfgGroupNode *group, + int32_t index, int32_t len) +{ + struct SensorRegCfg *cfgItem = NULL; + + CHECK_NULL_PTR_RETURN_VALUE(busCfg, HDF_FAILURE); + CHECK_NULL_PTR_RETURN_VALUE(group, HDF_FAILURE); + CHECK_NULL_PTR_RETURN_VALUE(group->regCfgItem, HDF_FAILURE); + + if ((index >= group->itemNum) || index < 0) { + HDF_LOGE("%s: Index is invalid parameter", __func__); + return HDF_FAILURE; + } + + cfgItem = group->regCfgItem + index; + + int32_t ret = SensorOpsUpdateBitwise(busCfg, cfgItem); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "Write i2c reg"); + + return HDF_SUCCESS; +} \ No newline at end of file diff --git a/model/sensor/driver/common/src/sensor_config_parser.c b/model/sensor/driver/common/src/sensor_config_parser.c index 31efd2f1361ca2ec98d21c19a5ead6f01489f73a..a5c52e0bdd58e6bf1cd8dd2e72ae6f04c496247f 100644 --- a/model/sensor/driver/common/src/sensor_config_parser.c +++ b/model/sensor/driver/common/src/sensor_config_parser.c @@ -63,18 +63,20 @@ static int32_t ParseSensorRegItem(struct DeviceResourceIface *parser, const stru int32_t ret; int32_t step; int32_t index; + int32_t num; int32_t itemNum = group->itemNum; + uint16_t *buf = NULL; CHECK_NULL_PTR_RETURN_VALUE(group->regCfgItem, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(groupName, HDF_ERR_INVALID_PARAM); - int32_t num = parser->GetElemNum(regNode, groupName); + num = parser->GetElemNum(regNode, groupName); if (num <= 0 || num > SENSOR_CONFIG_MAX_ITEM) { HDF_LOGE("%s: parser %s element num failed", __func__, groupName); return HDF_SUCCESS; } - uint16_t *buf = (uint16_t *)OsalMemCalloc(sizeof(uint16_t) * num); + buf = (uint16_t *)OsalMemCalloc(sizeof(uint16_t) * num); CHECK_NULL_PTR_RETURN_VALUE(buf, HDF_ERR_MALLOC_FAIL); ret = parser->GetUint16Array(regNode, groupName, buf, num, 0); @@ -105,9 +107,10 @@ static int32_t ParseSensorRegItem(struct DeviceResourceIface *parser, const stru return HDF_SUCCESS; } -static int32_t ParseSensorRegGroup(struct DeviceResourceIface *parser, const struct DeviceResourceNode *regCfgNode, +int32_t ParseSensorRegGroup(struct DeviceResourceIface *parser, const struct DeviceResourceNode *regCfgNode, const char *groupName, struct SensorRegCfgGroupNode **groupNode) { + int32_t num; struct SensorRegCfgGroupNode *group = NULL; CHECK_NULL_PTR_RETURN_VALUE(parser, HDF_ERR_INVALID_PARAM); @@ -115,7 +118,7 @@ static int32_t ParseSensorRegGroup(struct DeviceResourceIface *parser, const str CHECK_NULL_PTR_RETURN_VALUE(groupName, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(groupNode, HDF_ERR_INVALID_PARAM); - int32_t num = parser->GetElemNum(regCfgNode, groupName); + num = parser->GetElemNum(regCfgNode, groupName); group = *groupNode; if (num > 0) { @@ -246,13 +249,14 @@ int32_t DetectSensorDevice(struct SensorCfgData *config) uint8_t value = 0; uint16_t chipIdReg; uint16_t chipIdValue; + int32_t ret; CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); chipIdReg = config->sensorAttr.chipIdReg; chipIdValue = config->sensorAttr.chipIdValue; - int32_t ret = GetSensorBusHandle(&config->busCfg); + ret = GetSensorBusHandle(&config->busCfg); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: get sensor bus handle failed", __func__); (void)ReleaseSensorBusHandle(&config->busCfg); @@ -280,6 +284,8 @@ static int32_t ParseSensorInfo(struct DeviceResourceIface *parser, const struct struct SensorCfgData *config) { int32_t ret; + uint16_t id; + int32_t value; const char *name = NULL; ret = parser->GetString(infoNode, "sensorName", &name, NULL); @@ -310,7 +316,6 @@ static int32_t ParseSensorInfo(struct DeviceResourceIface *parser, const struct return HDF_FAILURE; } - uint16_t id; ret = parser->GetUint16(infoNode, "sensorTypeId", &id, 0); CHECK_PARSER_RESULT_RETURN_VALUE(ret, "sensorTypeId"); config->sensorInfo.sensorTypeId = id; @@ -318,7 +323,6 @@ static int32_t ParseSensorInfo(struct DeviceResourceIface *parser, const struct CHECK_PARSER_RESULT_RETURN_VALUE(ret, "sensorId"); config->sensorInfo.sensorId = id; - int32_t value; ret = parser->GetUint32(infoNode, "maxRange", (uint32_t *)&value, 0); CHECK_PARSER_RESULT_RETURN_VALUE(ret, "maxRange"); config->sensorInfo.maxRange = value; @@ -354,6 +358,11 @@ static int32_t ParseSensorBus(struct DeviceResourceIface *parser, const struct D CHECK_PARSER_RESULT_RETURN_VALUE(ret, "busNum"); ret = parser->GetUint32(busNode, "busAddr", &config->busCfg.spiCfg.csNum, 0); CHECK_PARSER_RESULT_RETURN_VALUE(ret, "busAddr"); + } else if (config->busCfg.busType == SENSOR_BUS_GPIO) { + ret = parser->GetUint32(busNode, "gpioIrq1", &config->busCfg.GpioNum[SENSOR_GPIO_NUM1], 0); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "gpioIrq1"); + ret = parser->GetUint32(busNode, "gpioIrq2", &config->busCfg.GpioNum[SENSOR_GPIO_NUM2], 0); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "gpioIrq2"); } return HDF_SUCCESS; @@ -373,10 +382,102 @@ static int32_t ParseSensorAttr(struct DeviceResourceIface *parser, const struct return ret; } +void ReleaseSensorDirectionConfig(struct SensorCfgData *config) +{ + CHECK_NULL_PTR_RETURN(config); + + if (config->direction != NULL) { + OsalMemFree(config->direction); + config->direction = NULL; + } +} + +int32_t ParseSensorDirection(struct SensorCfgData *config) +{ + int32_t num; + int32_t ret; + uint32_t index; + uint32_t *buf = NULL; + const struct DeviceResourceNode *directionNode = NULL; + struct DeviceResourceIface *parser = NULL; + + CHECK_NULL_PTR_RETURN_VALUE(config->root, HDF_ERR_INVALID_PARAM); + parser = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + CHECK_NULL_PTR_RETURN_VALUE(parser, HDF_ERR_INVALID_PARAM); + + directionNode = parser->GetChildNode(config->root, "sensorDirection"); + CHECK_NULL_PTR_RETURN_VALUE(directionNode, HDF_ERR_INVALID_PARAM); + + num = parser->GetElemNum(directionNode, "convert"); + ret = parser->GetUint32(directionNode, "direction", &index, 0); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "direction"); + if ((num <= 0 || num > MAX_SENSOR_INDEX_NUM) || (index < 0 || index > num / AXIS_INDEX_MAX)) { + return HDF_FAILURE; + } + + buf = (uint32_t *)OsalMemCalloc(sizeof(uint32_t) * num); + CHECK_NULL_PTR_RETURN_VALUE(buf, HDF_ERR_MALLOC_FAIL); + + ret = parser->GetUint32Array(directionNode, "convert", buf, num, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: parser %s convert failed", __func__, "convert"); + OsalMemFree(buf); + return HDF_FAILURE; + } + + config->direction = (struct SensorDirection*)OsalMemCalloc(sizeof(struct SensorDirection)); + if (config->direction == NULL) { + HDF_LOGE("%s: malloc sensor direction config item failed", __func__); + OsalMemFree(buf); + return HDF_ERR_MALLOC_FAIL; + } + + index = index * AXIS_INDEX_MAX; + config->direction->sign[AXIS_X] = buf[index + SIGN_X_INDEX]; + config->direction->sign[AXIS_Y] = buf[index + SIGN_Y_INDEX]; + config->direction->sign[AXIS_Z] = buf[index + SIGN_Z_INDEX]; + config->direction->map[AXIS_X] = buf[index + AXIS_X_INDEX]; + config->direction->map[AXIS_Y] = buf[index + AXIS_Y_INDEX]; + config->direction->map[AXIS_Z] = buf[index + AXIS_Z_INDEX]; + + OsalMemFree(buf); + return HDF_SUCCESS; +} + +int32_t SensorRawDataToRemapData(struct SensorDirection *direction, int32_t *remapData, uint32_t num) +{ + int32_t axis; + int32_t directionSign[MAX_SENSOR_AXIS_NUM]; + int32_t newData[MAX_SENSOR_AXIS_NUM]; + + CHECK_NULL_PTR_RETURN_VALUE(direction, HDF_ERR_INVALID_PARAM); + + for (axis = 0; axis < num; axis++) { + if (direction->sign[axis] == 0) { + directionSign[axis] = 1; + } else { + directionSign[axis] = -1; + } + } + + newData[direction->map[AXIS_X]] = directionSign[AXIS_X] * remapData[AXIS_X]; + newData[direction->map[AXIS_Y]] = directionSign[AXIS_Y] * remapData[AXIS_Y]; + newData[direction->map[AXIS_Z]] = directionSign[AXIS_Z] * remapData[AXIS_Z]; + + remapData[AXIS_X] = newData[direction->map[AXIS_X]]; + remapData[AXIS_Y] = newData[direction->map[AXIS_Y]]; + remapData[AXIS_Z] = newData[direction->map[AXIS_Z]]; + + return HDF_SUCCESS; +} + int32_t GetSensorBaseConfigData(const struct DeviceResourceNode *node, struct SensorCfgData *config) { int32_t ret; struct DeviceResourceIface *parser = NULL; + const struct DeviceResourceNode *infoNode = NULL; + const struct DeviceResourceNode *busNode = NULL; + const struct DeviceResourceNode *attrNode = NULL; CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); @@ -387,19 +488,19 @@ int32_t GetSensorBaseConfigData(const struct DeviceResourceNode *node, struct Se config->root = node; CHECK_NULL_PTR_RETURN_VALUE(parser->GetChildNode, HDF_ERR_INVALID_PARAM); - const struct DeviceResourceNode *infoNode = parser->GetChildNode(node, "sensorInfo"); + infoNode = parser->GetChildNode(node, "sensorInfo"); if (infoNode != NULL) { ret = ParseSensorInfo(parser, infoNode, config); CHECK_PARSER_RESULT_RETURN_VALUE(ret, "sensorInfo"); } - const struct DeviceResourceNode *busNode = parser->GetChildNode(node, "sensorBusConfig"); + busNode = parser->GetChildNode(node, "sensorBusConfig"); if (busNode != NULL) { ret = ParseSensorBus(parser, busNode, config); CHECK_PARSER_RESULT_RETURN_VALUE(ret, "sensorBusConfig"); } - const struct DeviceResourceNode *attrNode = parser->GetChildNode(node, "sensorIdAttr"); + attrNode = parser->GetChildNode(node, "sensorIdAttr"); if (attrNode != NULL) { ret = ParseSensorAttr(parser, attrNode, config); CHECK_PARSER_RESULT_RETURN_VALUE(ret, "sensorIdAttr"); diff --git a/model/sensor/driver/common/src/sensor_device_manager.c b/model/sensor/driver/common/src/sensor_device_manager.c index 8c3389392029b559e09845fdc80652cccd77b259..c38271e7a9a962aac6ccc66126ec970deedb23c9 100644 --- a/model/sensor/driver/common/src/sensor_device_manager.c +++ b/model/sensor/driver/common/src/sensor_device_manager.c @@ -88,14 +88,16 @@ int32_t DeleteSensorDevice(const struct SensorBasicInfo *sensorBaseInfo) int32_t ReportSensorEvent(const struct SensorReportEvent *events) { int32_t ret; + struct SensorDevMgrData *manager = NULL; + struct HdfSBuf *msg = NULL; CHECK_NULL_PTR_RETURN_VALUE(events, HDF_ERR_INVALID_PARAM); - struct SensorDevMgrData *manager = GetSensorDeviceManager(); + manager = GetSensorDeviceManager(); CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_ERR_INVALID_PARAM); (void)OsalMutexLock(&manager->eventMutex); - struct HdfSBuf *msg = HdfSBufObtain(HDF_SENSOR_EVENT_MAX_BUF); + msg = HdfSBufObtain(HDF_SENSOR_EVENT_MAX_BUF); if (msg == NULL) { (void)OsalMutexUnlock(&manager->eventMutex); return HDF_ERR_INVALID_PARAM; @@ -128,11 +130,14 @@ EXIT: static int32_t GetAllSensorInfo(struct HdfSBuf *data, struct HdfSBuf *reply) { - (void)data; + int32_t count = 0; struct SensorDevInfoNode *pos = NULL; struct SensorBasicInfo *sensorInfo = NULL; - struct SensorDevMgrData *manager = GetSensorDeviceManager(); - int32_t count = 0; + struct SensorDevMgrData *manager = NULL; + + (void)data; + + manager = GetSensorDeviceManager(); CHECK_NULL_PTR_RETURN_VALUE(reply, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_ERR_INVALID_PARAM); @@ -303,9 +308,11 @@ static int32_t DispatchSensor(struct HdfDeviceIoClient *client, int32_t BindSensorDevManager(struct HdfDeviceObject *device) { + struct SensorDevMgrData *manager = NULL; + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); - struct SensorDevMgrData *manager = (struct SensorDevMgrData *)OsalMemCalloc(sizeof(*manager)); + manager = (struct SensorDevMgrData *)OsalMemCalloc(sizeof(*manager)); if (manager == NULL) { HDF_LOGE("%s: malloc manager fail!", __func__); return HDF_ERR_MALLOC_FAIL; @@ -321,8 +328,10 @@ int32_t BindSensorDevManager(struct HdfDeviceObject *device) int32_t InitSensorDevManager(struct HdfDeviceObject *device) { + struct SensorDevMgrData *manager = NULL; + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); - struct SensorDevMgrData *manager = (struct SensorDevMgrData *)device->service; + manager = (struct SensorDevMgrData *)device->service; CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_ERR_INVALID_PARAM); DListHeadInit(&manager->sensorDevInfoHead); @@ -347,11 +356,13 @@ int32_t InitSensorDevManager(struct HdfDeviceObject *device) void ReleaseSensorDevManager(struct HdfDeviceObject *device) { - CHECK_NULL_PTR_RETURN(device); - struct SensorDevInfoNode *pos = NULL; struct SensorDevInfoNode *tmp = NULL; - struct SensorDevMgrData *manager = (struct SensorDevMgrData *)device->service; + struct SensorDevMgrData *manager = NULL; + + CHECK_NULL_PTR_RETURN(device); + + manager = (struct SensorDevMgrData *)device->service; CHECK_NULL_PTR_RETURN(manager); DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->sensorDevInfoHead, struct SensorDevInfoNode, node) { @@ -360,6 +371,7 @@ void ReleaseSensorDevManager(struct HdfDeviceObject *device) } OsalMutexDestroy(&manager->mutex); + OsalMutexDestroy(&manager->eventMutex); OsalMemFree(manager); g_sensorDeviceManager = NULL; } diff --git a/model/sensor/driver/gyro/sensor_gyro_driver.c b/model/sensor/driver/gyro/sensor_gyro_driver.c index 3e827ae3524d90e8f321a6ad7978c9be1adf5e03..fe3236f9758ea73561735388888667a22b891a13 100644 --- a/model/sensor/driver/gyro/sensor_gyro_driver.c +++ b/model/sensor/driver/gyro/sensor_gyro_driver.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * 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. @@ -8,7 +8,6 @@ #include "sensor_gyro_driver.h" #include -#include "gyro_bmi160.h" #include "hdf_base.h" #include "hdf_device_desc.h" #include "osal_math.h" @@ -21,10 +20,6 @@ #define HDF_GYRO_WORK_QUEUE_NAME "hdf_gyro_work_queue" -static struct GyroDetectIfList g_gyroDetectIfList[] = { - {GYRO_CHIP_NAME_BMI160, DetectGyroBim160Chip}, -}; - static struct GyroDrvData *g_gyroDrvData = NULL; static struct GyroDrvData *GyroGetDrvData(void) @@ -34,14 +29,13 @@ static struct GyroDrvData *GyroGetDrvData(void) static struct SensorRegCfgGroupNode *g_regCfgGroup[SENSOR_GROUP_MAX] = { NULL }; -int32_t RegisterGyroChipOps(const struct GyroOpsCall *ops) +int32_t GyroRegisterChipOps(const struct GyroOpsCall *ops) { - struct GyroDrvData *drvData = NULL; + struct GyroDrvData *drvData = GyroGetDrvData(); + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(ops, HDF_ERR_INVALID_PARAM); - drvData = GyroGetDrvData(); - CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); drvData->ops.Init = ops->Init; drvData->ops.ReadData = ops->ReadData; return HDF_SUCCESS; @@ -49,16 +43,18 @@ int32_t RegisterGyroChipOps(const struct GyroOpsCall *ops) static void GyroDataWorkEntry(void *arg) { - int32_t ret; - struct GyroDrvData *drvData = (struct GyroDrvData *)arg; + struct GyroDrvData *drvData = NULL; + + drvData = (struct GyroDrvData *)arg; CHECK_NULL_PTR_RETURN(drvData); - CHECK_NULL_PTR_RETURN(drvData->ops.ReadData); - ret = drvData->ops.ReadData(drvData->gyroCfg); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: gyro read data failed", __func__); + if (drvData->ops.ReadData == NULL) { + HDF_LOGI("%s: Gyro ReadData function NULl", __func__); return; } + if (drvData->ops.ReadData(drvData->gyroCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Gyro read data failed", __func__); + } } static void GyroTimerEntry(uintptr_t arg) @@ -69,48 +65,32 @@ static void GyroTimerEntry(uintptr_t arg) CHECK_NULL_PTR_RETURN(drvData); if (!HdfAddWork(&drvData->gyroWorkQueue, &drvData->gyroWork)) { - HDF_LOGE("%s: gyro add work queue failed", __func__); + HDF_LOGE("%s: Gyro add work queue failed", __func__); } interval = OsalDivS64(drvData->interval, (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT)); interval = (interval < SENSOR_TIMER_MIN_TIME) ? SENSOR_TIMER_MIN_TIME : interval; ret = OsalTimerSetTimeout(&drvData->gyroTimer, interval); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: gyro modify time failed", __func__); + HDF_LOGE("%s: Gyro modify time failed", __func__); } } -static int32_t InitGyroData(void) +static int32_t InitGyroData(struct GyroDrvData *drvData) { - struct GyroDrvData *drvData = GyroGetDrvData(); - int32_t ret; - CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); - - if (drvData->initStatus) { - return HDF_SUCCESS; - } - if (HdfWorkQueueInit(&drvData->gyroWorkQueue, HDF_GYRO_WORK_QUEUE_NAME) != HDF_SUCCESS) { - HDF_LOGE("%s: gyro init work queue failed", __func__); + HDF_LOGE("%s: Gyro init work queue failed", __func__); return HDF_FAILURE; } if (HdfWorkInit(&drvData->gyroWork, GyroDataWorkEntry, drvData) != HDF_SUCCESS) { - HDF_LOGE("%s: gyro create thread failed", __func__); - return HDF_FAILURE; - } - - CHECK_NULL_PTR_RETURN_VALUE(drvData->ops.Init, HDF_ERR_INVALID_PARAM); - - ret = drvData->ops.Init(drvData->gyroCfg); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: gyro create thread failed", __func__); + HDF_LOGE("%s: Gyro create thread failed", __func__); return HDF_FAILURE; } drvData->interval = SENSOR_TIMER_MIN_TIME; - drvData->initStatus = true; drvData->enable = false; + drvData->detectFlag = false; return HDF_SUCCESS; } @@ -124,25 +104,25 @@ static int32_t SetGyroEnable(void) CHECK_NULL_PTR_RETURN_VALUE(drvData->gyroCfg, HDF_ERR_INVALID_PARAM); if (drvData->enable) { - HDF_LOGE("%s: gyro sensor is enabled", __func__); + HDF_LOGE("%s: Gyro sensor is enabled", __func__); return HDF_SUCCESS; } ret = SetSensorRegCfgArray(&drvData->gyroCfg->busCfg, drvData->gyroCfg->regCfgGroup[SENSOR_ENABLE_GROUP]); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: gyro sensor enable config failed", __func__); + HDF_LOGE("%s: Gyro sensor enable config failed", __func__); return ret; } ret = OsalTimerCreate(&drvData->gyroTimer, SENSOR_TIMER_MIN_TIME, GyroTimerEntry, (uintptr_t)drvData); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: gyro create timer failed[%d]", __func__, ret); + HDF_LOGE("%s: Gyro create timer failed[%d]", __func__, ret); return ret; } ret = OsalTimerStartLoop(&drvData->gyroTimer); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: gyro start timer failed[%d]", __func__, ret); + HDF_LOGE("%s: Gyro start timer failed[%d]", __func__, ret); return ret; } drvData->enable = true; @@ -159,22 +139,23 @@ static int32_t SetGyroDisable(void) CHECK_NULL_PTR_RETURN_VALUE(drvData->gyroCfg, HDF_ERR_INVALID_PARAM); if (!drvData->enable) { - HDF_LOGE("%s: gyro sensor had disable", __func__); + HDF_LOGE("%s: Gyro sensor had disable", __func__); return HDF_SUCCESS; } ret = SetSensorRegCfgArray(&drvData->gyroCfg->busCfg, drvData->gyroCfg->regCfgGroup[SENSOR_DISABLE_GROUP]); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: gyro sensor disable config failed", __func__); + HDF_LOGE("%s: Gyro sensor disable config failed", __func__); return ret; } ret = OsalTimerDelete(&drvData->gyroTimer); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: gyro delete timer failed", __func__); + HDF_LOGE("%s: Gyro delete timer failed", __func__); return ret; } drvData->enable = false; + return HDF_SUCCESS; } @@ -214,13 +195,13 @@ static int32_t DispatchGyro(struct HdfDeviceIoClient *client, return HDF_SUCCESS; } -int32_t BindGyroDriver(struct HdfDeviceObject *device) +int32_t GyroBindDriver(struct HdfDeviceObject *device) { CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); struct GyroDrvData *drvData = (struct GyroDrvData *)OsalMemCalloc(sizeof(*drvData)); if (drvData == NULL) { - HDF_LOGE("%s: malloc gyro drv data fail!", __func__); + HDF_LOGE("%s: Malloc gyro drv data fail!", __func__); return HDF_ERR_MALLOC_FAIL; } @@ -231,11 +212,9 @@ int32_t BindGyroDriver(struct HdfDeviceObject *device) return HDF_SUCCESS; } -static int32_t InitGyroOps(struct SensorDeviceInfo *deviceInfo) +static int32_t InitGyroOps(struct SensorCfgData *config, struct SensorDeviceInfo *deviceInfo) { - struct GyroDrvData *drvData = GyroGetDrvData(); - - CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); deviceInfo->ops.Enable = SetGyroEnable; deviceInfo->ops.Disable = SetGyroDisable; @@ -244,149 +223,156 @@ static int32_t InitGyroOps(struct SensorDeviceInfo *deviceInfo) deviceInfo->ops.SetOption = SetGyroOption; if (memcpy_s(&deviceInfo->sensorInfo, sizeof(deviceInfo->sensorInfo), - &drvData->gyroCfg->sensorInfo, sizeof(drvData->gyroCfg->sensorInfo)) != EOK) { - HDF_LOGE("%s: copy sensor info failed", __func__); + &config->sensorInfo, sizeof(config->sensorInfo)) != EOK) { + HDF_LOGE("%s: Copy sensor info failed", __func__); return HDF_FAILURE; } return HDF_SUCCESS; } -static int32_t InitGyroAfterConfig(void) +static int32_t InitGyroAfterDetected(struct SensorCfgData *config) { struct SensorDeviceInfo deviceInfo; + CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); - if (InitGyroData() != HDF_SUCCESS) { - HDF_LOGE("%s: init gyro config failed", __func__); + if (InitGyroOps(config, &deviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: Init gyro ops failed", __func__); return HDF_FAILURE; } - if (InitGyroOps(&deviceInfo) != HDF_SUCCESS) { - HDF_LOGE("%s: init gyro ops failed", __func__); + if (AddSensorDevice(&deviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: Add gyro device failed", __func__); return HDF_FAILURE; } - if (AddSensorDevice(&deviceInfo) != HDF_SUCCESS) { - HDF_LOGE("%s: add gyro device failed", __func__); + if (ParseSensorDirection(config) != HDF_SUCCESS) { + HDF_LOGE("%s: Parse gyro direction failed", __func__); + (void)DeleteSensorDevice(&config->sensorInfo); return HDF_FAILURE; } + if (ParseSensorRegConfig(config) != HDF_SUCCESS) { + HDF_LOGE("%s: Parse sensor register failed", __func__); + (void)DeleteSensorDevice(&config->sensorInfo); + ReleaseSensorAllRegConfig(config); + ReleaseSensorDirectionConfig(config); + return HDF_FAILURE; + } return HDF_SUCCESS; } -static int32_t DetectGyroChip(void) +struct SensorCfgData *GyroCreateCfgData(const struct DeviceResourceNode *node) { - int32_t num; - int32_t ret; - int32_t loop; struct GyroDrvData *drvData = GyroGetDrvData(); - CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(drvData->gyroCfg, HDF_ERR_INVALID_PARAM); - - num = sizeof(g_gyroDetectIfList) / sizeof(g_gyroDetectIfList[0]); - for (loop = 0; loop < num; ++loop) { - if (g_gyroDetectIfList[loop].DetectChip != NULL) { - ret = g_gyroDetectIfList[loop].DetectChip(drvData->gyroCfg); - if (ret == HDF_SUCCESS) { - drvData->detectFlag = true; - return HDF_SUCCESS; - } - } + if (drvData == NULL || node == NULL) { + HDF_LOGE("%s: Gyro node pointer NULL", __func__); + return NULL; } - HDF_LOGE("%s: detect gyro device failed", __func__); - drvData->detectFlag = false; - return HDF_FAILURE; -} - -int32_t InitGyroDriver(struct HdfDeviceObject *device) -{ - CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); - struct GyroDrvData *drvData = (struct GyroDrvData *)device->service; - CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); - if (drvData->detectFlag) { - HDF_LOGE("%s: gyro sensor have detected", __func__); - return HDF_SUCCESS; + HDF_LOGE("%s: Gyro sensor have detected", __func__); + return NULL; } - drvData->gyroCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->gyroCfg)); if (drvData->gyroCfg == NULL) { - HDF_LOGE("%s: malloc sensor config data failed", __func__); - return HDF_FAILURE; + HDF_LOGE("%s: Gyro gyroCfg pointer NULL", __func__); + return NULL; } - drvData->gyroCfg->regCfgGroup = &g_regCfgGroup[0]; - - if (GetSensorBaseConfigData(device->property, drvData->gyroCfg) != HDF_SUCCESS) { - HDF_LOGE("%s: get sensor base config failed", __func__); + if (GetSensorBaseConfigData(node, drvData->gyroCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Get sensor base config failed", __func__); goto BASE_CONFIG_EXIT; } - // if return failure, hdf framework go to next detect sensor - if (DetectGyroChip() != HDF_SUCCESS) { - HDF_LOGE("%s: gyro sensor detect device no exist", __func__); - goto DETECT_CHIP_EXIT; - } - drvData->detectFlag = true; - - if (ParseSensorRegConfig(drvData->gyroCfg) != HDF_SUCCESS) { - HDF_LOGE("%s: detect sensor device failed", __func__); - goto REG_CONFIG_EXIT; + if (DetectSensorDevice(drvData->gyroCfg) != HDF_SUCCESS) { + HDF_LOGI("%s: Gyro sensor detect device no exist", __func__); + drvData->detectFlag = false; + goto BASE_CONFIG_EXIT; } - if (InitGyroAfterConfig() != HDF_SUCCESS) { - HDF_LOGE("%s: init gyro after config failed", __func__); + drvData->detectFlag = true; + if (InitGyroAfterDetected(drvData->gyroCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Gyro sensor detect device no exist", __func__); goto INIT_EXIT; } - - HDF_LOGI("%s: init gyro driver success", __func__); - return HDF_SUCCESS; + return drvData->gyroCfg; INIT_EXIT: - (void)DeleteSensorDevice(&drvData->gyroCfg->sensorInfo); -REG_CONFIG_EXIT: - ReleaseSensorAllRegConfig(drvData->gyroCfg); (void)ReleaseSensorBusHandle(&drvData->gyroCfg->busCfg); -DETECT_CHIP_EXIT: - drvData->detectFlag = false; BASE_CONFIG_EXIT: drvData->gyroCfg->root = NULL; - drvData->gyroCfg->regCfgGroup = NULL; - OsalMemFree(drvData->gyroCfg); - drvData->gyroCfg = NULL; - return HDF_FAILURE; + (void)memset_s(&drvData->gyroCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo)); + (void)memset_s(&drvData->gyroCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg)); + (void)memset_s(&drvData->gyroCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr)); + return drvData->gyroCfg; +} + +void GyroReleaseCfgData(struct SensorCfgData *gyroCfg) +{ + CHECK_NULL_PTR_RETURN(gyroCfg); + + (void)DeleteSensorDevice(&gyroCfg->sensorInfo); + ReleaseSensorAllRegConfig(gyroCfg); + (void)ReleaseSensorBusHandle(&gyroCfg->busCfg); + ReleaseSensorDirectionConfig(gyroCfg); + + gyroCfg->root = NULL; + (void)memset_s(&gyroCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo)); + (void)memset_s(&gyroCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg)); + (void)memset_s(&gyroCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr)); +} + +int32_t GyroInitDriver(struct HdfDeviceObject *device) +{ + HDF_LOGE("%s: cclog ----> 1111111111111111 ", __func__); + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + struct GyroDrvData *drvData = (struct GyroDrvData *)device->service; + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + if (InitGyroData(drvData) != HDF_SUCCESS) { + HDF_LOGE("%s: Init gyro config failed", __func__); + return HDF_FAILURE; + } + + drvData->gyroCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->gyroCfg)); + if (drvData->gyroCfg == NULL) { + HDF_LOGE("%s: Malloc gyro config data failed", __func__); + return HDF_FAILURE; + } + + drvData->gyroCfg->regCfgGroup = &g_regCfgGroup[0]; + + HDF_LOGI("%s: Init gyro driver success", __func__); + return HDF_SUCCESS; } -void ReleaseGyroDriver(struct HdfDeviceObject *device) +void GyroReleaseDriver(struct HdfDeviceObject *device) { CHECK_NULL_PTR_RETURN(device); struct GyroDrvData *drvData = (struct GyroDrvData *)device->service; CHECK_NULL_PTR_RETURN(drvData); - (void)DeleteSensorDevice(&drvData->gyroCfg->sensorInfo); - drvData->detectFlag = false; - - if (drvData->gyroCfg != NULL) { - drvData->gyroCfg->root = NULL; - drvData->gyroCfg->regCfgGroup = NULL; - ReleaseSensorAllRegConfig(drvData->gyroCfg); - (void)ReleaseSensorBusHandle(&drvData->gyroCfg->busCfg); - OsalMemFree(drvData->gyroCfg); - drvData->gyroCfg = NULL; + if (drvData->detectFlag && drvData->gyroCfg != NULL) { + GyroReleaseCfgData(drvData->gyroCfg); } - drvData->initStatus = false; + OsalMemFree(drvData->gyroCfg); + drvData->gyroCfg = NULL; + + HdfWorkDestroy(&drvData->gyroWork); + HdfWorkQueueDestroy(&drvData->gyroWorkQueue); + OsalMemFree(drvData); } struct HdfDriverEntry g_sensorGyroDevEntry = { .moduleVersion = 1, .moduleName = "HDF_SENSOR_GYRO", - .Bind = BindGyroDriver, - .Init = InitGyroDriver, - .Release = ReleaseGyroDriver, + .Bind = GyroBindDriver, + .Init = GyroInitDriver, + .Release = GyroReleaseDriver, }; HDF_INIT(g_sensorGyroDevEntry); diff --git a/model/sensor/driver/gyro/sensor_gyro_driver.h b/model/sensor/driver/gyro/sensor_gyro_driver.h index bb63e10d3b332a3f0b91d315e104d607e4ce6385..6e64f96322fe98f87268f4d6491662cc46ed8fcc 100644 --- a/model/sensor/driver/gyro/sensor_gyro_driver.h +++ b/model/sensor/driver/gyro/sensor_gyro_driver.h @@ -1,5 +1,5 @@ /* - * Copyright (c) 2021 Huawei Device Co., Ltd. + * 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. @@ -15,9 +15,6 @@ #include "sensor_config_parser.h" #include "sensor_platform_if.h" -#define GYRO_DEFAULT_SAMPLING_200_MS 200000000 -#define GYRO_CHIP_NAME_BMI160 "bmi160" - enum GyroAxisNum { GYRO_X_AXIS = 0, GYRO_Y_AXIS = 1, @@ -41,11 +38,6 @@ struct GyroData { int32_t z; }; -struct GyroDetectIfList { - char *chipName; - int32_t (*DetectChip)(struct SensorCfgData *data); -}; - struct GyroOpsCall { int32_t (*Init)(struct SensorCfgData *data); int32_t (*ReadData)(struct SensorCfgData *data); @@ -59,12 +51,13 @@ struct GyroDrvData { OsalTimer gyroTimer; bool detectFlag; bool enable; - bool initStatus; int64_t interval; struct SensorCfgData *gyroCfg; struct GyroOpsCall ops; }; -int32_t RegisterGyroChipOps(const struct GyroOpsCall *ops); +int32_t GyroRegisterChipOps(const struct GyroOpsCall *ops); +struct SensorCfgData *GyroCreateCfgData(const struct DeviceResourceNode *node); +void GyroReleaseCfgData(struct SensorCfgData *sensorCfgData); #endif /* SENSOR_GYRO_DRIVER_H */ diff --git a/model/sensor/driver/hall/sensor_hall_driver.c b/model/sensor/driver/hall/sensor_hall_driver.c index f8383e40a370c6f2c4b9f6084aaaa46da846b1d9..2a6a82bb6ebcf4f978e06b0383602d1c857818ed 100755 --- a/model/sensor/driver/hall/sensor_hall_driver.c +++ b/model/sensor/driver/hall/sensor_hall_driver.c @@ -13,8 +13,8 @@ #include "hdf_base.h" #include "hdf_device_desc.h" #include "osal_irq.h" -#include "osal_math.h" #include "osal_mem.h" +#include "osal_time.h" #include "sensor_config_controller.h" #include "sensor_device_manager.h" #include "sensor_platform_if.h" @@ -35,37 +35,102 @@ int32_t HallRegisterChipOps(const struct HallOpsCall *ops) CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); CHECK_NULL_PTR_RETURN_VALUE(ops, HDF_ERR_INVALID_PARAM); - + drvData->ops.Init = ops->Init; drvData->ops.ReadData = ops->ReadData; return HDF_SUCCESS; } +void ReadGpioData() +{ + int32_t ret; + uint16_t tmp; + OsalTimespec time; + struct SensorReportEvent event; + + struct HallDrvData *drvData = HallGetDrvData(); + CHECK_NULL_PTR_RETURN(drvData); + + (void)memset_s(&event, sizeof(event), 0, sizeof(event)); + (void)memset_s(&time, sizeof(time), 0, sizeof(time)); + if (OsalGetTime(&time) != HDF_SUCCESS) { + HDF_LOGE("%s: Get time failed", __func__); + return; + } + + tmp = drvData->status; + event.timestamp = time.sec * SENSOR_SECOND_CONVERT_NANOSECOND + time.usec * + SENSOR_CONVERT_UNIT; /* unit nanosecond */ + event.sensorId = SENSOR_TAG_HALL; + event.version = 0; + event.option = 0; + event.mode = SENSOR_WORK_MODE_ON_CHANGE; + event.dataLen = sizeof(tmp); + event.data = (uint8_t *)&tmp; + ret = ReportSensorEvent(&event); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: AK8789 report data failed", __func__); + } +} + static void HallDataWorkEntry(void *arg) { struct HallDrvData *drvData = NULL; - + drvData = (struct HallDrvData *)arg; CHECK_NULL_PTR_RETURN(drvData); if (drvData->ops.ReadData == NULL) { + ReadGpioData(); HDF_LOGI("%s: Hall ReadData function NULL", __func__); - return; - } - if (drvData->ops.ReadData(drvData->hallCfg) != HDF_SUCCESS) { + } else if (drvData->ops.ReadData(drvData->hallCfg) != HDF_SUCCESS) { HDF_LOGE("%s: Hall read data failed", __func__); } } +static int32_t ParserHallDelayedConfigData(const struct DeviceResourceNode *node, struct HallDrvData *drvData) +{ + int32_t ret; + struct DeviceResourceIface *parser = NULL; + + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + parser = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + CHECK_NULL_PTR_RETURN_VALUE(parser, HDF_ERR_INVALID_PARAM); + + CHECK_NULL_PTR_RETURN_VALUE(parser->GetChildNode, HDF_ERR_INVALID_PARAM); + + const struct DeviceResourceNode *delayedNode = parser->GetChildNode(node, "hallDelayedConfig"); + CHECK_NULL_PTR_RETURN_VALUE(delayedNode, HDF_ERR_INVALID_PARAM); + + ret = parser->GetUint32(delayedNode, "delayedTime", (uint32_t *)&drvData->delayTime, 0); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "delayedTime"); + + return HDF_SUCCESS; +} + static int32_t HallNorthPolarityIrqFunc(uint16_t gpio, void *data) { (void)gpio; + int32_t ret; + uint16_t valRead; struct HallDrvData *drvData = (struct HallDrvData *)data; CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); - if (!HdfAddWork(&drvData->hallWorkQueue, &drvData->hallWork)) { - HDF_LOGE("%s: Hall add work queue failed", __func__); + ret = GpioRead(drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM1], (uint16_t *)&valRead); + if (ret != 0) { + HDF_LOGE("%s: Read hall gpio value failed", __func__); + } + if (valRead == GPIO_VAL_LOW) { + drvData->status = 1; + } else if (valRead == GPIO_VAL_HIGH) { + drvData->status = 0; + } + + if (!HdfAddDelayedWork(&drvData->hallWorkQueue, &drvData->hallWork, drvData->delayTime)) { + HDF_LOGE("%s: Hall north add delay work queue failed", __func__); } return HDF_SUCCESS; @@ -74,12 +139,24 @@ static int32_t HallNorthPolarityIrqFunc(uint16_t gpio, void *data) static int32_t HallSouthPolarityIrqFunc(uint16_t gpio, void *data) { (void)gpio; + int32_t ret; + uint16_t valRead; struct HallDrvData *drvData = (struct HallDrvData *)data; CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); - if (!HdfAddWork(&drvData->hallWorkQueue, &drvData->hallWork)) { - HDF_LOGE("%s: Hall add work queue failed", __func__); + ret = GpioRead(drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM2], (uint16_t *)&valRead); + if (ret != 0) { + HDF_LOGE("%s: Read hall gpio value failed", __func__); + } + if (valRead == GPIO_VAL_LOW) { + drvData->status = 1; + } else if (valRead == GPIO_VAL_HIGH) { + drvData->status = 0; + } + + if (!HdfAddDelayedWork(&drvData->hallWorkQueue, &drvData->hallWork, drvData->delayTime)) { + HDF_LOGE("%s: Hall south add delay work queue failed", __func__); } return HDF_SUCCESS; @@ -92,7 +169,7 @@ static int32_t InitHallData(struct HallDrvData *drvData) return HDF_FAILURE; } - if (HdfWorkInit(&drvData->hallWork, HallDataWorkEntry, drvData) != HDF_SUCCESS) { + if (HdfDelayedWorkInit(&drvData->hallWork, HallDataWorkEntry, drvData) != HDF_SUCCESS) { HDF_LOGE("%s: Hall create thread failed", __func__); return HDF_FAILURE; } @@ -107,6 +184,7 @@ static int32_t InitHallData(struct HallDrvData *drvData) static int32_t SetHallEnable(void) { int32_t ret; + uint16_t mode; struct HallDrvData *drvData = HallGetDrvData(); CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); @@ -115,25 +193,26 @@ static int32_t SetHallEnable(void) return HDF_SUCCESS; } - if (drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO] >= 0) { - ret = GpioSetIrq(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO], OSAL_IRQF_TRIGGER_FALLING, + mode = OSAL_IRQF_TRIGGER_RISING | OSAL_IRQF_TRIGGER_FALLING; + if (drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM1] >= 0) { + ret = GpioSetIrq(drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM1], mode, HallNorthPolarityIrqFunc, drvData); if (ret != 0) { HDF_LOGE("Gpio set north irq failed: %d", ret); } - ret = GpioEnableIrq(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO]); + ret = GpioEnableIrq(drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM1]); if (ret != 0) { HDF_LOGE("Gpio enable north irq failed: %d", ret); } } - if (drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO] >= 0) { - ret = GpioSetIrq(drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO], OSAL_IRQF_TRIGGER_FALLING, + if (drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM2] >= 0) { + ret = GpioSetIrq(drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM2], mode, HallSouthPolarityIrqFunc, drvData); if (ret != 0) { HDF_LOGE("%s: Gpio set south irq failed", __func__); } - ret = GpioEnableIrq(drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO]); + ret = GpioEnableIrq(drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM2]); if (ret != 0) { HDF_LOGE("%s: Gpio enable south irq failed", __func__); } @@ -154,25 +233,25 @@ static int32_t SetHallDisable(void) return HDF_SUCCESS; } - if (drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO] >= 0) { - ret = GpioUnSetIrq(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO]); + if (drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM1] >= 0) { + ret = GpioUnSetIrq(drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM1]); if (ret != 0) { HDF_LOGE("%s: Gpio unset north irq failed", __func__); } - ret = GpioDisableIrq(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO]); + ret = GpioDisableIrq(drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM1]); if (ret != 0) { HDF_LOGE("%s: Gpio disable north irq failed", __func__); } } - if (drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO] >= 0) { - ret = GpioUnSetIrq(drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO]); + if (drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM2] >= 0) { + ret = GpioUnSetIrq(drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM2]); if (ret != 0) { HDF_LOGE("%s: Gpio unset south irq failed", __func__); } - ret = GpioDisableIrq(drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO]); + ret = GpioDisableIrq(drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM2]); if (ret != 0) { HDF_LOGE("%s: Gpio disable south irq failed", __func__); } @@ -245,30 +324,6 @@ static int32_t InitHallOps(struct SensorCfgData *config, struct SensorDeviceInfo return HDF_SUCCESS; } -static int32_t ParserHallPinConfigData(const struct DeviceResourceNode *node, struct HallDrvData *drvData) -{ - int32_t ret; - struct DeviceResourceIface *parser = NULL; - - CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); - CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); - - parser = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); - CHECK_NULL_PTR_RETURN_VALUE(parser, HDF_ERR_INVALID_PARAM); - - CHECK_NULL_PTR_RETURN_VALUE(parser->GetChildNode, HDF_ERR_INVALID_PARAM); - - const struct DeviceResourceNode *pinNode = parser->GetChildNode(node, "hallPinConfig"); - CHECK_NULL_PTR_RETURN_VALUE(pinNode, HDF_ERR_INVALID_PARAM); - - ret = parser->GetUint32(pinNode, "NorthPolarityGpio", (uint32_t *)&drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO], 0); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "NorthPolarityGpio"); - ret = parser->GetUint32(pinNode, "SouthPolarityGpio", (uint32_t *)&drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO], 0); - CHECK_PARSER_RESULT_RETURN_VALUE(ret, "SouthPolarityGpio"); - - return HDF_SUCCESS; -} - static int32_t InitHallAfterDetected(const struct DeviceResourceNode *node, struct HallDrvData *drvData) { struct SensorDeviceInfo deviceInfo; @@ -285,28 +340,29 @@ static int32_t InitHallAfterDetected(const struct DeviceResourceNode *node, stru return HDF_FAILURE; } - if (ParserHallPinConfigData(node, drvData) != HDF_SUCCESS) { - HDF_LOGE("%s: get hall pin config failed", __func__); + if (ParserHallDelayedConfigData(node, drvData) != HDF_SUCCESS) { + HDF_LOGE("%s: get hall delayed config failed", __func__); (void)DeleteSensorDevice(&drvData->hallCfg->sensorInfo); return HDF_FAILURE; } + return HDF_SUCCESS; } static int32_t SetHallGpioPin(struct HallDrvData *drvData) { - if (drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO] >= 0) { - int ret = GpioSetDir(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO], GPIO_DIR_IN); + if (drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM1] >= 0) { + int ret = GpioSetDir(drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM1], GPIO_DIR_IN); if (ret != 0) { - HDF_LOGE("%s:%d set north gpio dir failed", __func__, __LINE__); + HDF_LOGE("%s:%d Set north gpio dir failed", __func__, __LINE__); return HDF_FAILURE; } } - if (drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO] >= 0) { - int ret = GpioSetDir(drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO], GPIO_DIR_IN); + if (drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM2] >= 0) { + int ret = GpioSetDir(drvData->hallCfg->busCfg.GpioNum[SENSOR_GPIO_NUM2], GPIO_DIR_IN); if (ret != 0) { - HDF_LOGE("%s:%d south south gpio dir failed", __func__, __LINE__); + HDF_LOGE("%s:%d Set south gpio dir failed", __func__, __LINE__); return HDF_FAILURE; } } diff --git a/model/sensor/driver/hall/sensor_hall_driver.h b/model/sensor/driver/hall/sensor_hall_driver.h index 3b706dcc3937c62c8c64f5a529b3a0f20d7d0a3c..7766365d430a5638b42db847c86eae7c477cef16 100755 --- a/model/sensor/driver/hall/sensor_hall_driver.h +++ b/model/sensor/driver/hall/sensor_hall_driver.h @@ -9,18 +9,12 @@ #ifndef SENSOR_HALL_DRIVER_H #define SENSOR_HALL_DRIVER_H -#include "hdf_workqueue.h" +#include "hdf_workqueue.h" #include "sensor_config_parser.h" #include "sensor_platform_if.h" #define HALL_CHIP_NAME_AK8789 "ak8789" -enum HallGpioIrq { - HALL_NORTH_POLARITY_GPIO = 0, - HALL_SOUTH_POLARITY_GPIO = 1, - HALL_POLARITY_GPIO_MAX = 2, -}; - struct HallOpsCall { int32_t (*Init)(struct SensorCfgData *data); int32_t (*ReadData)(struct SensorCfgData *data); @@ -36,7 +30,8 @@ struct HallDrvData { int64_t interval; struct SensorCfgData *hallCfg; struct HallOpsCall ops; - int32_t GpioIrq[HALL_POLARITY_GPIO_MAX]; + uint16_t status; + uint32_t delayTime; }; int32_t HallRegisterChipOps(const struct HallOpsCall *ops); diff --git a/model/sensor/driver/include/sensor_device_if.h b/model/sensor/driver/include/sensor_device_if.h index c3315fdc795674a710f29db54c5a160c89e578fa..5a68aa5df54a079d6ba170583b80f1848a4ed945 100644 --- a/model/sensor/driver/include/sensor_device_if.h +++ b/model/sensor/driver/include/sensor_device_if.h @@ -1,31 +1,31 @@ -/* - * 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 SENSOR_DEVICE_IF_H -#define SENSOR_DEVICE_IF_H - -#include "sensor_device_type.h" - -struct SensorOps { - int32_t (*Enable)(void); - int32_t (*Disable)(void); - int32_t (*SetBatch)(int64_t samplingInterval, int64_t reportInterval); - int32_t (*SetMode)(int32_t mode); - int32_t (*SetOption)(uint32_t option); -}; - -struct SensorDeviceInfo { - struct SensorBasicInfo sensorInfo; - struct SensorOps ops; -}; - -int32_t AddSensorDevice(const struct SensorDeviceInfo *deviceInfo); -int32_t DeleteSensorDevice(const struct SensorBasicInfo *sensorBaseInfo); -int32_t ReportSensorEvent(const struct SensorReportEvent *events); - -#endif /* SENSOR_DEVICE_IF_H */ +/* + * 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 SENSOR_DEVICE_IF_H +#define SENSOR_DEVICE_IF_H + +#include "sensor_device_type.h" + +struct SensorOps { + int32_t (*Enable)(void); + int32_t (*Disable)(void); + int32_t (*SetBatch)(int64_t samplingInterval, int64_t reportInterval); + int32_t (*SetMode)(int32_t mode); + int32_t (*SetOption)(uint32_t option); +}; + +struct SensorDeviceInfo { + struct SensorBasicInfo sensorInfo; + struct SensorOps ops; +}; + +int32_t AddSensorDevice(const struct SensorDeviceInfo *deviceInfo); +int32_t DeleteSensorDevice(const struct SensorBasicInfo *sensorBaseInfo); +int32_t ReportSensorEvent(const struct SensorReportEvent *events); + +#endif /* SENSOR_DEVICE_IF_H */ diff --git a/model/sensor/driver/include/sensor_platform_if.h b/model/sensor/driver/include/sensor_platform_if.h index 6bf64210f4623059483eaedc66f2babe86b04d16..6f14893833b7e30fcf3f91566c15bf1a5103c426 100644 --- a/model/sensor/driver/include/sensor_platform_if.h +++ b/model/sensor/driver/include/sensor_platform_if.h @@ -52,6 +52,13 @@ enum SensorBusType { SENSOR_BUS_I2C = 0, SENSOR_BUS_SPI = 1, + SENSOR_BUS_GPIO = 2, +}; + +enum SensorGpioNum { + SENSOR_GPIO_NUM1 = 0, + SENSOR_GPIO_NUM2 = 1, + SENSOR_GPIO_NUM_MAX = 2, }; struct SensorI2cCfg { @@ -73,6 +80,7 @@ struct SensorBusCfg { union { struct SensorI2cCfg i2cCfg; struct SensorSpiCfg spiCfg; + uint32_t GpioNum[SENSOR_GPIO_NUM_MAX]; }; }; diff --git a/model/sensor/driver/magnetic/sensor_magnetic_driver.c b/model/sensor/driver/magnetic/sensor_magnetic_driver.c new file mode 100755 index 0000000000000000000000000000000000000000..eb831ad1122039190d2eb60a39c8ec4f97c832fd --- /dev/null +++ b/model/sensor/driver/magnetic/sensor_magnetic_driver.c @@ -0,0 +1,386 @@ +/* + * Copyright (c) 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 "sensor_magnetic_driver.h" +#include +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "osal_math.h" +#include "osal_mem.h" +#include "sensor_config_controller.h" +#include "sensor_device_manager.h" +#include "sensor_platform_if.h" + +#define HDF_LOG_TAG sensor_magnetic_driver_c + +#define HDF_MAGNETIC_WORK_QUEUE_NAME "hdf_magnetic_work_queue" + +static struct MagneticDrvData *g_magneticDrvData = NULL; + +static struct MagneticDrvData *MagneticGetDrvData(void) +{ + return g_magneticDrvData; +} + +static struct SensorRegCfgGroupNode *g_regCfgGroup[SENSOR_GROUP_MAX] = { NULL }; + +int32_t MagneticRegisterChipOps(const struct MagneticOpsCall *ops) +{ + struct MagneticDrvData *drvData = MagneticGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(ops, HDF_ERR_INVALID_PARAM); + + drvData->ops.Init = ops->Init; + drvData->ops.ReadData = ops->ReadData; + return HDF_SUCCESS; +} + +static void MagneticDataWorkEntry(void *arg) +{ + struct MagneticDrvData *drvData = NULL; + + drvData = (struct MagneticDrvData *)arg; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->ops.ReadData == NULL) { + HDF_LOGE("%s: Magnetic readdata function NULL", __func__); + return; + } + if (drvData->ops.ReadData(drvData->magneticCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Magnetic read data failed", __func__); + } +} + +static void MagneticTimerEntry(uintptr_t arg) +{ + int64_t interval; + int32_t ret; + struct MagneticDrvData *drvData = (struct MagneticDrvData *)arg; + CHECK_NULL_PTR_RETURN(drvData); + + if (!HdfAddWork(&drvData->magneticWorkQueue, &drvData->magneticWork)) { + HDF_LOGE("%s: Magnetic add work queue failed", __func__); + } + + interval = OsalDivS64(drvData->interval, (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT)); + interval = (interval < SENSOR_TIMER_MIN_TIME) ? SENSOR_TIMER_MIN_TIME : interval; + ret = OsalTimerSetTimeout(&drvData->magneticTimer, interval); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Magnetic modify time failed", __func__); + } +} + +static int32_t InitMagneticData(struct MagneticDrvData *drvData) +{ + if (HdfWorkQueueInit(&drvData->magneticWorkQueue, HDF_MAGNETIC_WORK_QUEUE_NAME) != HDF_SUCCESS) { + HDF_LOGE("%s: Magnetic init work queue failed", __func__); + return HDF_FAILURE; + } + + if (HdfWorkInit(&drvData->magneticWork, MagneticDataWorkEntry, drvData) != HDF_SUCCESS) { + HDF_LOGE("%s: Magnetic create thread failed", __func__); + return HDF_FAILURE; + } + + drvData->interval = SENSOR_TIMER_MIN_TIME; + drvData->enable = false; + drvData->detectFlag = false; + + return HDF_SUCCESS; +} + +static int32_t SetMagneticEnable(void) +{ + int32_t ret; + struct MagneticDrvData *drvData = MagneticGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(drvData->magneticCfg, HDF_ERR_INVALID_PARAM); + + if (drvData->enable) { + HDF_LOGE("%s: Magnetic sensor is enabled", __func__); + return HDF_SUCCESS; + } + + ret = SetSensorRegCfgArray(&drvData->magneticCfg->busCfg, drvData->magneticCfg->regCfgGroup[SENSOR_ENABLE_GROUP]); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Magnetic sensor enable config failed", __func__); + return ret; + } + + ret = OsalTimerCreate(&drvData->magneticTimer, SENSOR_TIMER_MIN_TIME, MagneticTimerEntry, (uintptr_t)drvData); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Magnetic create timer failed[%d]", __func__, ret); + return ret; + } + + ret = OsalTimerStartLoop(&drvData->magneticTimer); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Magnetic start timer failed[%d]", __func__, ret); + return ret; + } + drvData->enable = true; + + return HDF_SUCCESS; +} + +static int32_t SetMagneticDisable(void) +{ + int32_t ret; + struct MagneticDrvData *drvData = MagneticGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(drvData->magneticCfg, HDF_ERR_INVALID_PARAM); + + if (!drvData->enable) { + HDF_LOGE("%s: Magnetic sensor had disable", __func__); + return HDF_SUCCESS; + } + + ret = SetSensorRegCfgArray(&drvData->magneticCfg->busCfg, drvData->magneticCfg->regCfgGroup[SENSOR_DISABLE_GROUP]); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Magnetic sensor disable config failed", __func__); + return ret; + } + + ret = OsalTimerDelete(&drvData->magneticTimer); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Magnetic delete timer failed", __func__); + return ret; + } + drvData->enable = false; + + return HDF_SUCCESS; +} + +static int32_t SetMagneticBatch(int64_t samplingInterval, int64_t interval) +{ + (void)interval; + + struct MagneticDrvData *drvData = NULL; + + drvData = MagneticGetDrvData(); + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + drvData->interval = samplingInterval; + + return HDF_SUCCESS; +} + +static int32_t SetMagneticMode(int32_t mode) +{ + return (mode == SENSOR_WORK_MODE_REALTIME) ? HDF_SUCCESS : HDF_FAILURE; +} + +static int32_t SetMagneticOption(uint32_t option) +{ + (void)option; + + return HDF_SUCCESS; +} + +static int32_t DispatchMagnetic(struct HdfDeviceIoClient *client, + int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)client; + (void)cmd; + (void)data; + (void)reply; + + return HDF_SUCCESS; +} + +int32_t MagneticBindDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + + struct MagneticDrvData *drvData = (struct MagneticDrvData *)OsalMemCalloc(sizeof(*drvData)); + if (drvData == NULL) { + HDF_LOGE("%s: Malloc magnetic drv data fail!", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + drvData->ioService.Dispatch = DispatchMagnetic; + drvData->device = device; + device->service = &drvData->ioService; + g_magneticDrvData = drvData; + + return HDF_SUCCESS; +} + +static int32_t InitMagneticOps(struct SensorCfgData *config, struct SensorDeviceInfo *deviceInfo) +{ + CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); + + deviceInfo->ops.Enable = SetMagneticEnable; + deviceInfo->ops.Disable = SetMagneticDisable; + deviceInfo->ops.SetBatch = SetMagneticBatch; + deviceInfo->ops.SetMode = SetMagneticMode; + deviceInfo->ops.SetOption = SetMagneticOption; + + if (memcpy_s(&deviceInfo->sensorInfo, sizeof(deviceInfo->sensorInfo), + &config->sensorInfo, sizeof(config->sensorInfo)) != EOK) { + HDF_LOGE("%s: Copy sensor info failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t InitMagneticAfterDetected(struct SensorCfgData *config) +{ + struct SensorDeviceInfo deviceInfo; + CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); + + if (InitMagneticOps(config, &deviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: Init magnetic ops failed", __func__); + return HDF_FAILURE; + } + + if (AddSensorDevice(&deviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: Add magnetic device failed", __func__); + return HDF_FAILURE; + } + + if (ParseSensorDirection(config) != HDF_SUCCESS) { + HDF_LOGE("%s: Parse magnetic direction failed", __func__); + (void)DeleteSensorDevice(&config->sensorInfo); + return HDF_FAILURE; + } + + if (ParseSensorRegConfig(config) != HDF_SUCCESS) { + HDF_LOGE("%s: Parse sensor register failed", __func__); + (void)DeleteSensorDevice(&config->sensorInfo); + ReleaseSensorAllRegConfig(config); + ReleaseSensorDirectionConfig(config); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +struct SensorCfgData *MagneticCreateCfgData(const struct DeviceResourceNode *node) +{ + struct MagneticDrvData *drvData = MagneticGetDrvData(); + + if (drvData == NULL || node == NULL) { + HDF_LOGE("%s: Magnetic node pointer NULL", __func__); + + return NULL; + } + + if (drvData->detectFlag) { + HDF_LOGE("%s: Magnetic sensor have detected", __func__); + + return NULL; + } + + if (drvData->magneticCfg == NULL) { + HDF_LOGE("%s: Magnetic magneticCfg pointer NULL", __func__); + + return NULL; + } + + if (GetSensorBaseConfigData(node, drvData->magneticCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Get sensor base config failed", __func__); + goto BASE_CONFIG_EXIT; + } + + if (DetectSensorDevice(drvData->magneticCfg) != HDF_SUCCESS) { + HDF_LOGI("%s: Magnetic sensor detect device no exist", __func__); + drvData->detectFlag = false; + goto BASE_CONFIG_EXIT; + } + + drvData->detectFlag = true; + if (InitMagneticAfterDetected(drvData->magneticCfg) != HDF_SUCCESS) { + HDF_LOGI("%s: Magnetic sensor detect device no exist", __func__); + + goto INIT_EXIT; + } + return drvData->magneticCfg; + +INIT_EXIT: + (void)ReleaseSensorBusHandle(&drvData->magneticCfg->busCfg); +BASE_CONFIG_EXIT: + drvData->magneticCfg->root = NULL; + (void)memset_s(&drvData->magneticCfg->sensorInfo, + sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo)); + (void)memset_s(&drvData->magneticCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg)); + (void)memset_s(&drvData->magneticCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr)); + + return drvData->magneticCfg; +} + +void MagneticReleaseCfgData(struct SensorCfgData *magneticCfg) +{ + CHECK_NULL_PTR_RETURN(magneticCfg); + + (void)DeleteSensorDevice(&magneticCfg->sensorInfo); + ReleaseSensorAllRegConfig(magneticCfg); + (void)ReleaseSensorBusHandle(&magneticCfg->busCfg); + ReleaseSensorDirectionConfig(magneticCfg); + + magneticCfg->root = NULL; + (void)memset_s(&magneticCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo)); + (void)memset_s(&magneticCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg)); + (void)memset_s(&magneticCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr)); +} + +int32_t MagneticInitDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + struct MagneticDrvData *drvData = (struct MagneticDrvData *)device->service; + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + if (InitMagneticData(drvData) != HDF_SUCCESS) { + HDF_LOGE("%s: Init magnetic config failed", __func__); + return HDF_FAILURE; + } + + drvData->magneticCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->magneticCfg)); + if (drvData->magneticCfg == NULL) { + HDF_LOGE("%s: Malloc magnetic config data failed", __func__); + return HDF_FAILURE; + } + + drvData->magneticCfg->regCfgGroup = &g_regCfgGroup[0]; + + HDF_LOGI("%s: Init magnetic driver success", __func__); + return HDF_SUCCESS; +} + +void MagneticReleaseDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN(device); + + struct MagneticDrvData *drvData = (struct MagneticDrvData *)device->service; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->detectFlag && drvData->magneticCfg != NULL) { + MagneticReleaseCfgData(drvData->magneticCfg); + } + + OsalMemFree(drvData->magneticCfg); + drvData->magneticCfg = NULL; + + HdfWorkDestroy(&drvData->magneticWork); + HdfWorkQueueDestroy(&drvData->magneticWorkQueue); + OsalMemFree(drvData); +} + +struct HdfDriverEntry g_sensorMagneticDevEntry = { + .moduleVersion = 1, + .moduleName = "HDF_SENSOR_MAGNETIC", + .Bind = MagneticBindDriver, + .Init = MagneticInitDriver, + .Release = MagneticReleaseDriver, +}; + +HDF_INIT(g_sensorMagneticDevEntry); \ No newline at end of file diff --git a/model/sensor/driver/magnetic/sensor_magnetic_driver.h b/model/sensor/driver/magnetic/sensor_magnetic_driver.h new file mode 100755 index 0000000000000000000000000000000000000000..14b836e091467d7612f76f6022428fe368c1f408 --- /dev/null +++ b/model/sensor/driver/magnetic/sensor_magnetic_driver.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 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 SENSOR_MAGNETIC_DRIVER_H +#define SENSOR_MAGNETIC_DRIVER_H + +#include "hdf_workqueue.h" +#include "osal_timer.h" +#include "sensor_config_parser.h" +#include "sensor_platform_if.h" + +#define MAGNETIC_DEFAULT_SAMPLING_200_MS 200000000 +#define MAGNETIC_CHIP_NAME_LSM303 "lsm303" + +enum MagneticAxisNum { + MAGNETIC_X_AXIS = 0, + MAGNETIC_Y_AXIS = 1, + MAGNETIC_Z_AXIS = 2, + MAGNETIC_AXIS_NUM = 3, +}; + +enum MagneticAxisPart { + MAGNETIC_X_AXIS_MSB = 0, + MAGNETIC_X_AXIS_LSB = 1, + MAGNETIC_Y_AXIS_MSB = 2, + MAGNETIC_Y_AXIS_LSB = 3, + MAGNETIC_Z_AXIS_MSB = 4, + MAGNETIC_Z_AXIS_LSB = 5, + MAGNETIC_AXIS_BUTT, +}; + +struct MagneticData { + int32_t x; + int32_t y; + int32_t z; +}; + +struct MagneticOpsCall { + int32_t (*Init)(struct SensorCfgData *data); + int32_t (*ReadData)(struct SensorCfgData *data); +}; + +struct MagneticDrvData { + struct IDeviceIoService ioService; + struct HdfDeviceObject *device; + HdfWorkQueue magneticWorkQueue; + HdfWork magneticWork; + OsalTimer magneticTimer; + bool detectFlag; + bool enable; + int64_t interval; + struct SensorCfgData *magneticCfg; + struct MagneticOpsCall ops; +}; + +int32_t MagneticRegisterChipOps(const struct MagneticOpsCall *ops); +struct SensorCfgData *MagneticCreateCfgData(const struct DeviceResourceNode *node); +void MagneticReleaseCfgData(struct SensorCfgData *sensorCfgData); + +#endif /* SENSOR_MAGNETIC_DRIVER_H */ diff --git a/model/sensor/driver/proximity/sensor_proximity_driver.c b/model/sensor/driver/proximity/sensor_proximity_driver.c new file mode 100644 index 0000000000000000000000000000000000000000..9d4e770c3704ce50b02f263cb3b66fcdf4b71844 --- /dev/null +++ b/model/sensor/driver/proximity/sensor_proximity_driver.c @@ -0,0 +1,374 @@ +/* + * Copyright (c) 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 "sensor_proximity_driver.h" +#include +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "osal_math.h" +#include "osal_mem.h" +#include "sensor_config_controller.h" +#include "sensor_device_manager.h" +#include "sensor_platform_if.h" + +#define HDF_LOG_TAG sensor_proximity_driver_c + +#define HDF_PROXIMITY_WORK_QUEUE_NAME "hdf_proximity_work_queue" + +static struct ProximityDrvData *g_proximityDrvData = NULL; + +static struct ProximityDrvData *ProximityGetDrvData(void) +{ + return g_proximityDrvData; +} + +static struct SensorRegCfgGroupNode *g_regCfgGroup[SENSOR_GROUP_MAX] = { NULL }; + +int32_t ProximityRegisterChipOps(const struct ProximityOpsCall *ops) +{ + struct ProximityDrvData *drvData = NULL; + + CHECK_NULL_PTR_RETURN_VALUE(ops, HDF_ERR_INVALID_PARAM); + + drvData = ProximityGetDrvData(); + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + drvData->ops.Init = ops->Init; + drvData->ops.ReadData = ops->ReadData; + return HDF_SUCCESS; +} + +static void ProximityDataWorkEntry(void *arg) +{ + int32_t ret; + struct ProximityDrvData *drvData = (struct ProximityDrvData *)arg; + CHECK_NULL_PTR_RETURN(drvData); + CHECK_NULL_PTR_RETURN(drvData->ops.ReadData); + + ret = drvData->ops.ReadData(drvData->proximityCfg); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: proximity read data failed", __func__); + return; + } +} + +static void ProximityTimerEntry(uintptr_t arg) +{ + int64_t interval; + int32_t ret; + struct ProximityDrvData *drvData = (struct ProximityDrvData *)arg; + CHECK_NULL_PTR_RETURN(drvData); + + if (!HdfAddWork(&drvData->proximityWorkQueue, &drvData->proximityWork)) { + HDF_LOGE("%s: proximity add work queue failed", __func__); + } + + interval = OsalDivS64(drvData->interval, (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT)); + interval = (interval < SENSOR_TIMER_MIN_TIME) ? SENSOR_TIMER_MIN_TIME : interval; + ret = OsalTimerSetTimeout(&drvData->proximityTimer, interval); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: proximity modify time failed", __func__); + } +} + +static int32_t InitProximityData(struct ProximityDrvData *drvData) +{ + if (HdfWorkQueueInit(&drvData->proximityWorkQueue, HDF_PROXIMITY_WORK_QUEUE_NAME) != HDF_SUCCESS) { + HDF_LOGE("%s: proximity init work queue failed", __func__); + return HDF_FAILURE; + } + + if (HdfWorkInit(&drvData->proximityWork, ProximityDataWorkEntry, drvData) != HDF_SUCCESS) { + HDF_LOGE("%s: proximity create thread failed", __func__); + return HDF_FAILURE; + } + + drvData->interval = SENSOR_TIMER_MIN_TIME; + drvData->enable = false; + drvData->detectFlag = false; + + return HDF_SUCCESS; +} + +static int32_t SetProximityEnable(void) +{ + int32_t ret; + struct ProximityDrvData *drvData = ProximityGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(drvData->proximityCfg, HDF_ERR_INVALID_PARAM); + + if (drvData->enable) { + HDF_LOGE("%s: proximity sensor is enabled", __func__); + return HDF_SUCCESS; + } + + ret = SetSensorRegCfgArray(&drvData->proximityCfg->busCfg, drvData->proximityCfg->regCfgGroup[SENSOR_ENABLE_GROUP]); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: proximity sensor enable config failed", __func__); + return ret; + } + + ret = OsalTimerCreate(&drvData->proximityTimer, SENSOR_TIMER_MIN_TIME, ProximityTimerEntry, (uintptr_t)drvData); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: proximity create timer failed[%d]", __func__, ret); + return ret; + } + + ret = OsalTimerStartLoop(&drvData->proximityTimer); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: proximity start timer failed[%d]", __func__, ret); + return ret; + } + drvData->enable = true; + + return HDF_SUCCESS; +} + +static int32_t SetProximityDisable(void) +{ + int32_t ret; + struct ProximityDrvData *drvData = ProximityGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(drvData->proximityCfg, HDF_ERR_INVALID_PARAM); + + if (!drvData->enable) { + HDF_LOGE("%s: proximity sensor had disable", __func__); + return HDF_SUCCESS; + } + + ret = SetSensorRegCfgArray(&drvData->proximityCfg->busCfg, + drvData->proximityCfg->regCfgGroup[SENSOR_DISABLE_GROUP]); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: proximity sensor disable config failed", __func__); + return ret; + } + + ret = OsalTimerDelete(&drvData->proximityTimer); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: proximity delete timer failed", __func__); + return ret; + } + drvData->enable = false; + return HDF_SUCCESS; +} + +static int32_t SetProximityBatch(int64_t samplingInterval, int64_t interval) +{ + (void)interval; + + struct ProximityDrvData *drvData = NULL; + + drvData = ProximityGetDrvData(); + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + drvData->interval = samplingInterval; + + return HDF_SUCCESS; +} + +static int32_t SetProximityMode(int32_t mode) +{ + return (mode == SENSOR_WORK_MODE_REALTIME) ? HDF_SUCCESS : HDF_FAILURE; +} + +static int32_t SetProximityOption(uint32_t option) +{ + (void)option; + return HDF_SUCCESS; +} + +static int32_t DispatchProximity(struct HdfDeviceIoClient *client, + int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)client; + (void)cmd; + (void)data; + (void)reply; + + return HDF_SUCCESS; +} + +int32_t ProximityBindDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + + HDF_LOGI("%s: enter", __func__); + struct ProximityDrvData *drvData = (struct ProximityDrvData *)OsalMemCalloc(sizeof(*drvData)); + if (drvData == NULL) { + HDF_LOGI("%s: malloc proximity drv data fail!", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + drvData->ioService.Dispatch = DispatchProximity; + drvData->device = device; + device->service = &drvData->ioService; + g_proximityDrvData = drvData; + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +static int32_t InitProximityOps(struct SensorCfgData *config, struct SensorDeviceInfo *deviceInfo) +{ + struct ProximityDrvData *drvData = ProximityGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + deviceInfo->ops.Enable = SetProximityEnable; + deviceInfo->ops.Disable = SetProximityDisable; + deviceInfo->ops.SetBatch = SetProximityBatch; + deviceInfo->ops.SetMode = SetProximityMode; + deviceInfo->ops.SetOption = SetProximityOption; + + if (memcpy_s(&deviceInfo->sensorInfo, sizeof(deviceInfo->sensorInfo), + &config->sensorInfo, sizeof(config->sensorInfo)) != EOK) { + HDF_LOGE("%s: Copy sensor info failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t InitProximityAfterDetected(struct SensorCfgData *config) +{ + struct SensorDeviceInfo deviceInfo; + CHECK_NULL_PTR_RETURN_VALUE(config, HDF_ERR_INVALID_PARAM); + + if (InitProximityOps(config, &deviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: Init proximity ops failed", __func__); + return HDF_FAILURE; + } + + if (AddSensorDevice(&deviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: Add proximity device failed", __func__); + return HDF_FAILURE; + } + + if (ParseSensorRegConfig(config) != HDF_SUCCESS) { + HDF_LOGE("%s: Parse sensor register failed", __func__); + (void)DeleteSensorDevice(&config->sensorInfo); + ReleaseSensorAllRegConfig(config); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +struct SensorCfgData *ProximityCreateCfgData(const struct DeviceResourceNode *node) +{ + struct ProximityDrvData *drvData = ProximityGetDrvData(); + + if (drvData == NULL || node == NULL) { + HDF_LOGE("%s: Proximity node pointer NULL", __func__); + return NULL; + } + + if (drvData->detectFlag) { + HDF_LOGE("%s: Proximity sensor have detected", __func__); + return NULL; + } + + if (drvData->proximityCfg == NULL) { + HDF_LOGE("%s: Proximity proximityCfg pointer NULL", __func__); + return NULL; + } + + if (GetSensorBaseConfigData(node, drvData->proximityCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Get sensor base config failed", __func__); + goto BASE_CONFIG_EXIT; + } + + if (DetectSensorDevice(drvData->proximityCfg) != HDF_SUCCESS) { + HDF_LOGI("%s: Proximity sensor detect device no exist", __func__); + drvData->detectFlag = false; + goto BASE_CONFIG_EXIT; + } + + drvData->detectFlag = true; + if (InitProximityAfterDetected(drvData->proximityCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: Proximity sensor detect device no exist", __func__); + goto INIT_EXIT; + } + return drvData->proximityCfg; + +INIT_EXIT: + (void)ReleaseSensorBusHandle(&drvData->proximityCfg->busCfg); +BASE_CONFIG_EXIT: + drvData->proximityCfg->root = NULL; + (void)memset_s(&drvData->proximityCfg->sensorInfo, sizeof(struct SensorBasicInfo), + 0, sizeof(struct SensorBasicInfo)); + (void)memset_s(&drvData->proximityCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg)); + (void)memset_s(&drvData->proximityCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr)); + return drvData->proximityCfg; +} + +void ProximityReleaseCfgData(struct SensorCfgData *proximityCfg) +{ + CHECK_NULL_PTR_RETURN(proximityCfg); + + (void)DeleteSensorDevice(&proximityCfg->sensorInfo); + ReleaseSensorAllRegConfig(proximityCfg); + (void)ReleaseSensorBusHandle(&proximityCfg->busCfg); + + proximityCfg->root = NULL; + (void)memset_s(&proximityCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo)); + (void)memset_s(&proximityCfg->busCfg, sizeof(struct SensorBusCfg), 0, sizeof(struct SensorBusCfg)); + (void)memset_s(&proximityCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr)); +} + +int32_t ProximityInitDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + struct ProximityDrvData *drvData = (struct ProximityDrvData *)device->service; + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + if (InitProximityData(drvData) != HDF_SUCCESS) { + HDF_LOGE("%s: Init accel config failed", __func__); + return HDF_FAILURE; + } + + drvData->proximityCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->proximityCfg)); + if (drvData->proximityCfg == NULL) { + HDF_LOGE("%s: Malloc proximity config data failed", __func__); + return HDF_FAILURE; + } + + drvData->proximityCfg->regCfgGroup = &g_regCfgGroup[0]; + + HDF_LOGI("%s: Init proximity driver success", __func__); + return HDF_SUCCESS; +} + +void ProximityReleaseDriver(struct HdfDeviceObject *device) +{ + HDF_LOGI("%s: enter", __func__); + CHECK_NULL_PTR_RETURN(device); + + struct ProximityDrvData *drvData = (struct ProximityDrvData *)device->service; + CHECK_NULL_PTR_RETURN(drvData); + + if (drvData->detectFlag && drvData->proximityCfg != NULL) { + ProximityReleaseCfgData(drvData->proximityCfg); + } + + OsalMemFree(drvData->proximityCfg); + drvData->proximityCfg = NULL; + + HdfWorkDestroy(&drvData->proximityWork); + HdfWorkQueueDestroy(&drvData->proximityWorkQueue); + OsalMemFree(drvData); +} + +struct HdfDriverEntry g_sensorProximityDevEntry = { + .moduleVersion = 1, + .moduleName = "HDF_SENSOR_PROXIMITY", + .Bind = ProximityBindDriver, + .Init = ProximityInitDriver, + .Release = ProximityReleaseDriver, +}; + +HDF_INIT(g_sensorProximityDevEntry); \ No newline at end of file diff --git a/model/sensor/driver/proximity/sensor_proximity_driver.h b/model/sensor/driver/proximity/sensor_proximity_driver.h new file mode 100644 index 0000000000000000000000000000000000000000..7a58f4264c38fa82cfd0fcca1365829665d289c0 --- /dev/null +++ b/model/sensor/driver/proximity/sensor_proximity_driver.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 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 SENSOR_PROXIMITY_DRIVER_H +#define SENSOR_PROXIMITY_DRIVER_H + +#include "hdf_workqueue.h" +#include "osal_timer.h" +#include "sensor_config_parser.h" +#include "sensor_platform_if.h" + +struct ProximityData { + uint8_t stateFlag; +}; + +struct ProximityOpsCall { + int32_t (*Init)(struct SensorCfgData *data); + int32_t (*ReadData)(struct SensorCfgData *data); +}; + +struct ProximityDrvData { + struct IDeviceIoService ioService; + struct HdfDeviceObject *device; + HdfWorkQueue proximityWorkQueue; + HdfWork proximityWork; + OsalTimer proximityTimer; + bool detectFlag; + bool enable; + int64_t interval; + struct SensorCfgData *proximityCfg; + struct ProximityOpsCall ops; +}; + +struct SensorCfgData *ProximityCreateCfgData(const struct DeviceResourceNode *node); +int32_t ProximityRegisterChipOps(const struct ProximityOpsCall *ops); +void ProximityReleaseCfgData(struct SensorCfgData *proximityCfg); + +#endif /* SENSOR_PROXIMITY_DRIVER_H */ diff --git a/model/storage/include/common/storage_block.h b/model/storage/include/common/storage_block.h deleted file mode 100644 index 726c84d13ad98b64b93fc635b8d3c187b3f57f5e..0000000000000000000000000000000000000000 --- a/model/storage/include/common/storage_block.h +++ /dev/null @@ -1,77 +0,0 @@ -/* - * 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 STORAGE_BLOCK_H -#define STORAGE_BLOCK_H - -#include "storage.h" - -#ifdef __cplusplus -#if __cplusplus -extern "C" { -#endif -#endif /* __cplusplus */ - -#define STORAGE_SEC_SIZE 512 -#define STORAGE_SEC_SHIFT 9 -#define STORAGE_MAX_SEC_NR (STORAGE_MAX_BYTES >> STORAGE_SEC_SHIFT) - -#define STORAGE_SEC_PARAM_INVALID(s, n) \ - (s >= STORAGE_MAX_SEC_NR || \ - n >= STORAGE_MAX_SEC_NR || \ - (STORAGE_MAX_SEC_NR - n) <= s) - -#define BLOCK_NAME_LEN 32 - -struct StorageBlock { - char name[BLOCK_NAME_LEN]; /* name of the block device */ - int32_t index; - enum StorageType type; /* indicate which type of media is used */ - bool removeable; - void *media; /* media device of the block */ - size_t capacity; /* sized by sector */ - size_t secSize; /* sized by bytes */ - uint32_t errCnt; /* err count on io transfer */ - struct StorageBlockMethod *ops; /* storage oparations provided by specific media */ - void *bops; /* block operations of specific os */ -}; - -struct StorageBlockMethod { - ssize_t (*read)(struct StorageBlock *sb, uint8_t *buf, size_t secStart, size_t secNr); - ssize_t (*write)(struct StorageBlock *sb, const uint8_t *buf, size_t secStart, size_t secNr); - ssize_t (*erase)(struct StorageBlock *sb, size_t secStart, size_t secNr); - size_t (*getCapacity)(struct StorageBlock *sb); - bool (*isPresent)(struct StorageBlock *sb); - uint32_t (*getAuSize)(struct StorageBlock *sb); -}; - -ssize_t StorageBlockRead(struct StorageBlock *sb, uint8_t *buf, size_t secStart, size_t secNr); -ssize_t StorageBlockWrite(struct StorageBlock *sb, const uint8_t *buf, size_t secStart, size_t secNr); -ssize_t StorageBlockErase(struct StorageBlock *sb, size_t secStart, size_t secNr); -size_t StorageBlockGetCapacity(struct StorageBlock *sb); -bool StorageBlockIsPresent(struct StorageBlock *sb); -int32_t StorageBlockGetAuSize(struct StorageBlock *sb, uint32_t *auSize); - -int32_t StorageBlockAdd(struct StorageBlock *sb); -void StorageBlockDel(struct StorageBlock *sb); - -/* these two functions gona implemented by specific os */ -int32_t StorageBlockOsInit(struct StorageBlock *sb); -void StorageBlockOsUninit(struct StorageBlock *sb); - -ssize_t StorageBlockMmcErase(uint32_t blockId, size_t secStart, size_t secNr); -struct StorageBlock *StorageBlockFromNumber(uint32_t number); - - -#ifdef __cplusplus -#if __cplusplus -} -#endif -#endif /* __cplusplus */ - -#endif /* STORAGE_BLOCK_H */ diff --git a/model/storage/include/mmc/mmc_block.h b/model/storage/include/mmc/mmc_block.h new file mode 100644 index 0000000000000000000000000000000000000000..a1c91c16f79887b510900df38ee81624a9d599ee --- /dev/null +++ b/model/storage/include/mmc/mmc_block.h @@ -0,0 +1,113 @@ +/* + * 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 MMC_BLOCK_H +#define MMC_BLOCK_H + +#include "mmc_corex.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/** + * @Defines the default mmc sector size + * + */ +#define MMC_SEC_SIZE 512 + +/** + * @Defines the default mmc sector size shift + * + */ +#define MMC_SEC_SHIFT 9 + +/** + * @Defines the help macro for getting sector number + * + */ +#define MMC_MAX_SEC_NR (MMC_MAX_BYTES >> MMC_SEC_SHIFT) + +#define MMC_SEC_PARAM_INVALID(s, n) \ + (s >= MMC_MAX_SEC_NR || \ + n >= MMC_MAX_SEC_NR || \ + (MMC_MAX_SEC_NR - n) <= s) + +/** + * @Defines the max length of mmc block device name + * + */ +#define MMC_BLOCK_NAME_LEN 32 + +/** + * @Defines the structure used to identify a general block device. + * + */ +struct MmcBlock { + char name[MMC_BLOCK_NAME_LEN]; /* name of the block device */ + int32_t index; + bool removeable; + size_t capacity; /* sized by sector */ + size_t secSize; /* sized by bytes */ + uint32_t errCnt; /* err count on io transfer */ + void *bops; /* block operations of specific os */ + void *osData; /* os specific data */ + struct MmcDevice *mmc; +}; + +/** + * @brief Block device init for the mmc device. + * + * This function behaves differently in different OS + * + * @param mmcDevice Indicates the pointer to the mmc device. + * + * @return Returns 0 if init successfully; returns a negative value otherwise. + */ +int32_t MmcBlockInit(struct MmcDevice *mmcDevice); + +/** + * @brief Block device uninit for the mmc device. + * + * This function behaves differently in different OS + * + * @param mmcDevice Indicates the pointer to the mmc device. + * + */ +void MmcBlockUninit(struct MmcDevice *mmcDevice); + +/** + * @brief Block device init for the mmc device in specific os. + * + * These function gona be implemented by specific os + * + * @param mmcDevice Indicates the pointer to the mmc device. + * + * @return Returns 0 if init successfully; returns a negative value otherwise. + */ +int32_t MmcBlockOsInit(struct MmcDevice *mmcDevice); + +/** + * @brief Block device uninit for the mmc device in specific os. + * + * These function gona be implemented by specific os + * + * @param mmcDevice Indicates the pointer to the mmc device. + * + */ +void MmcBlockOsUninit(struct MmcDevice *mmcDevice); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* MMC_BLOCK_H */ diff --git a/support/platform/include/mmc/mmc_caps.h b/model/storage/include/mmc/mmc_caps.h similarity index 100% rename from support/platform/include/mmc/mmc_caps.h rename to model/storage/include/mmc/mmc_caps.h diff --git a/support/platform/include/mmc/mmc_corex.h b/model/storage/include/mmc/mmc_corex.h similarity index 98% rename from support/platform/include/mmc/mmc_corex.h rename to model/storage/include/mmc/mmc_corex.h index f3c2afdaf9b541f6dc16fd57e0b1883d7e6f5790..4cd5f319c4fa453f0a1fcf49d8f2af74ef1c5604 100644 --- a/support/platform/include/mmc/mmc_corex.h +++ b/model/storage/include/mmc/mmc_corex.h @@ -110,7 +110,7 @@ static inline struct MmcCntlr *MmcCntlrGet(struct MmcCntlr *cntlr) static inline struct MmcCntlr *MmcCntlrGetByNr(uint16_t number) { - struct PlatformDevice *device = PlatformManagerGetDeviceByMagic(PlatformManagerGet(PLATFORM_MODULE_MMC), number); + struct PlatformDevice *device = PlatformManagerGetDeviceByNumber(PlatformManagerGet(PLATFORM_MODULE_MMC), number); if (device == NULL) { return NULL; @@ -224,7 +224,7 @@ struct MmcDevice { size_t secSize; // by bytes size_t capacity; // by sectors size_t eraseSize; // by sectors - struct StorageBlock *sb; + struct MmcBlock *mb; void *priv; }; diff --git a/support/platform/include/mmc/mmc_dispatch.h b/model/storage/include/mmc/mmc_dispatch.h similarity index 100% rename from support/platform/include/mmc/mmc_dispatch.h rename to model/storage/include/mmc/mmc_dispatch.h diff --git a/support/platform/include/mmc/mmc_emmc.h b/model/storage/include/mmc/mmc_emmc.h similarity index 100% rename from support/platform/include/mmc/mmc_emmc.h rename to model/storage/include/mmc/mmc_emmc.h diff --git a/support/platform/include/mmc/mmc_protocol.h b/model/storage/include/mmc/mmc_protocol.h similarity index 100% rename from support/platform/include/mmc/mmc_protocol.h rename to model/storage/include/mmc/mmc_protocol.h diff --git a/support/platform/include/mmc/mmc_sd.h b/model/storage/include/mmc/mmc_sd.h similarity index 100% rename from support/platform/include/mmc/mmc_sd.h rename to model/storage/include/mmc/mmc_sd.h diff --git a/support/platform/include/mmc/mmc_sdio.h b/model/storage/include/mmc/mmc_sdio.h similarity index 100% rename from support/platform/include/mmc/mmc_sdio.h rename to model/storage/include/mmc/mmc_sdio.h diff --git a/model/storage/include/mtd/mtd_block.h b/model/storage/include/mtd/mtd_block.h index c1dc005ac9aff0d48ab0fa1c85f0e986725896ed..9d82c4db0b32a22a7f600b1a72d87f34e8bcf423 100644 --- a/model/storage/include/mtd/mtd_block.h +++ b/model/storage/include/mtd/mtd_block.h @@ -17,12 +17,47 @@ extern "C" { #endif #endif /* __cplusplus */ -int32_t MtdBlockInit(struct MtdDevice *mtd); -void MtdBlockUninit(struct MtdDevice *mtd); +/** + * @brief Block device init for the mtd device. + * + * This function behaves differently in different OS + * + * @param mtdDevice Indicates the pointer to the mtd device. + * + * @return Returns 0 if init successfully; returns a negative value otherwise. + */ +int32_t MtdBlockInit(struct MtdDevice *mtdDevice); + +/** + * @brief Block device uninit for the mtd device. + * + * This function behaves differently in different OS + * + * @param mtdDevice Indicates the pointer to the mtd device. + * + */ +void MtdBlockUninit(struct MtdDevice *mtdDevice); -/* these too functions gona implemented by specific os */ -extern int32_t MtdBlockOsInit(struct MtdDevice *mtd); -extern void MtdBlockOsUninit(struct MtdDevice *mtd); +/** + * @brief Block device init for the mtd device in specific os. + * + * These function gona be implemented by specific os + * + * @param mtdDevice Indicates the pointer to the mtd device. + * + * @return Returns 0 if init successfully; returns a negative value otherwise. + */ +int32_t MtdBlockOsInit(struct MtdDevice *mtd); + +/** + * @brief Block device uninit for the mtd device in specific os. + * + * These function gona be implemented by specific os + * + * @param mtdDevice Indicates the pointer to the mtd device. + * + */ +void MtdBlockOsUninit(struct MtdDevice *mtd); #ifdef __cplusplus #if __cplusplus diff --git a/model/storage/include/mtd/mtd_char.h b/model/storage/include/mtd/mtd_char.h index 3d32a273680778869c23b50151435844a0a492c8..80b8ff4ff6d2535ee2ac59ac6924d8557dcc2b70 100644 --- a/model/storage/include/mtd/mtd_char.h +++ b/model/storage/include/mtd/mtd_char.h @@ -19,12 +19,47 @@ extern "C" { #define CHAR_NAME_LEN 32 +/** + * @brief Char device init for the mtd device. + * + * This function behaves differently in different OS + * + * @param mtdDevice Indicates the pointer to the mtd device. + * + * @return Returns 0 if init successfully; returns a negative value otherwise. + */ int32_t MtdCharInit(struct MtdDevice *mtdDevice); + +/** + * @brief Char device uninit for the mtd device. + * + * This function behaves differently in different OS + * + * @param mtdDevice Indicates the pointer to the mtd device. + * + */ void MtdCharUninit(struct MtdDevice *mtdDevice); -/* these too functions gona implemented by specific os */ -extern int32_t MtdCharOsInit(struct MtdDevice *mtdDevice); -extern void MtdCharOsUninit(struct MtdDevice *mtdDevice); +/** + * @brief Char device init for the mtd device in specific OS. + * + * These function gona be implemented by specific os + * + * @param mtdDevice Indicates the pointer to the mtd device. + * + * @return Returns 0 if init successfully; returns a negative value otherwise. + */ +int32_t MtdCharOsInit(struct MtdDevice *mtdDevice); + +/** + * @brief Char device uninit for the mtd device in specific OS. + * + * These function gona be implemented by specific os + * + * @param mtdDevice Indicates the pointer to the mtd device. + * + */ +void MtdCharOsUninit(struct MtdDevice *mtdDevice); #ifdef __cplusplus #if __cplusplus diff --git a/model/storage/include/mtd/mtd_core.h b/model/storage/include/mtd/mtd_core.h index 4b1f311903fbec7402e618b24f55a48b4bfc5009..6a384ecf3ce14815a6f8aac5d38ade0d1fc0a17c 100644 --- a/model/storage/include/mtd/mtd_core.h +++ b/model/storage/include/mtd/mtd_core.h @@ -13,15 +13,20 @@ #include "hdf_base.h" #include "osal_mutex.h" -#include "platform_device.h" +#include "platform_core.h" #define MTD_FLASH_ID_LEN_MAX 8 +#define MTD_DEVICE_NUM_MAX 3 -// #define MTD_DEBUG /* open this macro for debug */ +// #define MTD_DEBUG /* open this macro for debug struct MtdDevice; struct MtdDeviceMethod; +/** + * @brief Enumerates the types of mtd devices. + * + */ enum MtdDevType { MTD_TYPE_NOR, MTD_TYPE_NAND, @@ -30,32 +35,68 @@ enum MtdDevType { MTD_TYPE_MAX, }; +/** + * @brief Enumerates the types of mtd message. + * + */ enum MtdMsgType { MTD_MSG_TYPE_WRITE, MTD_MSG_TYPE_READ, MTD_MSG_TYPE_ERASE, }; +/** + * @Defines the mtd request message used during request. + * + * This struct describes a custom access request typed by MtdMsgType + * + */ struct MtdMsg { + /** Type of the mtd message */ enum MtdMsgType type; + /** Start address of the mtd device to access */ off_t addr; + /** Indicates the failed address if request failed */ off_t faddr; + /** Pointer to the buffer for storing request data */ uint8_t *buf; + /** Length of the data */ size_t len; + /** Indicates whether request with oob data */ bool withOob; + /** Indicates whether skip on bad block */ bool skipBad; }; +/** + * @Defines the mtd page struct used during page transfer. + * + * This struct describes a page transfer request typed by MtdMsgType + * + */ struct MtdPage { + /** Page transfer type */ enum MtdMsgType type; + /** Start address of the mtd device to transfer from */ off_t addr; + /** Indicates the failed address if transfer failed */ off_t failAddr; + /** Pointer to the data buffer */ uint8_t *dataBuf; + /** Length of the data */ size_t dataLen; + /** Pointer to the oob data buffer */ uint8_t *oobBuf; + /** Length of the oob data */ size_t oobLen; }; +/** + * @Defines the callback method set of a mtd device. + * + * The methods defined in this struct expected to be implemented by drivers + * + */ struct MtdDeviceMethod { int32_t (*read)(struct MtdDevice *mtdDevice, off_t from, size_t len, uint8_t *buf); int32_t (*write)(struct MtdDevice *mtdDevice, off_t to, size_t len, const uint8_t *buf); @@ -68,58 +109,244 @@ struct MtdDeviceMethod { void (*unlock)(struct MtdDevice *mtdDevice); }; +/** + * @Defines the structure used to identify a physical mtd chip. + * + */ struct MtdDevice { + /** The parent device */ struct PlatformDevice device; + /** Number of the mtd device */ int16_t index; + /** Name of the mtd device */ const char *name; + /** Chip name of the mtd device */ const char *chipName; + /** Type of the mtd device */ enum MtdDevType type; union { + /** Vendor id of the mtd device */ uint8_t id[MTD_FLASH_ID_LEN_MAX]; struct { uint8_t mfrId; // id[0]: Manufacture ID uint8_t devId; // id[0]: Device ID }; }; + /** Length of the vendor id */ uint16_t idLen; - size_t capacity; // by bytes - size_t eraseSize; // by bytes - size_t writeSize; // by bytes - size_t readSize; // by bytes - size_t oobSize; // for nand only + /** Length of the vendor id */ + size_t capacity; + /** Erase size of the mtd device */ + size_t eraseSize; + /** Write size of the mtd device */ + size_t writeSize; + /** Read size of the mtd device */ + size_t readSize; + /** Oob size of the mtd device */ + size_t oobSize; + /** Write size shift bits of the mtd device */ unsigned int writeSizeShift; + /** Mutex lock for accessing protection */ struct OsalMutex lock; + /** The callback method set to access the device */ struct MtdDeviceMethod *ops; + /** Os specific data */ void *osData; + /** Flash memory controller specific data */ void *cntlr; + /** Private data of the mtd device */ void *priv; }; +/** + * @brief Get the manager of mtd + * + * @return Returns the pointer to the manager if success; + * returns NULL otherwise. + */ +struct PlatformManager *MtdManagerGet(void); + +/** + * @brief Add a mtd device. + * + * do not call in irq context cause it may sleep + * + * @param mtdDevice Indicates the pointer to the mtd device. + * + * @return Returns 0 if add successfully; returns a negative value otherwise. + */ int32_t MtdDeviceAdd(struct MtdDevice *mtdDevice); + +/** + * @brief Delete a mtd device. + * + * do not call in irq context cause it may sleep + * + * @param mtdDevice Indicates the pointer to the mtd device. + */ void MtdDeviceDel(struct MtdDevice *mtdDevice); +/** + * @brief Increase reference count for a mtd device. + * + * @param mtdDevice Indicates the pointer to the mtd device. + * + * @return Returns the pointer to the mtd device on success; returns NULL otherwise. + */ +static inline struct MtdDevice *MtdDeviceGet(struct MtdDevice *mtdDevice) +{ + if (mtdDevice != NULL && PlatformDeviceGet(&mtdDevice->device) != NULL) { + return mtdDevice; + } + return NULL; +} + +/** + * @brief Increase reference count for a mtd device by number. + * + * @param mtdDevice Indicates the pointer to the mtd device. + * + * @return Returns the pointer to the mtd device on success; returns NULL otherwise. + */ +static inline struct MtdDevice *MtdDeviceGetByNum(int16_t num) +{ + struct PlatformDevice *device = PlatformManagerGetDeviceByNumber(MtdManagerGet(), num); + + if (device != NULL) { + return CONTAINER_OF(device, struct MtdDevice, device); + } + return NULL; +} + +/** + * @brief Decrease reference count for a mtd device. + * + * @param mtdDevice Indicates the pointer to the mtd device. + */ +static inline void MtdDevicePut(struct MtdDevice *mtdDevice) +{ + if (mtdDevice != NULL) { + PlatformDevicePut(&mtdDevice->device); + } +} + +/** + * @brief Lock the mtd device exclusivly. + * + * do not call in irq context cause it may sleep + * + * @param mtdDevice Indicates the pointer to the mtd device. + * + * @return Returns 0 on success; returns a negative value otherwise. + */ int32_t MtdDeviceLock(struct MtdDevice *mtdDevice); + +/** + * @brief Unlock the mtd device. + * + * do not call in irq context cause it may sleep + * + * @param mtdDevice Indicates the pointer to the mtd device. + */ void MtdDeviceUnlock(struct MtdDevice *mtdDevice); +/** + * @brief Reads data of a specified size from a mtd device. + * + * do not call in irq context cause it may sleep + * + * @param mtdDevice Indicates the pointer to the mtd device. + * @param from Indicates the start address to read from. + * @param len Indicates the size of the data to read. + * @param buf Indicates the pointer to the buffer for receiving the data. + * + * @return Returns the size of the data read on success; returns a negative value otherwise. + */ ssize_t MtdDeviceRead(struct MtdDevice *mtdDevice, off_t from, size_t len, uint8_t *buf); + +/** + * @brief Writes data of a specified size to a mtd device. + * + * do not call in irq context cause it may sleep + * + * @param mtdDevice Indicates the pointer to the mtd device. + * @param to Indicates the start address to write to. + * @param len Indicates the size of the data to write. + * @param buf Indicates the pointer to the buffer which provide the data. + * + * @return Returns the size of the data written on success; returns a negative value otherwise. + */ ssize_t MtdDeviceWrite(struct MtdDevice *mtdDevice, off_t to, size_t len, const uint8_t *buf); -ssize_t MtdDeviceErase(struct MtdDevice *mtdDevice, off_t from, size_t len, off_t *failAddr); +/** + * @brief Erases data of a specified size to a mtd device. + * + * do not call in irq context cause it may sleep + * + * @param mtdDevice Indicates the pointer to the mtd device. + * @param from Indicates the start address to erase from. + * @param len Indicates the size of the data to erase. + * @param faddr Indicates the pointer for receiving the address when erasing failed. + * + * @return Returns the size of the data erased on success; returns a negative value otherwise. + */ +ssize_t MtdDeviceErase(struct MtdDevice *mtdDevice, off_t from, size_t len, off_t *faddr); + +/** + * @brief Reads data of a specified size from a mtd device including oob data. + * + * It is similar to MtdDeviceRead but read oob data together. + * + * @param mtdDevice Indicates the pointer to the mtd device. + * @param from Indicates the start address to read from. + * @param len Indicates the size of the data, including oob, to read. + * @param buf Indicates the pointer to the buffer for receiving the data, including oob data. + * + * @return Returns the size of the data read on success; returns a negative value otherwise. + */ ssize_t MtdDeviceReadWithOob(struct MtdDevice *mtdDevice, off_t from, size_t len, uint8_t *buf); + +/** + * @brief Writes data of a specified size to a mtd device including oob data. + * + * It is similar to MtdDeviceWrite but write oob data together. + * + * @param mtdDevice Indicates the pointer to the mtd device. + * @param to Indicates the start address to write to. + * @param len Indicates the size of the data, including oob, to . + * @param buf Indicates the pointer to the buffer which provide the data including oob. + * + * @return Returns the size of the data read on success; returns a negative value otherwise. + */ ssize_t MtdDeviceWriteWithOob(struct MtdDevice *mtdDevice, off_t to, size_t len, const uint8_t *buf); + +/** + * @brief Judge whether the block where the specified address is located is a bad block + * + * @param mtdDevice Indicates the pointer to the mtd device. + * @param addr Indicates the address to judge, which is not neccessary to align by block size. + * + * @return Returns true is the specified address falls into a bad block; returns false otherwise. + */ bool MtdDeviceIsBadBlock(struct MtdDevice *mtdDevice, off_t addr); + +/** + * @brief Mark the block where the specified address is located as a bad block + * + * @param mtdDevice Indicates the pointer to the mtd device. + * @param addr Indicates the address to mark, which is not neccessary to align by block size. + * + * @return Returns 0 on success; returns a negative value otherwise. + */ int32_t MtdDeviceMarkBadBlock(struct MtdDevice *mtdDevice, off_t addr); -static inline bool MtdDeviceIsPageAligned(struct MtdDevice *mtdDevice, off_t addr) -{ - return ((addr & (mtdDevice->writeSize - 1)) == 0); -} -static inline size_t MtdDeviceAddrToPage(struct MtdDevice *mtdDevice, off_t addr) -{ - return (size_t)(addr >> mtdDevice->writeSizeShift); -} +/***************************** Other Utils *******************************************/ +/** + * @brief A debugging macro which an dump all the attributes of a mtd device + * + */ #define MTD_DEVICE_DUMP(mtd) \ do { \ uint16_t i; \ @@ -134,9 +361,28 @@ static inline size_t MtdDeviceAddrToPage(struct MtdDevice *mtdDevice, off_t addr HDF_LOGI("%s: oobSize: %zu", __func__, mtd->oobSize); \ } while (0) +/** + * @brief Judge whether the specified address is aligned by page size + * + */ +static inline bool MtdDeviceIsPageAligned(struct MtdDevice *mtdDevice, off_t addr) +{ + return ((addr & (mtdDevice->writeSize - 1)) == 0); +} -/***************************** Other Utils *******************************************/ +/** + * @brief Transfer the specified address to page number + * + */ +static inline size_t MtdDeviceAddrToPage(struct MtdDevice *mtdDevice, off_t addr) +{ + return (size_t)(addr >> mtdDevice->writeSizeShift); +} +/** + * @brief Flush the cache for dma transfer + * + */ static inline void MtdDmaCacheClean(void *addr, size_t size) { uintptr_t start = (uintptr_t)addr & ~(CACHE_ALIGNED_SIZE - 1); @@ -147,6 +393,10 @@ static inline void MtdDmaCacheClean(void *addr, size_t size) return; } +/** + * @brief Invalid the cache for dma transfer + * + */ static inline void MtdDmaCacheInv(void *addr, size_t size) { uintptr_t start = (uintptr_t)addr & ~(CACHE_ALIGNED_SIZE - 1); @@ -157,6 +407,11 @@ static inline void MtdDmaCacheInv(void *addr, size_t size) return; } +/** + * @brief Find the first bit set in word + * + * @return Returns the position of first bit set; returns 0 if all zero. + */ int MtdFfs(int x); #endif /* MTD_CORE_H */ diff --git a/model/storage/include/mtd/mtd_nand.h b/model/storage/include/mtd/mtd_nand.h index 055f7c88b1451435163f02ceeb62ebd39d9cddba..01101da644ef3a3a63508d93a4e928b37a4782bf 100644 --- a/model/storage/include/mtd/mtd_nand.h +++ b/model/storage/include/mtd/mtd_nand.h @@ -18,6 +18,10 @@ extern "C" { #endif #endif /* __cplusplus */ +/** + * @brief Enumerates the page size type of a nand flash memory. + * + */ enum MtdNandPageSize { MTD_NAND_PAGE_SIZE_512 = 512, MTD_NAND_PAGE_SIZE_2K = 2048, @@ -26,6 +30,10 @@ enum MtdNandPageSize { MTD_NAND_PAGE_SIZE_16K = 16384, }; +/** + * @brief Enumerates the ECC type of a nand flash memory. + * + */ enum MtdNandEccTYpe { MTD_NAND_ECC_0BIT = 0, MTD_NAND_ECC_8BIT_1K = 1, @@ -36,6 +44,10 @@ enum MtdNandEccTYpe { MTD_NAND_ECC_64BIT_1K = 6, }; +/** + * @brief Defines the bad block area size of a nand flash memory. + * + */ #define MTD_NAND_BB_SIZE 2 #ifdef __cplusplus diff --git a/model/storage/include/mtd/mtd_spi_common.h b/model/storage/include/mtd/mtd_spi_common.h index cf46b3a5795229bc6d899e9abc713a6065ecf4b7..a55e1f099c65447babbc531b874f4d99f31ae144 100644 --- a/model/storage/include/mtd/mtd_spi_common.h +++ b/model/storage/include/mtd/mtd_spi_common.h @@ -19,14 +19,39 @@ extern "C" { struct SpiFlash; +/** + * @Defines the spi configuration of a specific operation + * + */ struct MtdSpiConfig { + /** spi interface type */ uint8_t ifType; + /** the operation command */ uint8_t cmd; + /** dummy cycles */ uint8_t dummy; + /** not used now */ uint32_t size; + /** system clock used */ uint32_t clock; }; +/** + * @brief Enumerates the type of spi interface. + * + */ +enum SpiIfType { + MTD_SPI_IF_STD = 0, + MTD_SPI_IF_DUAL = 1, + MTD_SPI_IF_DIO = 2, + MTD_SPI_IF_QUAD = 3, + MTD_SPI_IF_QIO = 4, +}; + +/** + * @Defines the spi oepration set of a mtd device. + * + */ struct MtdSpiOps { int32_t (*waitReady)(struct SpiFlash *spi); int32_t (*writeEnable)(struct SpiFlash *spi); @@ -34,38 +59,91 @@ struct MtdSpiOps { int32_t (*entry4Addr)(struct SpiFlash *spi, int enable); }; +/** + * @Defines the info structure which contains vendor id and spi operations + * + */ struct SpiOpsInfo { uint8_t id[MTD_FLASH_ID_LEN_MAX]; uint8_t idLen; struct MtdSpiOps spiOps; }; -enum SpiIfType { - MTD_SPI_IF_STD = 0, - MTD_SPI_IF_DUAL = 1, - MTD_SPI_IF_DIO = 2, - MTD_SPI_IF_QUAD = 3, - MTD_SPI_IF_QIO = 4, -}; - +/** + * @Defines the structure used to identify a physical spi flash. + * + */ struct SpiFlash { + /** The parent device */ struct MtdDevice mtd; + /** chip select number */ uint8_t cs; - uint8_t qeEnable; - uint8_t qeSupport; + /** address cycle */ uint32_t addrCycle; + /** spi configuration of erase */ struct MtdSpiConfig eraseCfg; + /** spi configuration of write */ struct MtdSpiConfig writeCfg; + /** spi configuration of read */ struct MtdSpiConfig readCfg; + /** spi operation set of the device */ struct MtdSpiOps spiOps; }; +/** + * @brief Wait for a spi flash to be ready. + * + * @param spi Indicates the pointer to the spi flash. + * + * @return Returns 0 on success; returns a negative value otherwise. + */ int32_t SpiFlashWaitReady(struct SpiFlash *spi); + +/** + * @brief Enable write operation to a spi falsh. + * + * @param spi Indicates the pointer to the spi flash. + * + * @return Returns 0 on success; returns a negative value otherwise. + */ int32_t SpiFlashWriteEnable(struct SpiFlash *spi); + +/** + * @brief Enable QUAD I/O mode of a spi falsh if it supports. + * + * @param spi Indicates the pointer to the spi flash. + * + * @return Returns 0 on success; returns a negative value otherwise. + */ int32_t SpiFlashQeEnable(struct SpiFlash *spi); + +/** + * @brief Enable 4 byte address mode of a spi falsh if it supports. + * + * @param spi Indicates the pointer to the spi flash. + * + * @return Returns 0 on success; returns a negative value otherwise. + */ int32_t SpiFlashEntry4Addr(struct SpiFlash *spi, int enable); +/** + * @brief Add a spi flash device. + * + * do not call in irq context cause it may sleep + * + * @param spi Indicates the pointer to the spi flash device. + * + * @return Returns 0 if add successfully; returns a negative value otherwise. + */ int32_t SpiFlashAdd(struct SpiFlash *spi); + +/** + * @brief Delete a spi flash device. + * + * do not call in irq context cause it may sleep + * + * @param spi Indicates the pointer to the spi flash device. + */ void SpiFlashDel(struct SpiFlash *spi); /****************************Spi Common Command Set **************************************/ @@ -117,7 +195,6 @@ void SpiFlashDel(struct SpiFlash *spi); #ifdef __cplusplus #if __cplusplus - } #endif #endif /* __cplusplus */ diff --git a/model/storage/include/mtd/mtd_spi_nand.h b/model/storage/include/mtd/mtd_spi_nand.h index 76b3e7ecb8ea366ed7bd76935e764d1f8d030c41..eb8a3dce0505243cbf73411a04719d47a2aa971a 100644 --- a/model/storage/include/mtd/mtd_spi_nand.h +++ b/model/storage/include/mtd/mtd_spi_nand.h @@ -41,6 +41,10 @@ extern "C" { #define MTD_SPI_NAND_ERASE_FAIL 0x04 #define MTD_SPI_NAND_PROG_FAIL 0x08 +/** + * @Defines the structure used to describe a spi nand flash. + * + */ struct SpinandInfo { const char *name; uint8_t id[MTD_FLASH_ID_LEN_MAX]; diff --git a/model/storage/include/mtd/mtd_spi_nor.h b/model/storage/include/mtd/mtd_spi_nor.h index fd1e210eb313cdac659fef6c2e6593a781614276..cab675bb1da1914845de13da23931a132f022f62 100644 --- a/model/storage/include/mtd/mtd_spi_nor.h +++ b/model/storage/include/mtd/mtd_spi_nor.h @@ -23,6 +23,10 @@ extern "C" { #define MTD_SPI_ADDR_3BYTE 3 #define MTD_SPI_ADDR_4BYTE 4 +/** + * @Defines the structure used to describe a spi nor flash. + * + */ struct SpinorInfo { const char *name; uint8_t id[MTD_FLASH_ID_LEN_MAX]; diff --git a/model/storage/src/common/storage_block.c b/model/storage/src/common/storage_block.c deleted file mode 100644 index 54733351e5e9899bc54e35d91473f2f9c5847f05..0000000000000000000000000000000000000000 --- a/model/storage/src/common/storage_block.c +++ /dev/null @@ -1,132 +0,0 @@ -/* - * 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_base.h" -#include "hdf_log.h" -#include "platform_core.h" -#include "storage_block.h" - -#define HDF_LOG_TAG storage_block_c - -#define MAX_BLOCK_COUNT 3 - -static struct StorageBlock *g_blocks[MAX_BLOCK_COUNT]; - -ssize_t StorageBlockErase(struct StorageBlock *sb, size_t secStart, size_t secNr) -{ - if (sb == NULL) { - return HDF_ERR_INVALID_OBJECT; - } - if (sb->ops == NULL || sb->ops->erase == NULL) { - return HDF_ERR_NOT_SUPPORT; - } - return sb->ops->erase(sb, secStart, secNr); -} - -ssize_t StorageBlockWrite(struct StorageBlock *sb, const uint8_t *buf, size_t secStart, size_t secNr) -{ - if (sb == NULL) { - return HDF_ERR_INVALID_OBJECT; - } - if (sb->ops == NULL || sb->ops->write == NULL) { - return HDF_ERR_NOT_SUPPORT; - } - return sb->ops->write(sb, buf, secStart, secNr); -} - -ssize_t StorageBlockRead(struct StorageBlock *sb, uint8_t *buf, size_t secStart, size_t secNr) -{ - if (sb == NULL) { - return HDF_ERR_INVALID_OBJECT; - } - if (sb->ops == NULL || sb->ops->read == NULL) { - return HDF_ERR_NOT_SUPPORT; - } - return sb->ops->read(sb, buf, secStart, secNr); -} - -int32_t StorageBlockGetAuSize(struct StorageBlock *sb, uint32_t *auSize) -{ - if (sb == NULL) { - return HDF_ERR_INVALID_OBJECT; - } - if (sb->ops == NULL || sb->ops->getAuSize == NULL) { - return HDF_ERR_NOT_SUPPORT; - } - *auSize = sb->ops->getAuSize(sb); - return HDF_SUCCESS; -} - -size_t StorageBlockGetCapacity(struct StorageBlock *sb) -{ - return (sb == NULL) ? 0 : sb->capacity; -} - -bool StorageBlockIsPresent(struct StorageBlock *sb) -{ - return (sb != NULL && sb->ops != NULL && - sb->ops->isPresent != NULL && sb->ops->isPresent(sb)); -} - -int32_t StorageBlockAdd(struct StorageBlock *sb) -{ - int i; - int32_t ret; - - if (sb == NULL) { - return HDF_ERR_INVALID_OBJECT; - } - - for (i = 0; i < MAX_BLOCK_COUNT; i++) { - if (g_blocks[i] == NULL) { - g_blocks[i] = sb; - sb->index = i; - break; - } - } - if (i >= MAX_BLOCK_COUNT) { - return HDF_PLT_ERR_DEV_FULL; - } - - if (sb->secSize == 0) { - sb->secSize = STORAGE_SEC_SIZE; - } - - ret = StorageBlockOsInit(sb); - if (ret != HDF_SUCCESS) { - g_blocks[i] = NULL; - return ret; - } - - return HDF_SUCCESS; -} - -void StorageBlockDel(struct StorageBlock *sb) -{ - int i; - - if (sb == NULL) { - return; - } - - for (i = 0; i < MAX_BLOCK_COUNT; i++) { - if (g_blocks[i] == sb) { - g_blocks[i] = NULL; - } - } - - StorageBlockOsUninit(sb); -} - -struct StorageBlock *StorageBlockFromNumber(uint32_t number) -{ - if (number >= MAX_BLOCK_COUNT) { - HDF_LOGE("StorageBlockFromNumber: invalid number:%d", number); - return NULL; - } - return g_blocks[number]; -} diff --git a/support/platform/src/mmc/emmc_if.c b/model/storage/src/mmc/emmc_if.c similarity index 98% rename from support/platform/src/mmc/emmc_if.c rename to model/storage/src/mmc/emmc_if.c index b3c9f206143032da4de12d4fbfdb59868ef6955f..1086295a9938f9f3b2dfe99dd19099e78b864c9d 100644 --- a/support/platform/src/mmc/emmc_if.c +++ b/model/storage/src/mmc/emmc_if.c @@ -11,12 +11,10 @@ #include "mmc_emmc.h" #endif #include "emmc_if.h" -#include "hdf_base.h" #ifdef __USER__ #include "hdf_io_service_if.h" #endif #include "hdf_log.h" -#include "osal_mem.h" #include "securec.h" #define HDF_LOG_TAG emmc_if_c @@ -112,6 +110,10 @@ static int32_t EmmcDeviceGetFromHandle(DevHandle handle, struct EmmcDevice **emm int32_t EmmcGetCid(DevHandle handle, uint8_t *cid, uint32_t size) { +#ifndef __USER__ + struct EmmcDevice *emmc = NULL; + int32_t ret; +#endif if (handle == NULL) { HDF_LOGE("EmmcGetCid: handle is NULL!"); return HDF_ERR_INVALID_OBJECT; @@ -124,9 +126,6 @@ int32_t EmmcGetCid(DevHandle handle, uint8_t *cid, uint32_t size) #ifdef __USER__ return EmmcServiceGetCid((struct HdfIoService *)handle, cid, size); #else - struct EmmcDevice *emmc = NULL; - int32_t ret; - if (EmmcDeviceGetFromHandle(handle, &emmc) != HDF_SUCCESS) { return HDF_ERR_INVALID_OBJECT; } diff --git a/model/storage/src/mmc/mmc_block.c b/model/storage/src/mmc/mmc_block.c new file mode 100644 index 0000000000000000000000000000000000000000..19a0949ab5e0c9e96d65639caf228391fec7c652 --- /dev/null +++ b/model/storage/src/mmc/mmc_block.c @@ -0,0 +1,69 @@ +/* + * 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 "securec.h" + +#include "hdf_base.h" +#include "hdf_log.h" +#include "mmc_block.h" + +#define HDF_LOG_TAG mmc_block_c + +int32_t MmcBlockInit(struct MmcDevice *mmcDevice) +{ + int32_t ret; + size_t nameSize; + struct MmcBlock *mb = NULL; + + if (mmcDevice == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + if (PlatformDeviceGet(&mmcDevice->device) == NULL) { + return HDF_PLT_ERR_DEV_GET; + } + + mb = (struct MmcBlock *)OsalMemCalloc(sizeof(*mb)); + if (mb == NULL) { + PlatformDevicePut(&mmcDevice->device); + return HDF_ERR_MALLOC_FAIL; + } + + mmcDevice->mb = mb; + mb->mmc = mmcDevice; + mb->secSize = mmcDevice->secSize; + mb->capacity = mmcDevice->capacity; + mb->removeable = (mmcDevice->state.bits.removeable == 0) ? false : true; + nameSize = sizeof(mb->name); + ret = snprintf_s(mb->name, nameSize, nameSize - 1, "/dev/mmcblk%0d", mmcDevice->cntlr->index); + if (ret <= 0) { + OsalMemFree(mb); + PlatformDevicePut(&mmcDevice->device); + HDF_LOGE("%s: format block dev name failed, ret = %d", __func__, ret); + return HDF_PLT_ERR_OS_API; + } + + ret = MmcBlockOsInit(mmcDevice); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: mmc block os init failed, ret = %d", __func__, ret); + OsalMemFree(mb); + PlatformDevicePut(&mmcDevice->device); + return ret; + } + return HDF_SUCCESS; +} + +void MmcBlockUninit(struct MmcDevice *mmcDevice) +{ + if (mmcDevice != NULL) { + MmcBlockOsUninit(mmcDevice); + OsalMemFree(mmcDevice->mb); + mmcDevice->mb = NULL; + PlatformDevicePut(&mmcDevice->device); + } +} diff --git a/support/platform/src/mmc/mmc_core.c b/model/storage/src/mmc/mmc_core.c similarity index 99% rename from support/platform/src/mmc/mmc_core.c rename to model/storage/src/mmc/mmc_core.c index 6d2670b1ae9f4f8d171de83141be8718afb98999..2b377d2e0c19ed5f792f1a14df43db1806f8beee 100644 --- a/support/platform/src/mmc/mmc_core.c +++ b/model/storage/src/mmc/mmc_core.c @@ -7,15 +7,10 @@ */ #include "device_resource_if.h" -#include "hdf_dlist.h" -#include "hdf_log.h" #include "mmc_block.h" -#include "mmc_corex.h" #include "mmc_dispatch.h" #include "mmc_emmc.h" #include "mmc_sdio.h" -#include "osal_mem.h" -#include "osal_time.h" #define HDF_LOG_TAG mmc_core_c @@ -235,7 +230,7 @@ static int32_t MmcCntlrInit(struct MmcCntlr *cntlr) cntlr->service.Dispatch = MmcIoDispatch; cntlr->hdfDevObj->service = &(cntlr->service); - cntlr->device.magic = cntlr->index; + cntlr->device.number = cntlr->index; cntlr->device.hdfDev = cntlr->hdfDevObj; return HDF_SUCCESS; } @@ -990,7 +985,7 @@ int32_t MmcDeviceAdd(struct MmcDevice *mmc) HDF_LOGE("MmcDeviceAdd: invalid erase size:%u", mmc->eraseSize); return HDF_ERR_INVALID_PARAM; } - mmc->device.magic = mmc->cntlr->device.magic + MMC_CNTLR_NR_MAX; + mmc->device.number = mmc->cntlr->device.number + MMC_CNTLR_NR_MAX; if (MmcCntlrGet(mmc->cntlr) == NULL) { return HDF_PLT_ERR_DEV_GET; @@ -1005,7 +1000,7 @@ int32_t MmcDeviceAdd(struct MmcDevice *mmc) } if (mmc->type == MMC_DEV_EMMC || mmc->type == MMC_DEV_SD || mmc->type == MMC_DEV_COMBO) { - ret = MmcBlockAdd(mmc); + ret = MmcBlockInit(mmc); if (ret != HDF_SUCCESS) { MmcCntlrPut(mmc->cntlr); PlatformDeviceDel(&mmc->device); @@ -1021,7 +1016,7 @@ void MmcDeviceRemove(struct MmcDevice *mmc) return; } if (mmc->type == MMC_DEV_EMMC || mmc->type == MMC_DEV_SD || mmc->type == MMC_DEV_COMBO) { - MmcBlockDel(mmc); + MmcBlockUninit(mmc); } PlatformDeviceDel(&mmc->device); MmcCntlrPut(mmc->cntlr); @@ -1101,6 +1096,7 @@ ssize_t MmcDeviceRead(struct MmcDevice *mmc, uint8_t *buf, size_t startSec, size } MmcDeviceFillRwInfo(&info, buf, false, curStartSec, readSec); if (mmc->cntlr->detecting == true) { + /* In SD device detecting, VFS will read/write SD. */ ret = MmcSendReadWriteBlocks(mmc->cntlr, &info); } else { cmd.data = &data; @@ -1146,6 +1142,7 @@ ssize_t MmcDeviceWrite(struct MmcDevice *mmc, uint8_t *buf, size_t startSec, siz } MmcDeviceFillRwInfo(&info, buf, true, curStartSec, writeSec); if (mmc->cntlr->detecting == true) { + /* In SD device detecting, VFS will read/write SD. */ ret = MmcSendReadWriteBlocks(mmc->cntlr, &info); } else { cmd.data = &data; diff --git a/support/platform/src/mmc/mmc_dispatch.c b/model/storage/src/mmc/mmc_dispatch.c similarity index 100% rename from support/platform/src/mmc/mmc_dispatch.c rename to model/storage/src/mmc/mmc_dispatch.c diff --git a/support/platform/src/mmc/mmc_emmc.c b/model/storage/src/mmc/mmc_emmc.c similarity index 100% rename from support/platform/src/mmc/mmc_emmc.c rename to model/storage/src/mmc/mmc_emmc.c diff --git a/support/platform/src/mmc/mmc_if.c b/model/storage/src/mmc/mmc_if.c similarity index 100% rename from support/platform/src/mmc/mmc_if.c rename to model/storage/src/mmc/mmc_if.c diff --git a/support/platform/src/mmc/mmc_protocol.c b/model/storage/src/mmc/mmc_protocol.c similarity index 100% rename from support/platform/src/mmc/mmc_protocol.c rename to model/storage/src/mmc/mmc_protocol.c diff --git a/support/platform/src/mmc/mmc_sdio.c b/model/storage/src/mmc/mmc_sdio.c similarity index 100% rename from support/platform/src/mmc/mmc_sdio.c rename to model/storage/src/mmc/mmc_sdio.c diff --git a/support/platform/src/mmc/sdio_if.c b/model/storage/src/mmc/sdio_if.c similarity index 100% rename from support/platform/src/mmc/sdio_if.c rename to model/storage/src/mmc/sdio_if.c diff --git a/model/storage/src/mtd/mtd_block.c b/model/storage/src/mtd/mtd_block.c index fb3c39f305c3b782bf7d6cb1689ee551516a6d51..069172b2c196116f63184b5f8f82c71d439afa09 100644 --- a/model/storage/src/mtd/mtd_block.c +++ b/model/storage/src/mtd/mtd_block.c @@ -6,6 +6,7 @@ * See the LICENSE file in the root of this repository for complete details. */ +#include "hdf_log.h" #include "mtd_core.h" __attribute__((weak)) int32_t MtdBlockOsInit(struct MtdDevice *mtdDevice) @@ -21,10 +22,31 @@ __attribute__ ((weak)) void MtdBlockOsUninit(struct MtdDevice *mtdDevice) int32_t MtdBlockInit(struct MtdDevice *mtdDevice) { - return MtdBlockOsInit(mtdDevice); + int32_t ret; + + if (mtdDevice == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + if (MtdDeviceGet(mtdDevice) == NULL) { + HDF_LOGE("%s: get mtd device failed", __func__); + return HDF_PLT_ERR_DEV_GET; + } + + ret = MtdBlockOsInit(mtdDevice); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: os init failed, ret = %d", __func__, ret); + MtdDevicePut(mtdDevice); + return ret; + } + + return HDF_SUCCESS; } void MtdBlockUninit(struct MtdDevice *mtdDevice) { - MtdBlockOsUninit(mtdDevice); + if (mtdDevice != NULL) { + MtdBlockOsUninit(mtdDevice); + MtdDevicePut(mtdDevice); + } } diff --git a/model/storage/src/mtd/mtd_core.c b/model/storage/src/mtd/mtd_core.c index 051e55efb0aa35dde9d64b87374fa3aba8cc98a4..dbb047a0d2a549471379b3c730f6991000cdfbd4 100644 --- a/model/storage/src/mtd/mtd_core.c +++ b/model/storage/src/mtd/mtd_core.c @@ -16,7 +16,7 @@ static int32_t MtdDeviceCheckParms(struct MtdDevice *mtdDevice) { - if (mtdDevice->index < 0) { + if (mtdDevice->index < 0 || mtdDevice->index >= MTD_DEVICE_NUM_MAX) { HDF_LOGE("%s: invalid index: %d", __func__, mtdDevice->index); return HDF_ERR_INVALID_OBJECT; } @@ -96,6 +96,16 @@ static void MtdDeviceUnlockDefault(struct MtdDevice *mtdDevice) return; } +struct PlatformManager *MtdManagerGet(void) +{ + static struct PlatformManager *g_mtdManager = NULL; + + if (g_mtdManager == NULL) { + g_mtdManager = PlatformManagerCreate("STORAGE_MTD"); + } + return g_mtdManager; +} + int32_t MtdDeviceAdd(struct MtdDevice *mtdDevice) { int32_t ret; @@ -124,15 +134,25 @@ int32_t MtdDeviceAdd(struct MtdDevice *mtdDevice) mtdDevice->ops->unlock = MtdDeviceUnlockDefault; } + mtdDevice->device.manager = MtdManagerGet(); + mtdDevice->device.number = mtdDevice->index; + ret = PlatformDeviceAdd(&mtdDevice->device); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: mtd device add fail", __func__); + return ret; + } + MtdDeviceDump(mtdDevice); ret = MtdCharInit(mtdDevice); if (ret != HDF_SUCCESS) { + PlatformDeviceDel(&mtdDevice->device); return ret; } ret = MtdBlockInit(mtdDevice); if (ret != HDF_SUCCESS) { + PlatformDeviceDel(&mtdDevice->device); return ret; } @@ -144,6 +164,7 @@ void MtdDeviceDel(struct MtdDevice *mtdDevice) if (mtdDevice != NULL) { MtdCharUninit(mtdDevice); MtdBlockUninit(mtdDevice); + PlatformDeviceDel(&mtdDevice->device); (void)OsalMutexDestroy(&mtdDevice->lock); } } @@ -186,9 +207,9 @@ static void MtdDumpBuf(uint8_t *buf, size_t len) #define MTD_DUMP_LINE_LEN 32 #define MTD_DUMP_BUF_LEN (MTD_DUMP_LINE_LEN * MTD_DUMP_SIGLE_WIDTH + 1) char lineBuf[MTD_DUMP_BUF_LEN]; - - for (idx = 0; idx < len; ) { - line = (MTD_DUMP_LINE_LEN <= (len - idx)) ? MTD_DUMP_LINE_LEN : len - idx; + idx = 0; + while (idx < len) { + line = (MTD_DUMP_LINE_LEN <= (len - idx)) ? MTD_DUMP_LINE_LEN : (len - idx); for (i = 0, lidx = 0; i < line; i++, lidx += MTD_DUMP_SIGLE_WIDTH, buf++) { ret = snprintf_s(lineBuf + lidx, MTD_DUMP_SIGLE_WIDTH + 1, MTD_DUMP_SIGLE_WIDTH, "%02x", *buf); if (ret < 0) { @@ -359,15 +380,9 @@ static int32_t MtdDeviceWriteReadByPageUnlock(struct MtdDevice *mtdDevice, struc off_t eraseOffset; struct MtdPage mtdPage; -#ifdef MTD_DEBUG - HDF_LOGD("%s: addr=0x%jd, len=%zu, buf=%p, type:%d, withoob:%d, skipbad:%d", __func__, - msg->addr, msg->len, msg->buf, msg->type, msg->withOob, msg->skipBad); -#endif - dataLenLeft = msg->withOob ? (msg->len / (mtdDevice->writeSize + mtdDevice->oobSize)) * mtdDevice->writeSize : msg->len; - - for (addr = msg->addr, buf = msg->buf; (dataLenLeft > 0) && addr < mtdDevice->capacity; ) { + for (addr = msg->addr, buf = msg->buf; (dataLenLeft > 0) && addr < mtdDevice->capacity;) { if (MtdDeviceIsBadBlockUnlocked(mtdDevice, addr)) { if (!msg->skipBad) { HDF_LOGE("%s: failed on bad block @0x%jx", __func__, addr); @@ -378,7 +393,7 @@ static int32_t MtdDeviceWriteReadByPageUnlock(struct MtdDevice *mtdDevice, struc continue; } eraseOffset = addr & (mtdDevice->eraseSize - 1); - blockSize = dataLenLeft < (mtdDevice->eraseSize - eraseOffset) ? + blockSize = (dataLenLeft < (mtdDevice->eraseSize - eraseOffset)) ? dataLenLeft : (mtdDevice->eraseSize - eraseOffset); // no more than one block at once mtdPage.type = msg->type; @@ -389,7 +404,7 @@ static int32_t MtdDeviceWriteReadByPageUnlock(struct MtdDevice *mtdDevice, struc if (mtdPage.dataLen > blockSize) { mtdPage.dataLen = blockSize; } - mtdPage.oobBuf = msg->withOob ? buf + mtdPage.dataLen : NULL; + mtdPage.oobBuf = msg->withOob ? (buf + mtdPage.dataLen) : NULL; mtdPage.oobLen = msg->withOob ? mtdDevice->oobSize : 0; ret = MtdDevicePageTransferUnlocked(mtdDevice, &mtdPage); if (ret != HDF_SUCCESS) { diff --git a/model/storage/src/mtd/mtd_spi_common.c b/model/storage/src/mtd/mtd_spi_common.c index 7561507e388790518153ee56346a60de888a68b5..cf2176e564e76e173264c2b716d4d57194dbfa6c 100644 --- a/model/storage/src/mtd/mtd_spi_common.c +++ b/model/storage/src/mtd/mtd_spi_common.c @@ -20,8 +20,7 @@ static void SpiFlashDumpDefualt(struct MtdDevice *mtdDevice) MTD_DEVICE_DUMP(mtdDevice); spi = CONTAINER_OF(mtdDevice, struct SpiFlash, mtd); - HDF_LOGD("%s: cs = %u, qe = %u, addrCycle = %u", __func__, - spi->cs, spi->qeEnable, spi->addrCycle); + HDF_LOGD("%s: cs = %u, addrCycle = %u", __func__, spi->cs, spi->addrCycle); cfg = &spi->readCfg; HDF_LOGD("%s: readCfg -> ifType:%u, cmd:0x%x, dummy:%u, size:%u, clock:%u", diff --git a/model/usb/include/usb_ddk_pnp_loader.h b/model/usb/include/usb_ddk_pnp_loader.h old mode 100755 new mode 100644 index 7915fe89e86e77d37b350325c08970061c3cc1ad..e7accbf3229ff97d10ba4270ecf2097826c06842 --- a/model/usb/include/usb_ddk_pnp_loader.h +++ b/model/usb/include/usb_ddk_pnp_loader.h @@ -78,7 +78,7 @@ struct UsbPnpRemoveInfo { uint8_t interfaceNum; }; -int UsbDdkPnpLoaderEventReceived(void *priv, uint32_t id, struct HdfSBuf *data); +int UsbDdkPnpLoaderEventReceived(void *usbPnpManagerPtr, uint32_t id, struct HdfSBuf *data); int UsbDdkPnpLoaderEventHandle(void); #endif /* USB_DDK_PNP_LOADER_H */ diff --git a/model/usb/include/usb_pnp_manager.h b/model/usb/include/usb_pnp_manager.h new file mode 100644 index 0000000000000000000000000000000000000000..2a7cb5b43048b734da9157ad63986bc9c64364e7 --- /dev/null +++ b/model/usb/include/usb_pnp_manager.h @@ -0,0 +1,34 @@ +/* + * 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. + */ + +#ifndef USB_PNP_MANAGE_H +#define USB_PNP_MANAGE_H + +#include "hdf_base.h" +#include "hdf_sbuf.h" + +struct UsbPnpManagerDeviceInfo { + struct HdfDeviceObject *usbPnpManager; + const char *moduleName; + const char *serviceName; + const char *deviceMatchAttr; + const void *privateData; + bool isReg; +}; + +bool UsbPnpManagerWriteModuleName(struct HdfSBuf *sbuf, const char *moduleName); +int32_t UsbPnpManagerRegisterOrUnregisterDevice(struct UsbPnpManagerDeviceInfo *managerInfo); + +#endif /* USB_PNP_MANAGE_H */ diff --git a/model/usb/src/usb_ddk_pnp_loader.c b/model/usb/src/usb_ddk_pnp_loader.c old mode 100755 new mode 100644 index affbd048951f2c0d09ede05a25c10cc6b8791d27..49aace587dfa32fa178bae655633cd1c372e5eb8 --- a/model/usb/src/usb_ddk_pnp_loader.c +++ b/model/usb/src/usb_ddk_pnp_loader.c @@ -7,13 +7,16 @@ */ #include "usb_ddk_pnp_loader.h" +#include #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_device_object.h" #include "hdf_log.h" #include "hdf_sbuf.h" +#include "osal_file.h" #include "osal_mem.h" #include "osal_time.h" #include "securec.h" @@ -39,27 +42,27 @@ static struct HdfSBuf *UsbDdkPnpLoaderBufCreate(const char *moduleName, if (!UsbPnpManagerWriteModuleName(pnpData, moduleName)) { HDF_LOGE("%s: write moduleName failed!", __func__); - goto out; + goto OUT; } if (!HdfSbufWriteString(pnpData, serviceName)) { HDF_LOGE("%s: write service name failed!", __func__); - goto out; + goto OUT; } if (!HdfSbufWriteString(pnpData, deviceMatchAttr)) { HDF_LOGE("%s: write deviceMatchAttr failed!", __func__); - goto out; + goto OUT; } if (!HdfSbufWriteBuffer(pnpData, (const void *)(&serviceInfo), serviceInfo.length)) { HDF_LOGE("%s: write privateData failed!", __func__); - goto out; + goto OUT; } return pnpData; -out: +OUT: HdfSBufRecycle(pnpData); return NULL; @@ -106,10 +109,89 @@ static bool UsbDdkPnpLoaderMatchDevice(const struct UsbPnpNotifyMatchInfoTable * return true; } +// Need optimize this device object array later, should bind device object to usb deivce +#define REGISTER_DEV_MAX 16 +static struct HdfDeviceObject *g_resistedDevice[REGISTER_DEV_MAX] = {0}; +static int SaveRegistedDevice(struct HdfDeviceObject *dev) +{ + for (size_t i = 0; i < REGISTER_DEV_MAX; i++) { + if (g_resistedDevice[i] == NULL) { + g_resistedDevice[i] = dev; + return HDF_SUCCESS; + } + } + + return HDF_FAILURE; +} + +static struct HdfDeviceObject *GetRegistedDevice(const char *serviceName) +{ + struct HdfDeviceObject *dev = NULL; + for (size_t i = 0; i < REGISTER_DEV_MAX; i++) { + if (g_resistedDevice[i] == NULL) { + continue; + } + if (!strcmp(HdfDeviceGetServiceName(g_resistedDevice[i]), serviceName)) { + dev = g_resistedDevice[i]; + g_resistedDevice[i] = NULL; + break; + } + } + + return dev; +} + +int32_t UsbPnpManagerRegisterDevice(struct UsbPnpManagerDeviceInfo *managerInfo) +{ + int ret = HDF_FAILURE; + struct HdfDeviceObject *devObj = HdfDeviceObjectAlloc(managerInfo->usbPnpManager, managerInfo->moduleName); + if (devObj == NULL) { + HDF_LOGE("%s: failed to alloc device object", __func__); + return HDF_DEV_ERR_NO_DEVICE; + } + + devObj->priv = (void *)managerInfo->privateData; + ret = HdfDeviceObjectRegister(devObj); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: failed to regitst device %s", __func__, managerInfo->serviceName); + HdfDeviceObjectRelease(devObj); + return ret; + } + ret = HdfDeviceObjectPublishService(devObj, managerInfo->serviceName, SERVICE_POLICY_CAPACITY, + OSAL_S_IREAD | OSAL_S_IWRITE | OSAL_S_IRGRP | OSAL_S_IWGRP | OSAL_S_IROTH); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: failed to regitst device %s", __func__, managerInfo->serviceName); + HdfDeviceObjectRelease(devObj); + return ret; + } + // need optimize this code to remove SaveRegistedDevice function later + return SaveRegistedDevice(devObj); +} + +int32_t UsbPnpManagerUnregisterDevice(struct UsbPnpManagerDeviceInfo *managerInfo) +{ + // need optimize this code to remove GetRegistedDevice function later + struct HdfDeviceObject *devObj = GetRegistedDevice(managerInfo->serviceName); + if (devObj == NULL) { + return HDF_DEV_ERR_NO_DEVICE; + } + HdfDeviceObjectRelease(devObj); + return HDF_SUCCESS; +} + +int32_t UsbPnpManagerRegisterOrUnregisterDevice(struct UsbPnpManagerDeviceInfo *managerInfo) +{ + if (managerInfo == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + return managerInfo->isReg ? UsbPnpManagerRegisterDevice(managerInfo) : UsbPnpManagerUnregisterDevice(managerInfo); +} + static void UsbDdkPnpLoaderMatchHandle(const struct UsbPnpNotifyMatchInfoTable *dev, int8_t index, struct UsbPnpMatchIdTable *id, bool flag) { - if ((id->pnpMatchFlag == false) && (flag == true)) { + if ((!id->pnpMatchFlag) && flag) { if (!(id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_CLASS)) { id->interfaceClass[id->interfaceClassLength++] = dev->interfaceInfo[index].interfaceClass; } @@ -125,63 +207,85 @@ static void UsbDdkPnpLoaderMatchHandle(const struct UsbPnpNotifyMatchInfoTable * } } -static bool UsbDdkPnpLoaderMatchFlag(const struct UsbPnpNotifyMatchInfoTable *dev, - int8_t index, struct UsbPnpMatchIdTable *id, bool flag) +static bool UsbDdkPnpLoaderMatchFlagFirst(struct UsbPnpMatchIdTable *id) { int32_t i; bool ret = true; + uint32_t offset; if (id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_CLASS) { for (i = 0; i < id->interfaceClassLength; i++) { - if (!((id->interfaceClassMask >> i) & 0x01)) { + offset = i; + if (!((id->interfaceClassMask >> offset) & 0x01)) { break; } } if (i < id->interfaceClassLength) { ret = false; - goto out; + goto OUT; } } if (id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_SUBCLASS) { for (i = 0; i < id->interfaceSubClassLength; i++) { - if (!((id->interfaceSubClassMask >> i) & 0x01)) { + offset = i; + if (!((id->interfaceSubClassMask >> offset) & 0x01)) { break; } } if (i < id->interfaceSubClassLength) { ret = false; - goto out; + goto OUT; } } + ret = true; + +OUT: + return ret; +} + +static bool UsbDdkPnpLoaderMatchFlag(const struct UsbPnpNotifyMatchInfoTable *dev, + int8_t index, struct UsbPnpMatchIdTable *id, bool flag) +{ + int32_t i; + bool ret = true; + uint32_t offset; + + if (!UsbDdkPnpLoaderMatchFlagFirst(id)) { + 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)) { + offset = i; + if (!((id->interfaceProtocolMask >> offset) & 0x01)) { break; } } if (i < id->interfaceProtocolLength) { ret = false; - goto out; + goto OUT; } } if (id->matchFlag & USB_PNP_NOTIFY_MATCH_INT_NUMBER) { for (i = 0; i < id->interfaceLength; i++) { - if (!((id->interfaceMask >> i) & 0x01)) { + offset = i; + if (!((id->interfaceMask >> offset) & 0x01)) { break; } } if (i < id->interfaceLength) { ret = false; - goto out; + goto OUT; } } ret = true; -out: +OUT: UsbDdkPnpLoaderMatchHandle(dev, index, id, flag); return ret; @@ -190,13 +294,13 @@ out: static bool UsbDdkPnpLoaderMatchInterface(const struct UsbPnpNotifyMatchInfoTable *dev, int8_t index, struct UsbPnpMatchIdTable *id) { - uint32_t i; + 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); + id->interfaceClassMask |= (1 << (uint32_t)i); break; } } @@ -209,7 +313,7 @@ static bool UsbDdkPnpLoaderMatchInterface(const struct UsbPnpNotifyMatchInfoTabl 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); + id->interfaceSubClassMask |= (1 << (uint32_t)i); break; } } @@ -222,7 +326,7 @@ static bool UsbDdkPnpLoaderMatchInterface(const struct UsbPnpNotifyMatchInfoTabl 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); + id->interfaceProtocolMask |= (1 << (uint32_t)i); break; } } @@ -235,7 +339,7 @@ static bool UsbDdkPnpLoaderMatchInterface(const struct UsbPnpNotifyMatchInfoTabl 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); + id->interfaceMask |= (1 << (uint32_t)i); break; } } @@ -261,11 +365,11 @@ static bool UsbDdkPnpLoaderMatchOneIdIntf(const struct UsbPnpNotifyMatchInfoTabl } maskFlag = UsbDdkPnpLoaderMatchInterface(dev, index, id); - if (UsbDdkPnpLoaderMatchFlag(dev, index, id, maskFlag) != true) { + if (!UsbDdkPnpLoaderMatchFlag(dev, index, id, maskFlag)) { return false; } - if (id->pnpMatchFlag == false) { + if (!id->pnpMatchFlag) { id->pnpMatchFlag = true; } else { return false; @@ -453,26 +557,26 @@ static struct UsbPnpMatchIdTable **UsbDdkPnpLoaderParseTableList( idTable[count] = (struct UsbPnpMatchIdTable *)OsalMemCalloc(sizeof(struct UsbPnpMatchIdTable)); if (idTable[count] == NULL) { HDF_LOGE("%s: OsalMemCalloc failure!", __func__); - goto out; + goto OUT; } ret = devResIface->GetStringArrayElem(node, "idTableList", count, &idTableName, NULL); if (ret != HDF_SUCCESS) { - goto out; + goto OUT; } tableNode = devResIface->GetChildNode(node, idTableName); if (tableNode == NULL) { HDF_LOGE("%s: tableNode is NULL!", __func__); - goto out; + goto OUT; } if (UsbDdkPnpLoaderParseIdTable(tableNode, devResIface, idTable[count]) != HDF_SUCCESS) { HDF_LOGE("%s: UsbDdkPnpLoaderParseIdTable failure!", __func__); - goto out; + goto OUT; } } return idTable; -out: +OUT: while ((--count) >= 0) { OsalMemFree(idTable[count]); } @@ -563,8 +667,8 @@ static struct UsbPnpMatchIdTable **UsbDdkPnpLoaderPnpMatch(void) return UsbDdkPnpLoaderParseDeviceId(usbPnpNode); } -static int32_t UsbDdkPnpLoaderDispatchPnpDevice( - const struct IDevmgrService *devmgrSvc, struct HdfSBuf *data, bool isReg) +static int32_t UsbDdkPnpLoaderDispatchPnpDevice(struct HdfDeviceObject *usbPnpManagerDevice, + struct HdfSBuf *data, bool isReg) { uint32_t infoSize = 0; struct UsbPnpNotifyServiceInfo *privateData = NULL; @@ -589,14 +693,14 @@ static int32_t UsbDdkPnpLoaderDispatchPnpDevice( privateData = NULL; } - managerInfo.devmgrSvc = (struct IDevmgrService *)devmgrSvc; + managerInfo.usbPnpManager = usbPnpManagerDevice; managerInfo.moduleName = moduleName; managerInfo.serviceName = serviceName; managerInfo.deviceMatchAttr = deviceMatchAttr; managerInfo.privateData = privateData; managerInfo.isReg = isReg; - return UsbPnpManagerRegisterOrUnregisterDevice(managerInfo); + return UsbPnpManagerRegisterOrUnregisterDevice(&managerInfo); } static int UsbDdkPnpLoaderDeviceListAdd(const struct UsbPnpNotifyMatchInfoTable *info, @@ -663,7 +767,7 @@ static struct UsbPnpDeviceListTable *UsbDdkPnpLoaderAddInterface( return NULL; } -static int UsbDdkPnpLoaderrAddPnpDevice(const struct IDevmgrService *devmgrSvc, +static int UsbDdkPnpLoaderrAddPnpDevice(struct HdfDeviceObject *usbPnpManagerDevice, const struct UsbPnpNotifyMatchInfoTable *infoTable, const struct UsbPnpMatchIdTable *idTable, uint32_t cmdId) { int ret; @@ -678,8 +782,8 @@ static int UsbDdkPnpLoaderrAddPnpDevice(const struct IDevmgrService *devmgrSvc, return HDF_SUCCESS; } - serviceInfo.length = sizeof(struct UsbPnpNotifyServiceInfo) - (USB_PNP_INFO_MAX_INTERFACES - - idTable->interfaceLength); + serviceInfo.length = sizeof(struct UsbPnpNotifyServiceInfo) - + (USB_PNP_INFO_MAX_INTERFACES - idTable->interfaceLength); serviceInfo.devNum = infoTable->devNum; serviceInfo.busNum = infoTable->busNum; serviceInfo.interfaceLength = idTable->interfaceLength; @@ -690,10 +794,10 @@ static int UsbDdkPnpLoaderrAddPnpDevice(const struct IDevmgrService *devmgrSvc, if (pnpData == NULL) { ret = HDF_FAILURE; HDF_LOGE("%s: UsbDdkPnpLoaderBufCreate faile", __func__); - goto error; + goto ERROR; } - ret = UsbDdkPnpLoaderDispatchPnpDevice(devmgrSvc, pnpData, true); + ret = UsbDdkPnpLoaderDispatchPnpDevice(usbPnpManagerDevice, pnpData, true); if (ret != HDF_SUCCESS) { HDF_LOGE("%s:%d handle failed, %s-%s cmdId is %d, ret=%d", __func__, __LINE__, idTable->moduleName, idTable->serviceName, cmdId, ret); @@ -702,26 +806,26 @@ static int UsbDdkPnpLoaderrAddPnpDevice(const struct IDevmgrService *devmgrSvc, if (deviceListTable == NULL) { ret = HDF_ERR_INVALID_OBJECT; HDF_LOGE("%s:%d UsbDdkPnpLoaderAddInterface faile", __func__, __LINE__); - goto error; + goto ERROR; } deviceListTable->status = USB_PNP_ADD_STATUS; } else { ret = UsbDdkPnpLoaderDeviceListAdd(infoTable, idTable); if (ret != HDF_SUCCESS) { HDF_LOGE("%s:%d UsbDdkPnpLoaderDeviceListAdd faile", __func__, __LINE__); - goto error; + goto ERROR; } } } -error: +ERROR: HdfSBufRecycle(pnpData); return ret; } -static void UsbDdkPnpLoaderAddDevice(uint32_t cmdId, uint8_t index, const struct IDevmgrService *devmgrSvc, +static void UsbDdkPnpLoaderAddDevice(uint32_t cmdId, uint8_t index, struct HdfDeviceObject *usbPnpManagerDevice, const struct UsbPnpNotifyMatchInfoTable *infoTable, struct UsbPnpMatchIdTable **matchIdTable) { - int ret = HDF_FAILURE; + int ret; struct UsbPnpMatchIdTable *idTable = NULL; int32_t tableCount; @@ -738,16 +842,14 @@ static void UsbDdkPnpLoaderAddDevice(uint32_t cmdId, uint8_t index, const struct idTable=%p, moduleName=%s, serviceName=%s", __func__, __LINE__, index, tableCount, idTable, idTable->moduleName, idTable->serviceName); - ret = UsbDdkPnpLoaderrAddPnpDevice(devmgrSvc, infoTable, idTable, cmdId); + ret = UsbDdkPnpLoaderrAddPnpDevice(usbPnpManagerDevice, infoTable, idTable, cmdId); if (ret != HDF_SUCCESS) { continue; } } - - HDF_LOGD("%s:%d AddDevice end, index=%d, ret=%d", __func__, __LINE__, index, ret); } -static int UsbDdkPnpLoaderRemoveHandle(const struct IDevmgrService *devmgrSvc, +static int UsbDdkPnpLoaderRemoveHandle(struct HdfDeviceObject *usbPnpManager, struct UsbPnpDeviceListTable *deviceListTablePos) { struct UsbPnpNotifyServiceInfo serviceInfo; @@ -769,21 +871,21 @@ static int UsbDdkPnpLoaderRemoveHandle(const struct IDevmgrService *devmgrSvc, } if (deviceListTablePos->status != USB_PNP_REMOVE_STATUS) { - ret = UsbDdkPnpLoaderDispatchPnpDevice(devmgrSvc, pnpData, false); + ret = UsbDdkPnpLoaderDispatchPnpDevice(usbPnpManager, pnpData, false); if (ret != HDF_SUCCESS) { HDF_LOGE("%s:%d UsbDdkPnpLoaderDispatchPnpDevice faile ret=%d", __func__, __LINE__, ret); - goto error; + goto ERROR; } deviceListTablePos->status = USB_PNP_REMOVE_STATUS; } -error: +ERROR: HdfSBufRecycle(pnpData); return ret; } -static int UsbDdkPnpLoaderRemoveDevice(const struct IDevmgrService *devmgrSvc, +static int UsbDdkPnpLoaderRemoveDevice(struct HdfDeviceObject *usbPnpManager, struct UsbPnpRemoveInfo removeInfo, uint32_t cmdId) { int ret = HDF_SUCCESS; @@ -813,7 +915,7 @@ static int UsbDdkPnpLoaderRemoveDevice(const struct IDevmgrService *devmgrSvc, } findFlag = true; - ret = UsbDdkPnpLoaderRemoveHandle(devmgrSvc, deviceListTablePos); + ret = UsbDdkPnpLoaderRemoveHandle(usbPnpManager, deviceListTablePos); if (ret != HDF_SUCCESS) { break; } @@ -835,8 +937,8 @@ static int UsbDdkPnpLoaderRemoveDevice(const struct IDevmgrService *devmgrSvc, return ret; } -static int UsbDdkPnpLoaderDevice(const struct UsbPnpNotifyMatchInfoTable *infoTable, - const struct IDevmgrService *super, uint32_t id) +static int UsbDdkPnpLoaderDevice(struct HdfDeviceObject *usbPnpManagerDevice, + const struct UsbPnpNotifyMatchInfoTable *infoTable, uint32_t id) { int8_t i; int32_t tableCount; @@ -848,7 +950,7 @@ static int UsbDdkPnpLoaderDevice(const struct UsbPnpNotifyMatchInfoTable *infoTa } for (i = 0; i < infoTable->numInfos; i++) { - UsbDdkPnpLoaderAddDevice(id, i, super, infoTable, g_usbPnpMatchIdTable); + UsbDdkPnpLoaderAddDevice(id, i, usbPnpManagerDevice, infoTable, g_usbPnpMatchIdTable); } for (tableCount = 0, idTable = g_usbPnpMatchIdTable[0]; idTable != NULL; @@ -892,44 +994,44 @@ static int UsbDdkPnpLoaderEventSend(const struct HdfIoService *serv, const char if (reply == NULL) { ret = HDF_DEV_ERR_NO_MEMORY; HDF_LOGE("%s: fail to obtain sbuf reply", __func__); - goto out; + goto OUT; } if (!HdfSbufWriteString(data, eventData)) { ret = HDF_FAILURE; HDF_LOGE("%s: fail to write sbuf", __func__); - goto out; + goto OUT; } ret = serv->dispatcher->Dispatch((struct HdfObject *)&serv->object, USB_PNP_NOTIFY_REPORT_INTERFACE, data, reply); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: fail to send serivice call, ret=%d", __func__, ret); - goto out; + goto OUT; } if (!HdfSbufReadInt32(reply, &replyData)) { ret = HDF_ERR_INVALID_OBJECT; HDF_LOGE("%s: fail to get service call reply", __func__); - goto out; + goto OUT; } HDF_LOGI("%s:%d get reply is 0x%x", __func__, __LINE__, replyData); -out: +OUT: HdfSBufRecycle(data); HdfSBufRecycle(reply); return ret; } -int UsbDdkPnpLoaderEventReceived(void *priv, uint32_t id, struct HdfSBuf *data) +int UsbDdkPnpLoaderEventReceived(void *usbPnpManagerPtr, 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; + struct HdfDeviceObject *usbPnpManagerDevice = (struct HdfDeviceObject *)usbPnpManagerPtr; flag = HdfSbufReadBuffer(data, (const void **)(&infoTable), &infoSize); if ((flag == false) || (infoTable == NULL)) { @@ -951,7 +1053,7 @@ int UsbDdkPnpLoaderEventReceived(void *priv, uint32_t id, struct HdfSBuf *data) #if USB_PNP_NOTIFY_TEST_MODE == true case USB_PNP_NOTIFY_ADD_TEST: #endif - ret = UsbDdkPnpLoaderDevice(infoTable, super, id); + ret = UsbDdkPnpLoaderDevice(usbPnpManagerDevice, infoTable, id); break; case USB_PNP_NOTIFY_REMOVE_INTERFACE: case USB_PNP_NOTIFY_REMOVE_DEVICE: @@ -963,7 +1065,7 @@ int UsbDdkPnpLoaderEventReceived(void *priv, uint32_t id, struct HdfSBuf *data) removeInfo.devNum = infoTable->devNum; removeInfo.busNum = infoTable->busNum; removeInfo.interfaceNum = infoTable->interfaceInfo[0].interfaceNumber; - ret = UsbDdkPnpLoaderRemoveDevice(super, removeInfo, id); + ret = UsbDdkPnpLoaderRemoveDevice(usbPnpManagerDevice, removeInfo, id); break; default: ret = HDF_ERR_INVALID_PARAM; @@ -1004,11 +1106,12 @@ int UsbDdkPnpLoaderEventHandle(void) status = UsbDdkPnpLoaderEventSend(usbPnpServ, "USB PNP Handle Info"); if (status != HDF_SUCCESS) { HDF_LOGE("UsbDdkPnpLoaderEventSend faile status=%d", status); - goto error; + goto ERROR; } return status; -error: - for (idTable = g_usbPnpMatchIdTable[0]; idTable != NULL; ) { +ERROR: + idTable = g_usbPnpMatchIdTable[0]; + while (idTable != NULL) { tableCount++; idTable = g_usbPnpMatchIdTable[tableCount]; } diff --git a/sample/config/device_info/device_info.hcs b/sample/config/device_info/device_info.hcs new file mode 100755 index 0000000000000000000000000000000000000000..f3cd30a2aa8613ef4dbf358be80c3fc9db452d9c --- /dev/null +++ b/sample/config/device_info/device_info.hcs @@ -0,0 +1,18 @@ +root { + device_info { + platform :: host { + hostName = "platform_host"; + priority = 50; + device_uart :: device { + device5 :: deviceNode { + policy = 2; + priority = 10; + permission = 0660; + moduleName = "UART_SAMPLE"; + serviceName = "HDF_PLATFORM_UART_5"; + deviceMatchAttr = "sample_uart_5"; + } + } + } + } +} diff --git a/sample/config/uart/uart_config.hcs b/sample/config/uart/uart_config.hcs new file mode 100755 index 0000000000000000000000000000000000000000..2ea8900bbb5b142c50bfb3c7a0351e9cfc34edfc --- /dev/null +++ b/sample/config/uart/uart_config.hcs @@ -0,0 +1,15 @@ +root { + platform { + uart_sample { + num = 5; + base = 0x120a0000; // UART base register address + irqNum = 38; + baudrate = 115200; + uartClk = 24000000; // 24 M + wlen = 0x60; // 8 bit width + parity = 0; + stopBit = 0; + match_attr = "sample_uart_5"; + } + } +} diff --git a/sample/platform/uart/BUILD.gn b/sample/platform/uart/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..9404df09728c324edd198ee2bd04a0042774d991 --- /dev/null +++ b/sample/platform/uart/BUILD.gn @@ -0,0 +1,14 @@ +# Copyright (c) 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. + +import("//build/lite/config/component/lite_component.gni") + +lite_component("hello_uart_sample") { + features = [ + "dev:hello_uart", + "dispatch:hello_uart_dispatch", + ] +} diff --git a/sample/platform/uart/Kconfig b/sample/platform/uart/Kconfig new file mode 100755 index 0000000000000000000000000000000000000000..2a317abf38a3c218d39cf81d81df0bf7c2119864 --- /dev/null +++ b/sample/platform/uart/Kconfig @@ -0,0 +1,12 @@ +# Copyright (c) 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. + +config DRIVERS_HDF_PLATFORM_UART_SAMPLE + bool "Enable HDF platform uart sample driver" + default n + depends on DRIVERS_HDF_PLATFORM + help + Answer Y to enable HDF platform uart sample driver. diff --git a/sample/platform/uart/dev/BUILD.gn b/sample/platform/uart/dev/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..25f7815c0730d58f1f7f1f5556245de282ae95fe --- /dev/null +++ b/sample/platform/uart/dev/BUILD.gn @@ -0,0 +1,41 @@ +# Copyright (c) 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. + +HDF_FRAMEWORKS = "//drivers/framework" + +executable("hello_uart") { + sources = [ "hello_uart_dev.c" ] + + include_dirs = [ + "$HDF_FRAMEWORKS/ability/sbuf/include", + "$HDF_FRAMEWORKS/core/shared/include", + "$HDF_FRAMEWORKS/core/host/include", + "$HDF_FRAMEWORKS/core/master/include", + "$HDF_FRAMEWORKS/include/core", + "$HDF_FRAMEWORKS/include/utils", + "$HDF_FRAMEWORKS/utils/include", + "$HDF_FRAMEWORKS/include/osal", + "//drivers/adapter/uhdf/posix/include", + "//third_party/bounds_checking_function/include", + "//base/hiviewdfx/hilog_lite/interfaces/native/innerkits", + ] + + deps = [ + "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", + "//drivers/adapter/uhdf/manager:hdf_core", + "//drivers/adapter/uhdf/posix:hdf_posix_osal", + ] + + public_deps = [ "//third_party/bounds_checking_function:libsec_shared" ] + defines = [ "__USER__" ] + + cflags = [ + "-Wall", + "-Wextra", + "-Wno-format", + "-Wno-format-extra-args", + ] +} diff --git a/sample/platform/uart/dev/hello_uart_dev.c b/sample/platform/uart/dev/hello_uart_dev.c new file mode 100755 index 0000000000000000000000000000000000000000..ffacc5df0f3e2e1ca6deecbfbe08388d44644c5e --- /dev/null +++ b/sample/platform/uart/dev/hello_uart_dev.c @@ -0,0 +1,38 @@ +/* + * Copyright (c) 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 +#include +#include +#include "hdf_log.h" + +#define HDF_LOG_TAG hello_uart +#define INFO_SIZE 16 + +int main(void) +{ + int ret; + int fd; + const char info[INFO_SIZE] = {" HELLO UART! "}; + + fd = open("/dev/uartdev-5", O_RDWR); + if (fd < 0) { + HDF_LOGE("uartdev-5 open failed %d", fd); + return -1; + } + ret = write(fd, info, INFO_SIZE); + if (ret != 0) { + HDF_LOGE("write uartdev-5 ret is %d", ret); + } + ret = close(fd); + if (ret != 0) { + HDF_LOGE("uartdev-5 close failed %d", fd); + return -1; + } + return ret; +} \ No newline at end of file diff --git a/sample/platform/uart/dispatch/BUILD.gn b/sample/platform/uart/dispatch/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..6813ed10cfa389b8c9ef57acc95f5e88f2a4e88e --- /dev/null +++ b/sample/platform/uart/dispatch/BUILD.gn @@ -0,0 +1,44 @@ +# Copyright (c) 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. + +HDF_FRAMEWORKS = "//drivers/framework" + +executable("hello_uart_dispatch") { + sources = [ + "hello_uart_dispatch.c", + "uart_if.c", + ] + + include_dirs = [ + "$HDF_FRAMEWORKS/ability/sbuf/include", + "$HDF_FRAMEWORKS/core/shared/include", + "$HDF_FRAMEWORKS/core/host/include", + "$HDF_FRAMEWORKS/core/master/include", + "$HDF_FRAMEWORKS/include/core", + "$HDF_FRAMEWORKS/include/utils", + "$HDF_FRAMEWORKS/utils/include", + "$HDF_FRAMEWORKS/include/osal", + "//drivers/adapter/uhdf/posix/include", + "//third_party/bounds_checking_function/include", + "//base/hiviewdfx/hilog_lite/interfaces/native/innerkits", + ] + + deps = [ + "//base/hiviewdfx/hilog_lite/frameworks/featured:hilog_shared", + "//drivers/adapter/uhdf/manager:hdf_core", + "//drivers/adapter/uhdf/posix:hdf_posix_osal", + ] + + public_deps = [ "//third_party/bounds_checking_function:libsec_shared" ] + defines = [ "__USER__" ] + + cflags = [ + "-Wall", + "-Wextra", + "-Wno-format", + "-Wno-format-extra-args", + ] +} diff --git a/sample/platform/uart/dispatch/hello_uart_dispatch.c b/sample/platform/uart/dispatch/hello_uart_dispatch.c new file mode 100755 index 0000000000000000000000000000000000000000..ea123de111c8caaf2b20d0e80191baee63cccb57 --- /dev/null +++ b/sample/platform/uart/dispatch/hello_uart_dispatch.c @@ -0,0 +1,34 @@ +/* + * Copyright (c) 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 +#include "hdf_log.h" +#include "osal_mem.h" +#include "uart_if.h" + +#define HDF_LOG_TAG hello_uart_dispatch +#define UART_PORT 5 + +int main() +{ + const char *info = " HELLO UART! "; + + struct DevHandle *handle = UartOpen(UART_PORT); + if (handle == NULL) { + HDF_LOGE("Failed to open uart %d", UART_PORT); + return HDF_FAILURE; + } + + int ret = UartWrite(handle, (uint8_t *)info, strlen(info)); + if (ret != HDF_SUCCESS) { + HDF_LOGE("Failed to send data to uart"); + } + + UartClose(handle); + return ret; +} \ No newline at end of file diff --git a/sample/platform/uart/dispatch/uart_if.c b/sample/platform/uart/dispatch/uart_if.c new file mode 100755 index 0000000000000000000000000000000000000000..9fdb158c67dbeb36bc3a98d59d2dd3f5ae845f48 --- /dev/null +++ b/sample/platform/uart/dispatch/uart_if.c @@ -0,0 +1,96 @@ +/* + * Copyright (c) 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 "uart_if.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "hdf_io_service_if.h" + +#define HDF_LOG_TAG uart_if + +struct DevHandle *UartOpen(uint32_t port) +{ + int32_t ret; + struct DevHandle *handle = NULL; + char *serviceName = NULL; + + handle = (struct DevHandle *)OsalMemCalloc(sizeof(struct DevHandle)); + if (handle == NULL) { + HDF_LOGE("Failed to OsalMemCalloc handle"); + return NULL; + } + + serviceName = (char *)OsalMemCalloc(sizeof(char) * (MAX_DEV_NAME_SIZE + 1)); + if (serviceName == NULL) { + HDF_LOGE("Failed to OsalMemCalloc serviceName"); + OsalMemFree(handle); + return NULL; + } + ret = snprintf_s(serviceName, MAX_DEV_NAME_SIZE + 1, MAX_DEV_NAME_SIZE, UART_DEV_SERVICE_NAME_PREFIX, port); + if (ret < 0) { + HDF_LOGE("Failed to snprintf_s"); + OsalMemFree(handle); + OsalMemFree(serviceName); + return NULL; + } + + struct HdfIoService *service = HdfIoServiceBind(serviceName); + if (service == NULL) { + HDF_LOGE("Failed to get service %s", serviceName); + OsalMemFree(handle); + OsalMemFree(serviceName); + return NULL; + } + OsalMemFree(serviceName); + handle->object = service; + return handle; +} + +int32_t UartWrite(struct DevHandle *handle, uint8_t *data, uint32_t size) +{ + int ret; + struct HdfIoService *service = NULL; + + if (handle == NULL || handle->object == NULL) { + HDF_LOGE("handle or handle->object is NULL"); + return HDF_FAILURE; + } + + struct HdfSBuf *sBuf = HdfSBufObtainDefaultSize(); + if (sBuf == NULL) { + HDF_LOGE("Failed to obtain sBuf"); + return HDF_FAILURE; + } + + if (!HdfSbufWriteBuffer(sBuf, data, size)) { + HDF_LOGE("Failed to write sbuf"); + HdfSBufRecycle(sBuf); + return HDF_FAILURE; + } + + service = (struct HdfIoService *)handle->object; + ret = service->dispatcher->Dispatch(&service->object, UART_WRITE, sBuf, NULL); + if (ret != HDF_SUCCESS) { + HDF_LOGE("Failed to send service call"); + } + HdfSBufRecycle(sBuf); + return ret; +} + +void UartClose(struct DevHandle *handle) +{ + struct HdfIoService *service = NULL; + + if (handle == NULL || handle->object == NULL) { + HDF_LOGE("handle or handle->object is NULL"); + return; + } + service = (struct HdfIoService *)handle->object; + HdfIoServiceRecycle(service); + OsalMemFree(handle); +} diff --git a/sample/platform/uart/dispatch/uart_if.h b/sample/platform/uart/dispatch/uart_if.h new file mode 100755 index 0000000000000000000000000000000000000000..61ca0ad3aadca076cf91e3138f64ed11edaf4a9b --- /dev/null +++ b/sample/platform/uart/dispatch/uart_if.h @@ -0,0 +1,29 @@ +/* + * Copyright (c) 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 UART_IF_H +#define UART_IF_H + +#include + +#define UART_DEV_SERVICE_NAME_PREFIX "HDF_PLATFORM_UART_%d" +#define MAX_DEV_NAME_SIZE 32 + +enum { + UART_WRITE = 1 +}; + +struct DevHandle { + void *object; +}; + +struct DevHandle *UartOpen(uint32_t port); +int32_t UartWrite(struct DevHandle *handle, uint8_t *data, uint32_t size); +void UartClose(struct DevHandle *handle); + +#endif // UART_IF_H \ No newline at end of file diff --git a/sample/platform/uart/include/buf_fifo.h b/sample/platform/uart/include/buf_fifo.h new file mode 100755 index 0000000000000000000000000000000000000000..ba9dab7d7e7c68246a2004cb35e0b4294afdc2fa --- /dev/null +++ b/sample/platform/uart/include/buf_fifo.h @@ -0,0 +1,36 @@ +/* + * Copyright (c) 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 BUF_FIFO_H +#define BUF_FIFO_H + +#include +#include +#include + +struct BufferFifo { + volatile uint32_t readPosition; + volatile uint32_t writePosition; + uint16_t bufSizeMask; + uint8_t *buffer; +}; + +static inline uint16_t BufferFifoGetDataSize(struct BufferFifo *fifo) +{ + return (fifo->writePosition - fifo->readPosition); +} + +static inline bool IsPowerOfTwo(int num) +{ + return (num > 0) && (num & (num - 1)) == 0; +} + +bool BufferFifoInit(struct BufferFifo *fifo, uint8_t *buf, uint16_t bufSize); + +#endif // BUF_FIFO_H + diff --git a/sample/platform/uart/include/uart_dev_sample.h b/sample/platform/uart/include/uart_dev_sample.h new file mode 100755 index 0000000000000000000000000000000000000000..87150de3a37271c85d9cd0ab504e5106ca620f27 --- /dev/null +++ b/sample/platform/uart/include/uart_dev_sample.h @@ -0,0 +1,35 @@ +/* + * Copyright (c) 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 UART_DEV_SAMPLE_H +#define UART_DEV_SAMPLE_H + +#include "sys/ioctl.h" +#include "uart_core.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif /* __cplusplus */ +#endif /* __cplusplus */ + +#define UART_IOC_MAGIC 'u' + +/* baudrate config */ +#define UART_CFG_BAUDRATE _IO(UART_IOC_MAGIC, 1) + +void AddUartDevice(struct UartHost *host); +void RemoveUartDevice(struct UartHost *host); + +#ifdef __cplusplus +#if __cplusplus +} +#endif /* __cplusplus */ +#endif /* __cplusplus */ + +#endif /* UART_DEV_SAMPLE_H */ diff --git a/tools/hdi-gen/codegen/generator_factory.h b/sample/platform/uart/include/uart_dispatch_sample.h similarity index 42% rename from tools/hdi-gen/codegen/generator_factory.h rename to sample/platform/uart/include/uart_dispatch_sample.h index 8b99621fbb6ce3af842405c67ac60f5e19c837d5..42ca3c5bc78fb52c5011b7ee283009c2743a3094 100755 --- a/tools/hdi-gen/codegen/generator_factory.h +++ b/sample/platform/uart/include/uart_dispatch_sample.h @@ -1,23 +1,20 @@ -/* - * Copyright (c) 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 OHOS_HDI_GENERATORFACTORY_H -#define OHOS_HDI_GENERATORFACTORY_H - -#include "codegen/code_generator.h" - -namespace OHOS { -namespace HDI { -class GeneratorFactory { -public: - AutoPtr GetCodeGenerator(const String& targetLanuage); -}; -} // namespace HDI -} // namespace OHOS - -#endif // OHOS_HDI_GENERATORFACTORY_H \ No newline at end of file +/* + * Copyright (c) 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 UART_DISPATCH_SAMPLE_H +#define UART_DISPATCH_SAMPLE_H + +#include "uart_pl011_sample.h" + +enum { + UART_WRITE = 1 +}; + +int32_t SampleDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply); + +#endif // UART_DISPATCH_SAMPLE_H diff --git a/sample/platform/uart/include/uart_pl011_sample.h b/sample/platform/uart/include/uart_pl011_sample.h new file mode 100755 index 0000000000000000000000000000000000000000..ae2f612645aed627ffb23f103ca01ebaee5f88f9 --- /dev/null +++ b/sample/platform/uart/include/uart_pl011_sample.h @@ -0,0 +1,242 @@ +/* + * Copyright (c) 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 UART_PL011_SAMPLE_H +#define UART_PL011_SAMPLE_H + +#include +#include +#include "hdf_device_desc.h" +#include "buf_fifo.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct UartRegisterMap { + volatile uint32_t dr; /* Offset: 0x000 TYPE: (RW) Data register */ + union { + volatile uint32_t rsr; /* Offset: 0x004 TYPE: (RO) Receive status register */ + volatile uint32_t ecr; /* Offset: 0x004 TYPE: (WO) Error clear register */ + }; + volatile uint32_t reserved0[4]; /* Offset: 0x008-0x014 Reserved */ + volatile uint32_t fr; /* Offset: 0x018 TYPE: (RO) Flag register */ + volatile uint32_t reserved1; /* Offset: 0x01C Reserved */ + volatile uint32_t ilpr; /* Offset: 0x020 TYPE: (RW) IrDA low-power counter register */ + volatile uint32_t ibrd; /* Offset: 0x024 TYPE: (RW) Integer baud rate register */ + volatile uint32_t fbrd; /* Offset: 0x028 TYPE: (RW) Fractional baud rate register */ + volatile uint32_t lcr; /* Offset: 0x02C TYPE: (RW) Line control register */ + volatile uint32_t cr; /* Offset: 0x030 TYPE: (RW) Control register */ + volatile uint32_t ifls; /* Offset: 0x034 TYPE: (RW) Interrupt FIFO level select register */ + volatile uint32_t imsc; /* Offset: 0x038 TYPE: (RW) Interrupt mask set/clear register */ + volatile uint32_t ris; /* Offset: 0x03C TYPE: (RO) Raw interrupt status register */ + volatile uint32_t mis; /* Offset: 0x040 TYPE: (RO) Masked interrupt status register */ + volatile uint32_t icr; /* Offset: 0x044 TYPE: (WO) Interrupt clear register */ + volatile uint32_t dmacr; /* Offset: 0x048 TYPE: (RW) DMA control register */ +}; + +struct UartResource { + uint32_t num; /* UART port num */ + uint32_t base; /* UART PL011 base address */ + uint32_t irqNum; /* UART PL011 IRQ num */ + uint32_t baudrate; /* Default baudrate */ + uint32_t wlen; /* Default word length */ + uint32_t parity; /* Default parity */ + uint32_t stopBit; /* Default stop bits */ + uint32_t uartClk; /* UART clock */ + unsigned long physBase; +}; + +enum UartDeviceState { + UART_DEVICE_UNINITIALIZED = 0x0u, + UART_DEVICE_INITIALIZED = 0x1u, +}; + +struct UartDevice { + struct IDeviceIoService ioService; + struct UartResource resource; + enum UartDeviceState state; /* UART State */ + uint32_t uartClk; /* UART clock */ + uint32_t baudrate; /* Baudrate */ + struct BufferFifo rxFifo; +}; + +/* Receive Status Register/Error Clear Register data */ +#define UART_PL011_RSR_FRAMING_ERROR_MASK (1 << 0x0u) /* Framing error bit mask */ +#define UART_PL011_RSR_PARITY_ERROR_MASK (1 << 0x1u) /* Parity error bit mask */ +#define UART_PL011_RSR_BREAK_ERROR_MASK (1 << 0x2u) /* Break error bit mask */ +#define UART_PL011_RSR_OVERRUN_ERROR_MASK (1 << 0x3u) /* Overrun error bit mask */ + +/* Receive Status Register Error Mask */ +#define UART_PL011_RSR_RX_ERROR_MASK ( \ + UART_PL011_RSR_FRAMING_ERROR_MASK \ + | UART_PL011_RSR_PARITY_ERROR_MASK \ + | UART_PL011_RSR_BREAK_ERROR_MASK \ + | UART_PL011_RSR_OVERRUN_ERROR_MASK) + +#define UART_PL011_FR_CTS_MASK (1 << 0x0u) /* Clear to send bit mask */ +#define UART_PL011_FR_DSR_MASK (1 << 0x1u) /* Data set ready bit mask */ +#define UART_PL011_FR_DCD_MASK (1 << 0x2u) /* Data carrier detect bit mask */ +#define UART_PL011_FR_BUSY_MASK (1 << 0x3u) /* UART busy bit mask */ +#define UART_PL011_FR_RX_FIFO_EMPTY_MASK (1 << 0x4u) /* Receive FIFO empty bit mask */ +#define UART_PL011_FR_TX_FIFO_FULL_MASK (1 << 0x5u) /* Transmit FIFO full bit mask */ +#define UART_PL011_FR_RX_FIFO_FULL_MASK (1 << 0x6u) /* Receive FIFO full bit mask */ +#define UART_PL011_FR_TX_FIFO_EMPTY_MASK (1 << 0x7u) /* Transmit FIFO empty. bit mask */ +#define UART_PL011_FR_RI_MASK (1 << 0x8u) /* Ring indicator bit mask */ + +/* PL011 Line Control Register Data bits */ +#define UART_PL011_LCR_H_BRK_MASK (1 << 0x0u) /* Send Break bit mask */ +#define UART_PL011_LCR_H_PEN_MASK (1 << 0x1u) /* Parity enable bit mask */ +#define UART_PL011_LCR_H_EPS_MASK (1 << 0x2u) /* Even parity select bit mask . */ +#define UART_PL011_LCR_H_FEN_MASK (1 << 0x4u) /* Enable FIFOs bit mask */ +#define UART_PL011_LCR_H_SPS_MASK (1 << 0x7u) /* Stick parity select bit mask */ + +#define UART_PL011_LCR_H_WLEN_BIT_OFFSET 0x5u /* Word length bit offset */ +#define UART_PL011_LCR_H_WLEN_MASK ( \ + 0x3u << UART_PL011_LCR_H_WLEN_BIT_OFFSET) + +#define UART_PL011_WLEN_5BITS (0x0u << UART_PL011_LCR_H_WLEN_BIT_OFFSET) +#define UART_PL011_WLEN_6BITS (0x1u << UART_PL011_LCR_H_WLEN_BIT_OFFSET) +#define UART_PL011_WLEN_7BITS (0x2u << UART_PL011_LCR_H_WLEN_BIT_OFFSET) +#define UART_PL011_WLEN_8BITS (0x3u << UART_PL011_LCR_H_WLEN_BIT_OFFSET) + +#define UART_PL011_NONE_PARITY_CHECKED 0 + +#define UART_PL011_LCR_H_STP2_BIT_OFFSET 0x3u /* Two stop bits select */ + +#define UART_PL011_STOPBIT_1 (0x0u << UART_PL011_LCR_H_STP2_BIT_OFFSET) +#define UART_PL011_STOPBIT_2 (0x1u << UART_PL011_LCR_H_STP2_BIT_OFFSET) + +#define UART_PL011_LCR_H_PARITY_MASK ( \ + UART_PL011_LCR_H_PEN_MASK \ + | UART_PL011_LCR_H_EPS_MASK \ + | UART_PL011_LCR_H_SPS_MASK) + +#define UART_PL011_LCR_H_STOPBIT_MASK (0x1u << UART_PL011_LCR_H_STP2_BIT_OFFSET) + +#define UART_PL011_DATA_FORMAT_MASK ( \ + UART_PL011_LCR_H_PARITY_MASK \ + | UART_PL011_LCR_H_STOPBIT_MASK \ + | UART_PL011_LCR_H_WLEN_MASK) + +/* Control Register */ +#define UART_PL011_CR_UARTEN_MASK (0x1u << 0x0u) /* Uart enable bit mask */ +#define UART_PL011_CR_SIREN_MASK (0x1u << 0x1u) /* Sir enable bit mask */ +#define UART_PL011_CR_SIRLP_MASK (0x1u << 0x2u) /* SIR low-power IrDA mode bit mask */ +#define UART_PL011_CR_LBE_MASK (0x1u << 0x7u) /* Loopback enable bit mask */ +#define UART_PL011_CR_TXE_MASK (0x1u << 0x8u) /* Transmit enable bit mask */ +#define UART_PL011_CR_RXE_MASK (0x1u << 0x9u) /* Receive enable bit mask */ +#define UART_PL011_CR_DTR_MASK (0x1u << 0xAu) /* Data transmit ready.bit mask */ +#define UART_PL011_CR_RTS_MASK (0x1u << 0xBu) /* Request to send bit mask */ +#define UART_PL011_CR_OUT1_MASK (0x1u << 0xCu) /* Out1 bit field mask */ +#define UART_PL011_CR_OUT2_MASK (0x1u << 0xDu) /* Out2 bit field mask */ +#define UART_PL011_CR_RTSE_MASK (0x1u << 0xEu) /* RTS hardware flow control enable bit mask */ +#define UART_PL011_CR_CTSE_MASK (0x1u << 0xFu) /* CTS hardware flow control enable bit mask */ + + +/* Interrupt FIFO Level Select Register Transmit bit offset */ +#define UART_PL011_IFLS_TX_BIT_OFFSET 0x0u +/* Interrupt FIFO Level Select Register Receive bit offset */ +#define UART_PL011_IFLS_RX_BIT_OFFSET 0x3u + +#define UART_PL011_RX_FIFO_LVL_1_8 (0x0u << UART_PL011_IFLS_RX_BIT_OFFSET) +#define UART_PL011_RX_FIFO_LVL_1_4 (0x1u << UART_PL011_IFLS_RX_BIT_OFFSET) +#define UART_PL011_RX_FIFO_LVL_1_2 (0x2u << UART_PL011_IFLS_RX_BIT_OFFSET) +#define UART_PL011_RX_FIFO_LVL_3_4 (0x3u << UART_PL011_IFLS_RX_BIT_OFFSET) +#define UART_PL011_RX_FIFO_LVL_7_8 (0x4u << UART_PL011_IFLS_RX_BIT_OFFSET) + +#define UART_PL011_TX_FIFO_LVL_1_8 (0x0u << UART_PL011_IFLS_TX_BIT_OFFSET) +#define UART_PL011_TX_FIFO_LVL_1_4 (0x1u << UART_PL011_IFLS_TX_BIT_OFFSET) +#define UART_PL011_TX_FIFO_LVL_1_2 (0x2u << UART_PL011_IFLS_TX_BIT_OFFSET) +#define UART_PL011_TX_FIFO_LVL_3_4 (0x3u << UART_PL011_IFLS_TX_BIT_OFFSET) +#define UART_PL011_TX_FIFO_LVL_7_8 (0x4u << UART_PL011_IFLS_TX_BIT_OFFSET) + +/* Default register values of UART PL011 */ +#define UART_PL011_DEFAULT_DATA_REG_VALUE (0x0u) +#define UART_PL011_DEFAULT_ECR_VALUE (0xFFu) +#define UART_PL011_DEFAULT_ILPR_VALUE (0x0u) +#define UART_PL011_DEFAULT_IBRD_REG_VALUE (0x0u) +#define UART_PL011_DEFAULT_FBRD_REG_VALUE (0x0u) +/* Clear UARTLCR */ +#define UART_PL011_DEFAULT_LCR_H_VALUE (0x0u) +#define UART_PL011_DEFAULT_CTRL_REG_VALUE (0x0300u) + +#define UART_PL011_DEFAULT_IFLS_REG_VALUE ( \ + UART_PL011_RX_FIFO_LVL_1_2 \ + | UART_PL011_TX_FIFO_LVL_7_8) + +/* Clear interrupt mask */ +#define UART_PL011_DEFAULT_IMSC_REG_VALUE (0x0u) +/* Clear interrupt */ +#define UART_PL011_DEFAULT_ICR_VALUE (0x7FFu) +#define UART_PL011_DEFAULT_DMACR_VALUE (0x0u) + +#define FREQ_IRLPBAUD16_MIN (1420000u) /* 1.42 MHz */ +#define FREQ_IRLPBAUD16_MAX (2120000u) /* 2.12 MHz */ +#define SAMPLING_FACTOR (16u) +#define UART_PL011_FBRD_WIDTH (6u) + +/** + * \brief ARM UART PL011 error enumeration types + */ +typedef enum UartPl011Error { + UART_PL011_ERR_NONE = (0x0u), + UART_PL011_ERR_RX_FRAME = UART_PL011_RSR_FRAMING_ERROR_MASK, + UART_PL011_ERR_RX_PARITY = UART_PL011_RSR_PARITY_ERROR_MASK, + UART_PL011_ERR_RX_BREAK = UART_PL011_RSR_BREAK_ERROR_MASK, + UART_PL011_ERR_RX_OVERFLOW = UART_PL011_RSR_OVERRUN_ERROR_MASK, + UART_PL011_ERR_INVALID_ARG = (UART_PL011_RSR_RX_ERROR_MASK + 1), + UART_PL011_ERR_NOT_READY, + UART_PL011_ERR_INVALID_BAUD, + UART_PL011_ERR_NOT_INIT, +} UartPl011Error; + +static inline void UartPl011Enable(struct UartRegisterMap *regMap) +{ + regMap->cr |= UART_PL011_CR_UARTEN_MASK; +} + +static inline void UartPl011Disable(struct UartRegisterMap *regMap) +{ + regMap->cr &= ~UART_PL011_CR_UARTEN_MASK; +} + +static inline bool UartPl011IsEnabled(struct UartRegisterMap *regMap) +{ + return (bool)(regMap->cr & UART_PL011_CR_UARTEN_MASK); +} + +static inline bool UartPl011IsBusy(struct UartRegisterMap *regMap) +{ + return (bool)(regMap->fr & UART_PL011_FR_BUSY_MASK); +} + +void UartPl011SetLcrBits(struct UartRegisterMap *regMap, uint32_t bits); + +static inline void UartPl011Write(struct UartRegisterMap *regMap, uint8_t byte) +{ + while (UartPl011IsBusy(regMap)); + regMap->dr = byte; +} + +UartPl011Error UartPl011SetBaudrate(struct UartRegisterMap *regMap, uint32_t clk, uint32_t baudrate); + +void UartPl011SetDataFormat(struct UartRegisterMap *regMap, uint32_t wordLen, uint32_t parity, uint32_t stopBits); + +void UartPl011ResetRegisters(struct UartRegisterMap *regMap); + +static inline void UartPl011EnableFifo(struct UartRegisterMap *regMap) +{ + UartPl011SetLcrBits(regMap, UART_PL011_LCR_H_FEN_MASK); +} + +#ifdef __cplusplus +} +#endif +#endif /* UART_PL011_SAMPLE_H */ + diff --git a/sample/platform/uart/src/BUILD.gn b/sample/platform/uart/src/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..a979792d487d743e696372112dc53e89a28d0820 --- /dev/null +++ b/sample/platform/uart/src/BUILD.gn @@ -0,0 +1,22 @@ +# Copyright (c) 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. + +import("//drivers/adapter/khdf/liteos/hdf.gni") + +module_switch = defined(LOSCFG_DRIVERS_HDF_PLATFORM_UART_SAMPLE) +module_name = "hdf_uart_sample" +hdf_driver(module_name) { + FRAMEWORK_UART_ROOT = "//drivers/framework/sample/platform/uart/src" + sources = [ + "$FRAMEWORK_UART_ROOT/buf_fifo.c", + "$FRAMEWORK_UART_ROOT/uart_dev_sample.c", + "$FRAMEWORK_UART_ROOT/uart_dispatch_sample.c", + "$FRAMEWORK_UART_ROOT/uart_pl011_sample.c", + "$FRAMEWORK_UART_ROOT/uart_sample.c", + ] + + include_dirs = [ "//drivers/framework/sample/platform/uart/include/" ] +} diff --git a/sample/platform/uart/src/buf_fifo.c b/sample/platform/uart/src/buf_fifo.c new file mode 100755 index 0000000000000000000000000000000000000000..19da2dff6dc1e1b53face0fdfc17a8fed5421109 --- /dev/null +++ b/sample/platform/uart/src/buf_fifo.c @@ -0,0 +1,24 @@ +/* + * Copyright (c) 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 "buf_fifo.h" + +bool BufferFifoInit(struct BufferFifo *fifo, uint8_t *fifoBuffer, uint16_t fifoSize) +{ + if (fifoBuffer == NULL) { + return false; + } + if (!IsPowerOfTwo(fifoSize)) { + return false; + } + fifo->buffer = fifoBuffer; + fifo->bufSizeMask = fifoSize - 1; + fifo->readPosition = 0; + fifo->writePosition = 0; + return true; +} \ No newline at end of file diff --git a/sample/platform/uart/src/uart_dev_sample.c b/sample/platform/uart/src/uart_dev_sample.c new file mode 100755 index 0000000000000000000000000000000000000000..1369188fe2a69999ccfa39e935bb4f2b182386bf --- /dev/null +++ b/sample/platform/uart/src/uart_dev_sample.c @@ -0,0 +1,192 @@ +/* + * Copyright (c) 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 "uart_dev_sample.h" +#include "fs/fs.h" +#include "securec.h" +#include "user_copy.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "uart_pl011_sample.h" + +#define HDF_LOG_TAG uart_dev_sample +#define HDF_UART_FS_MODE 0660 + +static int32_t UartSampleDevOpen(struct file *filep) +{ + struct UartHost *host = NULL; + + if (filep == NULL || filep->f_vnode == NULL) { + return HDF_ERR_INVALID_PARAM; + } + struct drv_data *drv = (struct drv_data *)filep->f_vnode->data; + host = (struct UartHost *)drv->priv; + if (host == NULL) { + HDF_LOGE("%s: host is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + HDF_LOGI("%s: open uart%d success", __func__, host->num); + return HDF_SUCCESS; +} +static int32_t UartSampleRelease(struct file *filep) +{ + struct UartHost *host = NULL; + + if (filep == NULL || filep->f_vnode == NULL) { + return HDF_ERR_INVALID_PARAM; + } + struct drv_data *drv = (struct drv_data *)filep->f_vnode->data; + host = (struct UartHost *)drv->priv; + if (host == NULL) { + HDF_LOGE("%s: host is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + HDF_LOGI("%s: close uart%d success", __func__, host->num); + return HDF_SUCCESS; +} + +static ssize_t UartSampleRead(struct file *filep, char *buf, size_t count) +{ + int32_t ret; + uint8_t *tmpBuf = NULL; + struct UartHost *host = NULL; + + if (filep == NULL || filep->f_vnode == NULL) { + return HDF_ERR_INVALID_PARAM; + } + struct drv_data *drv = (struct drv_data *)filep->f_vnode->data; + host = (struct UartHost *)drv->priv; + + if (LOS_IsUserAddressRange((vaddr_t)(uintptr_t)buf, count)) { + tmpBuf = (uint8_t *)OsalMemCalloc(count); + if (tmpBuf == NULL) { + HDF_LOGE("%s: OsalMemCalloc error", __func__); + return HDF_ERR_MALLOC_FAIL; + } + ret = UartHostRead(host, tmpBuf, count); + if (ret == HDF_SUCCESS) { + ret = LOS_ArchCopyToUser(buf, tmpBuf, count); + } + OsalMemFree(tmpBuf); + return ret; + } else { + return UartHostRead(host, (uint8_t *)buf, count); + } +} + +static ssize_t UartSampleWrite(struct file *filep, const char *buf, size_t count) +{ + int32_t ret; + uint8_t *tmpBuf = NULL; + struct UartHost *host = NULL; + + if (filep == NULL || filep->f_vnode == NULL) { + return HDF_ERR_INVALID_PARAM; + } + struct drv_data *drv = (struct drv_data *)filep->f_vnode->data; + host = (struct UartHost *)drv->priv; + + if (LOS_IsUserAddressRange((vaddr_t)(uintptr_t)buf, count)) { + tmpBuf = (uint8_t *)OsalMemCalloc(count); + if (tmpBuf == NULL) { + HDF_LOGE("%s: OsalMemCalloc error", __func__); + return HDF_ERR_MALLOC_FAIL; + } + ret = LOS_ArchCopyFromUser(tmpBuf, buf, count); + if (ret != LOS_OK) { + OsalMemFree(tmpBuf); + return ret; + } + ret = UartHostWrite(host, tmpBuf, count); + OsalMemFree(tmpBuf); + return ret; + } else { + return UartHostWrite(host, (uint8_t *)buf, count); + } +} + +static int32_t UartSampleDevIoctl(struct file *filep, int32_t cmd, unsigned long arg) +{ + int32_t ret; + struct UartHost *host = NULL; + if (filep == NULL || filep->f_vnode == NULL) { + return HDF_ERR_INVALID_PARAM; + } + struct drv_data *drv = (struct drv_data *)filep->f_vnode->data; + host = (struct UartHost *)drv->priv; + if (host->priv == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + ret = HDF_FAILURE; + switch (cmd) { + case UART_CFG_BAUDRATE: + ret = UartHostSetBaud(host, arg); + break; + default: + HDF_LOGE("%s cmd %d not support", __func__, cmd); + ret = HDF_ERR_NOT_SUPPORT; + break; + } + return ret; +} + +const struct file_operations_vfs g_uartSampleDevFops = { + .open = UartSampleDevOpen, + .close = UartSampleRelease, + .read = UartSampleRead, + .write = UartSampleWrite, + .ioctl = UartSampleDevIoctl, +}; + +#define MAX_DEV_NAME_SIZE 32 +static void AddRemoveUartDev(struct UartHost *host, bool add) +{ + int32_t ret; + char *devName = NULL; + + if (host == NULL || host->priv == NULL) { + HDF_LOGW("%s: invalid parameter", __func__); + return; + } + devName = (char *)OsalMemCalloc(sizeof(char) * (MAX_DEV_NAME_SIZE + 1)); + if (devName == NULL) { + HDF_LOGE("%s: OsalMemCalloc error", __func__); + return; + } + ret = snprintf_s(devName, MAX_DEV_NAME_SIZE + 1, MAX_DEV_NAME_SIZE, "/dev/uartdev-%d", host->num); + if (ret < 0) { + HDF_LOGE("%s: snprintf_s failed", __func__); + OsalMemFree(devName); + return; + } + if (add) { + if (register_driver(devName, &g_uartSampleDevFops, HDF_UART_FS_MODE, host)) { + HDF_LOGE("%s: gen /dev/uartdev-%d fail!", __func__, host->num); + OsalMemFree(devName); + return; + } + } else { + if (unregister_driver(devName)) { + HDF_LOGE("%s: remove /dev/uartdev-%d fail!", __func__, host->num); + OsalMemFree(devName); + return; + } + } + OsalMemFree(devName); +} + +void AddUartDevice(struct UartHost *host) +{ + AddRemoveUartDev(host, true); +} + +void RemoveUartDevice(struct UartHost *host) +{ + AddRemoveUartDev(host, false); +} diff --git a/sample/platform/uart/src/uart_dispatch_sample.c b/sample/platform/uart/src/uart_dispatch_sample.c new file mode 100755 index 0000000000000000000000000000000000000000..6817896f769203333cb57522318060c8af5e86a3 --- /dev/null +++ b/sample/platform/uart/src/uart_dispatch_sample.c @@ -0,0 +1,66 @@ +/* + * Copyright (c) 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 "uart_core.h" +#include "uart_dispatch_sample.h" +#include "hdf_log.h" +#include "hdf_sbuf.h" +#include "uart_pl011_sample.h" + +#define HDF_LOG_TAG uart_dispatch_sample + +static int32_t SampleDispatchWrite(struct UartDevice *device, struct HdfSBuf *txBuf) +{ + uint32_t idx; + uint32_t dataSize = 0; + const uint8_t *data = NULL; + struct UartRegisterMap *regMap = (struct UartRegisterMap *)device->resource.physBase; + + if (regMap == NULL) { + HDF_LOGE("%s: regMap is NULL", __func__); + return HDF_FAILURE; + } + + if (!HdfSbufReadBuffer(txBuf, (const void **)&data, &dataSize)) { + HDF_LOGE("%s: Failed to read sbuf", __func__); + return HDF_FAILURE; + } + regMap = (struct UartRegisterMap *)device->resource.physBase; + for (idx = 0; idx < dataSize; idx++) { + UartPl011Write(regMap, data[idx]); + } + return HDF_SUCCESS; +} + +int32_t SampleDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + int32_t result = HDF_FAILURE; + if (client == NULL || client->device == NULL) { + HDF_LOGE("%s: client or client->device is NULL", __func__); + return result; + } + struct UartHost *uartHost = (struct UartHost *)client->device->service; + if (uartHost == NULL) { + HDF_LOGE("%s: uartHost is NULL", __func__); + return result; + } + struct UartDevice *uartDevice = (struct UartDevice *)uartHost->priv; + if (uartDevice == NULL) { + HDF_LOGE("%s: uartDevice is NULL", __func__); + return result; + } + switch (cmdId) { + case UART_WRITE: { + result = SampleDispatchWrite(uartDevice, data); + break; + } + default: + break; + } + return result; +} diff --git a/sample/platform/uart/src/uart_pl011_sample.c b/sample/platform/uart/src/uart_pl011_sample.c new file mode 100755 index 0000000000000000000000000000000000000000..12f2c6cf305efbfc1c914dfd686809bf1e17734e --- /dev/null +++ b/sample/platform/uart/src/uart_pl011_sample.c @@ -0,0 +1,90 @@ +/* + * Copyright (c) 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 "uart_pl011_sample.h" + +void UartPl011SetLcrBits(struct UartRegisterMap *regMap, uint32_t bits) +{ + bool uartEnabled = UartPl011IsEnabled(regMap); + /* UART must be disabled before UARTLCR_H are reprogrammed */ + UartPl011Disable(regMap); + regMap->lcr |= (bits); + /* Restore uart enable state */ + if (uartEnabled) { + UartPl011Enable(regMap); + } +} + +void UartPl011UpdateLcr(struct UartRegisterMap *regMap) +{ + bool uartEnabled = UartPl011IsEnabled(regMap); + /* UART must be disabled before UARTLCR_H are reprogrammed */ + UartPl011Disable(regMap); + regMap->lcr = regMap->lcr; + /* restore uart enable state */ + if (uartEnabled) { + UartPl011Enable(regMap); + } +} + +UartPl011Error UartPl011SetBaudrate(struct UartRegisterMap *regMap, uint32_t clk, uint32_t baudrate) +{ + if (baudrate == 0) { + return UART_PL011_ERR_INVALID_ARG; + } + + uint32_t value = SAMPLING_FACTOR * baudrate; + uint32_t divider = clk / value; + uint32_t remainder = clk % value; + uint32_t fraction; + value = (SAMPLING_FACTOR * remainder) / baudrate; + fraction = (value >> 1) + (value & 1); + + regMap->ibrd = divider; + regMap->fbrd = fraction; + /* to internally update the contents of UARTIBRD or + * UARTFBRD, a UARTLCR_H write must always be performed at the end. + */ + UartPl011UpdateLcr(regMap); + return UART_PL011_ERR_NONE; +} + +void UartPl011SetDataFormat( + struct UartRegisterMap *regMap, uint32_t wordLen, uint32_t parity, uint32_t stopBits) +{ + bool uartEnabled = UartPl011IsEnabled(regMap); + uint32_t lcr = regMap->lcr & (~UART_PL011_DATA_FORMAT_MASK); + lcr |= wordLen & UART_PL011_LCR_H_WLEN_MASK; + lcr |= parity & UART_PL011_LCR_H_PARITY_MASK; + lcr |= stopBits & UART_PL011_LCR_H_STOPBIT_MASK; + /* UART must be disabled before UARTLCR_H are reprogrammed */ + UartPl011Disable(regMap); + regMap->lcr = lcr; + if (uartEnabled) { + UartPl011Enable(regMap); + } +} + +void UartPl011ResetRegisters(struct UartRegisterMap *regMap) +{ + regMap->cr = UART_PL011_DEFAULT_CTRL_REG_VALUE; + regMap->dr = UART_PL011_DEFAULT_DATA_REG_VALUE; + /* Clear all the errors */ + regMap->ecr = UART_PL011_DEFAULT_ECR_VALUE; + regMap->ilpr = UART_PL011_DEFAULT_ILPR_VALUE; + regMap->ibrd = UART_PL011_DEFAULT_IBRD_REG_VALUE; + regMap->fbrd = UART_PL011_DEFAULT_FBRD_REG_VALUE; + regMap->lcr = UART_PL011_DEFAULT_LCR_H_VALUE; + regMap->ifls = UART_PL011_DEFAULT_IFLS_REG_VALUE; + /* Clear all interrupt mask */ + regMap->imsc = UART_PL011_DEFAULT_IMSC_REG_VALUE; + /* Clear all interrupts */ + regMap->icr = UART_PL011_DEFAULT_ICR_VALUE; + regMap->dmacr = UART_PL011_DEFAULT_DMACR_VALUE; +} + diff --git a/sample/platform/uart/src/uart_sample.c b/sample/platform/uart/src/uart_sample.c new file mode 100755 index 0000000000000000000000000000000000000000..19678890d6475acc62cd5b9d9ddea20e34119a96 --- /dev/null +++ b/sample/platform/uart/src/uart_sample.c @@ -0,0 +1,344 @@ +/* + * Copyright (c) 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 "device_resource_if.h" +#include "buf_fifo.h" +#include "hdf_device_desc.h" +#include "hdf_log.h" +#include "hisoc/uart.h" +#include "osal_io.h" +#include "osal_mem.h" +#include "uart_core.h" +#include "uart_dev_sample.h" +#include "uart_dispatch_sample.h" +#include "uart_pl011_sample.h" + +#define HDF_LOG_TAG uart_sample +#define UART_RX_FIFO_SIZE 128 + +static uint8_t g_fifoBuffer[UART_RX_FIFO_SIZE] = {0}; + +/* HdfDriverEntry method definitions */ +static int32_t SampleUartDriverBind(struct HdfDeviceObject *device); +static int32_t SampleUartDriverInit(struct HdfDeviceObject *device); +static void SampleUartDriverRelease(struct HdfDeviceObject *device); + +/* HdfDriverEntry definitions */ +struct HdfDriverEntry g_sampleUartDriverEntry = { + .moduleVersion = 1, + .moduleName = "UART_SAMPLE", + .Bind = SampleUartDriverBind, + .Init = SampleUartDriverInit, + .Release = SampleUartDriverRelease, +}; + +// Initialize HdfDriverEntry +HDF_INIT(g_sampleUartDriverEntry); + +/* UartHostMethod method definitions */ +static int32_t SampleUartHostInit(struct UartHost *host); +static int32_t SampleUartHostDeinit(struct UartHost *host); +static int32_t SampleUartHostWrite(struct UartHost *host, uint8_t *data, uint32_t size); +static int32_t SampleUartHostSetBaud(struct UartHost *host, uint32_t baudRate); +static int32_t SampleUartHostGetBaud(struct UartHost *host, uint32_t *baudRate); + +/* UartHostMethod definitions */ +struct UartHostMethod g_sampleUartHostMethod = { + .Init = SampleUartHostInit, + .Deinit = SampleUartHostDeinit, + .Read = NULL, + .Write = SampleUartHostWrite, + .SetBaud = SampleUartHostSetBaud, + .GetBaud = SampleUartHostGetBaud, + .SetAttribute = NULL, + .GetAttribute = NULL, + .SetTransMode = NULL, +}; + +/* UartHostMethod implementations */ +static int32_t SampleUartHostInit(struct UartHost *host) +{ + HDF_LOGD("%s: Enter", __func__); + if (host == NULL) { + HDF_LOGW("%s: invalid parameter", __func__); + return HDF_ERR_INVALID_PARAM; + } + return HDF_SUCCESS; +} + +static int32_t SampleUartHostDeinit(struct UartHost *host) +{ + HDF_LOGD("%s: Enter", __func__); + if (host == NULL) { + HDF_LOGW("%s: invalid parameter", __func__); + return HDF_ERR_INVALID_PARAM; + } + return HDF_SUCCESS; +} + +static int32_t SampleUartHostWrite(struct UartHost *host, uint8_t *data, uint32_t size) +{ + uint32_t idx; + struct UartRegisterMap *regMap = NULL; + struct UartDevice *device = NULL; + HDF_LOGD("%s: Enter", __func__); + + if (host == NULL || data == NULL || size == 0) { + HDF_LOGW("%s: invalid parameter", __func__); + return HDF_ERR_INVALID_PARAM; + } + device = (struct UartDevice *)host->priv; + if (device == NULL) { + HDF_LOGW("%s: device is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + regMap = (struct UartRegisterMap *)device->resource.physBase; + for (idx = 0; idx < size; idx++) { + UartPl011Write(regMap, data[idx]); + } + return HDF_SUCCESS; +} + +static int32_t SampleUartHostSetBaud(struct UartHost *host, uint32_t baudRate) +{ + struct UartDevice *device = NULL; + struct UartRegisterMap *regMap = NULL; + UartPl011Error err; + HDF_LOGD("%s: Enter", __func__); + + if (host == NULL) { + HDF_LOGW("%s: invalid parameter", __func__); + return HDF_ERR_INVALID_PARAM; + } + device = (struct UartDevice *)host->priv; + if (device == NULL) { + HDF_LOGW("%s: device is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + regMap = (struct UartRegisterMap *)device->resource.physBase; + if (device->state != UART_DEVICE_INITIALIZED) { + return UART_PL011_ERR_NOT_INIT; + } + if (baudRate == 0) { + return UART_PL011_ERR_INVALID_BAUD; + } + err = UartPl011SetBaudrate(regMap, device->uartClk, baudRate); + if (err == UART_PL011_ERR_NONE) { + device->baudrate = baudRate; + } + return err; +} + +static int32_t SampleUartHostGetBaud(struct UartHost *host, uint32_t *baudRate) +{ + struct UartDevice *device = NULL; + HDF_LOGD("%s: Enter", __func__); + + if (host == NULL) { + HDF_LOGW("%s: invalid parameter", __func__); + return HDF_ERR_INVALID_PARAM; + } + device = (struct UartDevice *)host->priv; + if (device == NULL) { + HDF_LOGW("%s: device is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + *baudRate = device->baudrate; + return HDF_SUCCESS; +} + +static int InitUartDevice(struct UartDevice *device) +{ + UartPl011Error err; + struct UartResource *resource = &device->resource; + struct UartRegisterMap *regMap = (struct UartRegisterMap *)resource->physBase; + if ((resource->uartClk == 0) || (resource->baudrate == 0)) { + return HDF_ERR_INVALID_PARAM; + } + /* Updating the system clock */ + device->uartClk = resource->uartClk; + uart_clk_cfg(0, true); + /* clear and reset registers. */ + UartPl011ResetRegisters(regMap); + /* set baud rate as device config */ + err = UartPl011SetBaudrate(regMap, resource->uartClk, resource->baudrate); + if (err != UART_PL011_ERR_NONE) { + return HDF_FAILURE; + } + /* set the data format as device config */ + UartPl011SetDataFormat(regMap, resource->wlen, resource->parity, resource->stopBit); + /* Enabling the FIFOs */ + UartPl011EnableFifo(regMap); + UartPl011Enable(regMap); + BufferFifoInit(&device->rxFifo, g_fifoBuffer, UART_RX_FIFO_SIZE); + device->state = UART_DEVICE_INITIALIZED; + return HDF_SUCCESS; +} + +static uint32_t GetUartDeviceResource( + struct UartDevice *device, const struct DeviceResourceNode *resourceNode) +{ + struct UartResource *resource = &device->resource; + struct DeviceResourceIface *dri = NULL; + dri = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (dri == NULL || dri->GetUint32 == NULL) { + HDF_LOGE("DeviceResourceIface is invalid"); + return HDF_FAILURE; + } + + if (dri->GetUint32(resourceNode, "num", &resource->num, 0) != HDF_SUCCESS) { + HDF_LOGE("uart config read num fail"); + return HDF_FAILURE; + } + if (dri->GetUint32(resourceNode, "base", &resource->base, 0) != HDF_SUCCESS) { + HDF_LOGE("uart config read base fail"); + return HDF_FAILURE; + } + resource->physBase = (unsigned long)OsalIoRemap(resource->base, 0x48); + if (resource->physBase == 0) { + HDF_LOGE("uart config fail to remap physBase"); + return HDF_FAILURE; + } + if (dri->GetUint32(resourceNode, "irqNum", &resource->irqNum, 0) != HDF_SUCCESS) { + HDF_LOGE("uart config read irqNum fail"); + return HDF_FAILURE; + } + if (dri->GetUint32(resourceNode, "baudrate", &resource->baudrate, 0) != HDF_SUCCESS) { + HDF_LOGE("uart config read baudrate fail"); + return HDF_FAILURE; + } + if (dri->GetUint32(resourceNode, "wlen", &resource->wlen, 0) != HDF_SUCCESS) { + HDF_LOGE("uart config read wlen fail"); + return HDF_FAILURE; + } + if (dri->GetUint32(resourceNode, "parity", &resource->parity, 0) != HDF_SUCCESS) { + HDF_LOGE("uart config read parity fail"); + return HDF_FAILURE; + } + if (dri->GetUint32(resourceNode, "stopBit", &resource->stopBit, 0) != HDF_SUCCESS) { + HDF_LOGE("uart config read stopBit fail"); + return HDF_FAILURE; + } + if (dri->GetUint32(resourceNode, "uartClk", &resource->uartClk, 0) != HDF_SUCCESS) { + HDF_LOGE("uart config read uartClk fail"); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static int32_t AttachUartDevice(struct UartHost *host, struct HdfDeviceObject *device) +{ + int32_t ret; + struct UartDevice *uartDevice = NULL; + if (device->property == NULL) { + HDF_LOGW("%s: property is NULL", __func__); + return HDF_FAILURE; + } + uartDevice = (struct UartDevice *)OsalMemCalloc(sizeof(struct UartDevice)); + if (uartDevice == NULL) { + HDF_LOGE("%s: OsalMemCalloc uartDevice error", __func__); + return HDF_ERR_MALLOC_FAIL; + } + ret = GetUartDeviceResource(uartDevice, device->property); + if (ret != HDF_SUCCESS) { + (void)OsalMemFree(uartDevice); + return HDF_FAILURE; + } + host->num = uartDevice->resource.num; + host->priv = uartDevice; + AddUartDevice(host); + return InitUartDevice(uartDevice); +} + +static void DeinitUartDevice(struct UartDevice *device) +{ + struct UartRegisterMap *regMap = (struct UartRegisterMap *)device->resource.physBase; + /* wait for uart enter idle. */ + while (UartPl011IsBusy(regMap)) { } + UartPl011ResetRegisters(regMap); + uart_clk_cfg(0, false); + OsalIoUnmap((void *)device->resource.physBase); + device->state = UART_DEVICE_UNINITIALIZED; +} + +static void DetachUartDevice(struct UartHost *host) +{ + struct UartDevice *uartDevice = NULL; + + if (host->priv == NULL) { + HDF_LOGW("%s: invalid parameter", __func__); + return; + } + uartDevice = host->priv; + DeinitUartDevice(uartDevice); + (void)OsalMemFree(uartDevice); + host->priv = NULL; +} + +/* HdfDriverEntry implementations */ +static int32_t SampleUartDriverBind(struct HdfDeviceObject *device) +{ + struct UartHost *uartHost = NULL; + HDF_LOGD("%s: Enter", __func__); + + if (device == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + uartHost = UartHostCreate(device); + if (uartHost == NULL) { + HDF_LOGE("%s: UartHostCreate failed", __func__); + return HDF_FAILURE; + } + uartHost->service.Dispatch = SampleDispatch; + return HDF_SUCCESS; +} + +static int32_t SampleUartDriverInit(struct HdfDeviceObject *device) +{ + int32_t ret; + struct UartHost *host = NULL; + HDF_LOGD("%s: Enter", __func__); + + if (device == NULL) { + HDF_LOGE("%s: device is NULL", __func__); + return HDF_ERR_INVALID_OBJECT; + } + host = UartHostFromDevice(device); + if (host == NULL) { + HDF_LOGE("%s: host is NULL", __func__); + return HDF_FAILURE; + } + ret = AttachUartDevice(host, device); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: attach error", __func__); + return HDF_FAILURE; + } + host->method = &g_sampleUartHostMethod; + return ret; +} + +static void SampleUartDriverRelease(struct HdfDeviceObject *device) +{ + struct UartHost *host = NULL; + HDF_LOGD("%s: Enter", __func__); + + if (device == NULL) { + HDF_LOGE("%s: device is NULL", __func__); + return; + } + host = UartHostFromDevice(device); + if (host == NULL) { + HDF_LOGE("%s: host is NULL", __func__); + return; + } + if (host->priv != NULL) { + DetachUartDevice(host); + } + UartHostDestroy(host); +} diff --git a/support/platform/include/adc_core.h b/support/platform/include/adc/adc_core.h similarity index 98% rename from support/platform/include/adc_core.h rename to support/platform/include/adc/adc_core.h index e0e47b521eacdc4161320e5ccde8e123f1eed8ae..c6890dfddbeea13c5f0993bec62517d3e06c363b 100644 --- a/support/platform/include/adc_core.h +++ b/support/platform/include/adc/adc_core.h @@ -12,6 +12,7 @@ #include "osal_spinlock.h" #include "hdf_base.h" #include "adc_if.h" +#include "platform_core.h" #ifdef __cplusplus #if __cplusplus diff --git a/support/platform/include/dac/dac_core.h b/support/platform/include/dac/dac_core.h new file mode 100644 index 0000000000000000000000000000000000000000..8c04f35cdb8293b026592a42739ade7bbbc892d8 --- /dev/null +++ b/support/platform/include/dac/dac_core.h @@ -0,0 +1,75 @@ +/* + * Copyright (c) 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 DAC_CORE_H +#define DAC_CORE_H + +#include "osal_spinlock.h" +#include "hdf_base.h" +#include "dac_if.h" +#include "platform_core.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +#define DAC_DEVICES_MAX 15 + +struct DacDevice; +struct DacMethod; +struct DacLockMethod; + +struct DacDevice { + const struct DacMethod *ops; + OsalSpinlock spin; + uint32_t devNum; + uint32_t chanNum; + const struct DacLockMethod *lockOps; + void *priv; +}; + +struct DacMethod { + int32_t (*write)(struct DacDevice *device, uint32_t channel, uint32_t val); + int32_t (*start)(struct DacDevice *device); + int32_t (*stop)(struct DacDevice *device); +}; + +struct DacLockMethod { + int32_t (*lock)(struct DacDevice *device); + void (*unlock)(struct DacDevice *device); +}; + +enum DacIoCmd { + DAC_IO_READ = 0, + DAC_IO_OPEN, + DAC_IO_CLOSE, +}; + +int32_t DacDeviceAdd(struct DacDevice *device); + +void DacDeviceRemove(struct DacDevice *device); + +struct DacDevice *DacDeviceGet(uint32_t number); + +void DacDevicePut(struct DacDevice *device); + +int32_t DacDeviceWrite(struct DacDevice *device, uint32_t channel, uint32_t val); + +int32_t DacDeviceStart(struct DacDevice *device); + +int32_t DacDeviceStop(struct DacDevice *device); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* DAC_CORE_H */ diff --git a/support/platform/include/dmac_core.h b/support/platform/include/dma/dmac_core.h similarity index 100% rename from support/platform/include/dmac_core.h rename to support/platform/include/dma/dmac_core.h diff --git a/support/platform/include/common/platform_core.h b/support/platform/include/fwk/platform_core.h similarity index 95% rename from support/platform/include/common/platform_core.h rename to support/platform/include/fwk/platform_core.h index 08e5770dd8224fa5827d337b3156372d327c3cd5..669d65cb21270c635df9707c4063e034f82821f5 100644 --- a/support/platform/include/common/platform_core.h +++ b/support/platform/include/fwk/platform_core.h @@ -11,10 +11,13 @@ #include "hdf_base.h" -#include "platform_device.h" +#include "platform_log.h" #include "platform_errno.h" -#include "platform_manager.h" #include "platform_queue.h" +#ifndef __USER__ +#include "platform_device.h" +#include "platform_manager.h" +#endif #ifdef __cplusplus #if __cplusplus @@ -30,6 +33,7 @@ enum PlatformModuleType { PLATFORM_MODULE_CLOCK, PLATFORM_MODULE_REGULATOR, PLATFORM_MODULE_MIPI_DSI, + PLATFORM_MODULE_MIPI_CSI, PLATFORM_MODULE_UART, PLATFORM_MODULE_SDIO, PLATFORM_MODULE_MDIO, diff --git a/support/platform/include/common/platform_device.h b/support/platform/include/fwk/platform_device.h similarity index 58% rename from support/platform/include/common/platform_device.h rename to support/platform/include/fwk/platform_device.h index 3b25cea81e709b0f9b25eb528c83c2733ce24456..f25d11053974040e422ee63929b2cbf2eae5a25a 100644 --- a/support/platform/include/common/platform_device.h +++ b/support/platform/include/fwk/platform_device.h @@ -10,6 +10,7 @@ #define PLATFORM_DEVICE_H #include "hdf_base.h" +#include "hdf_device_desc.h" #include "hdf_dlist.h" #include "hdf_sref.h" #include "osal_sem.h" @@ -24,20 +25,24 @@ extern "C" { struct PlatformManager; struct PlatformDevice { - struct HdfDeviceObject *hdfDev; /* releated to an hdf device object */ - struct PlatformManager *manager; /* the platform manager it belongs to */ - uint32_t magic; /* magic number of the device instance */ - const char *name; /* name of the device instance */ - struct HdfSRef ref; /* used for reference count */ - struct DListHead node; /* linked to the list of a manager */ - struct DListHead notifiers; /* list of notifier nodes */ - bool ready; /* indicates whether initialized */ - OsalSpinlock spin; /* for member protection */ - struct OsalSem released; /* for death notification */ + struct HdfDeviceObject *hdfDev; /* releated to a hdf device object */ + struct IDeviceIoService *service; /* releated to a hdf io service object */ + struct PlatformManager *manager; /* the platform manager it belongs to */ + int32_t number; /* number of the device instance */ + const char *name; /* name of the device instance */ + struct HdfSRef ref; /* used for reference count */ + struct DListHead node; /* linked to the list of a manager */ + struct DListHead notifiers; /* list of notifier nodes */ + bool ready; /* indicates whether initialized */ + OsalSpinlock spin; /* for member protection */ + struct OsalSem released; /* for death notification */ + void *priv; /* private data of the device */ }; enum PlatformEventType { - PLAT_EVENT_DEAD = 0, /* a platform device going to die */ + PLAT_EVENT_INIT = 0, /* a platform device already initialized */ + PLAT_EVENT_DEAD = 1, /* a platform device going to die */ + PLAT_EVENT_MAX = 2, }; struct PlatformNotifier { @@ -114,6 +119,17 @@ void PlatformDevicePut(struct PlatformDevice *device); */ int32_t PlatformDeviceRegNotifier(struct PlatformDevice *device, struct PlatformNotifier *notifier); +/** + * @brief Notify a platform event. + * + * @param device Indicates the pointer to the platform device. + * @param event The platform event to notify. + * + * @return Returns 0 if the notify successfully; returns a negative value otherwise. + * @since 1.0 + */ +int32_t PlatformDeviceNotify(struct PlatformDevice *device, int32_t event); + /** * @brief Unregister a notifier to a platform device. * @@ -160,6 +176,64 @@ int32_t PlatformDeviceAdd(struct PlatformDevice *device); */ void PlatformDeviceDel(struct PlatformDevice *device); +/** + * @brief Get device resource node of the device. + * + * @param device Indicates the pointer to the platform device. + * + * @since 1.0 + */ +struct DeviceResourceNode *PlatformDeviceGetDrs(struct PlatformDevice *device); + +/** + * @brief Create a hdf device service for the platform device. + * + * @param device Indicates the pointer to the platform device. + * @param dispatch Dispatch function for the service. + * + * @since 1.0 + */ +int32_t PlatformDeviceCreateService(struct PlatformDevice *device, + int32_t (*dispatch)(struct HdfDeviceIoClient *client, int cmd, struct HdfSBuf *data, struct HdfSBuf *reply)); + +/** + * @brief Destroy the hdf device service for the platform device. + * + * @param device Indicates the pointer to the platform device. + * + * @since 1.0 + */ +int32_t PlatformDeviceDestroyService(struct PlatformDevice *device); + +/** + * @brief Bind to a hdf device object. + * + * @param device Indicates the pointer to the platform device. + * @param hdfDevice Indicates the pointer to the hdf device object. + * + * @since 1.0 + */ +int32_t PlatformDeviceBind(struct PlatformDevice *device, struct HdfDeviceObject *hdfDevice); + +/** + * @brief Unbind from a hdf device object. + * + * @param device Indicates the pointer to the platform device. + * + * @since 1.0 + */ +int32_t PlatformDeviceUnbind(struct PlatformDevice *device); + + +/** + * @brief Get the platform device from a hdf device object. + * + * @param device Indicates the pointer to the platform device. + * + * @since 1.0 + */ +struct PlatformDevice *PlatformDeviceFromHdf(struct HdfDeviceObject *device); + #ifdef __cplusplus #if __cplusplus } diff --git a/support/platform/include/common/platform_errno.h b/support/platform/include/fwk/platform_errno.h similarity index 100% rename from support/platform/include/common/platform_errno.h rename to support/platform/include/fwk/platform_errno.h diff --git a/support/platform/include/plat_log.h b/support/platform/include/fwk/platform_log.h similarity index 70% rename from support/platform/include/plat_log.h rename to support/platform/include/fwk/platform_log.h index d3b4c6f2927a21d6ea01aae030d04daa99cfbb95..ab097fb147dba1610ec41d1a11da1fb1534afaeb 100644 --- a/support/platform/include/plat_log.h +++ b/support/platform/include/fwk/platform_log.h @@ -17,4 +17,9 @@ #define PLAT_LOGV(fmt, arg...) HDF_LOGV(fmt, ##arg) #endif +#define PLAT_LOGD(fmt, arg...) HDF_LOGD(fmt, ##arg) +#define PLAT_LOGI(fmt, arg...) HDF_LOGI(fmt, ##arg) +#define PLAT_LOGW(fmt, arg...) HDF_LOGW(fmt, ##arg) +#define PLAT_LOGE(fmt, arg...) HDF_LOGE(fmt, ##arg) + #endif /* PLATFORM_LOG_H */ diff --git a/support/platform/include/common/platform_manager.h b/support/platform/include/fwk/platform_manager.h similarity index 88% rename from support/platform/include/common/platform_manager.h rename to support/platform/include/fwk/platform_manager.h index fa4c9d198088602d949211dd6d13e043cf48f424..0faa1944f02e4aa34b54b31a4be6112ad6ea8823 100644 --- a/support/platform/include/common/platform_manager.h +++ b/support/platform/include/fwk/platform_manager.h @@ -22,9 +22,12 @@ extern "C" { enum PlatformModuleType; struct PlatformManager { + struct PlatformDevice device; const char *name; /* name of the manager */ struct DListHead devices; /* list to keep all it's device instances */ OsalSpinlock spin; /* for member protection */ + int32_t (*add)(struct PlatformManager *manager, struct PlatformDevice *device); + int32_t (*del)(struct PlatformManager *manager, struct PlatformDevice *device); }; /** @@ -92,17 +95,17 @@ struct PlatformDevice *PlatformManagerFindDevice(struct PlatformManager *manager bool (*match)(struct PlatformDevice *pdevice, void *data)); /** - * @brief Get a platform device from the manager by magic. + * @brief Get a platform device from the manager by number. * * The device got will be returned with reference count increased. * * @param manager Indicates the pointer to the platform manager. - * @param magic Indicates the magic number of the target platform device. + * @param number Indicates the number number of the target platform device. * * @return Returns the pointer to the paltform device on success; returns NULL otherwise. * @since 1.0 */ -struct PlatformDevice *PlatformManagerGetDeviceByMagic(struct PlatformManager *manager, uint32_t magic); +struct PlatformDevice *PlatformManagerGetDeviceByNumber(struct PlatformManager *manager, uint32_t number); #ifdef __cplusplus #if __cplusplus diff --git a/support/platform/include/common/platform_queue.h b/support/platform/include/fwk/platform_queue.h similarity index 100% rename from support/platform/include/common/platform_queue.h rename to support/platform/include/fwk/platform_queue.h diff --git a/support/platform/include/gpio_core.h b/support/platform/include/gpio/gpio_core.h similarity index 97% rename from support/platform/include/gpio_core.h rename to support/platform/include/gpio/gpio_core.h index 4f8fbdd6f4caf1963ba7c07a21ca6f8127dd9563..720fd237d97e177dc068e651af6518ac411e43ee 100644 --- a/support/platform/include/gpio_core.h +++ b/support/platform/include/gpio/gpio_core.h @@ -14,6 +14,7 @@ #include "hdf_dlist.h" #include "gpio_if.h" #include "osal_spinlock.h" +#include "platform_core.h" #ifdef __cplusplus #if __cplusplus @@ -33,11 +34,8 @@ struct GpioInfo; * @since 1.0 */ struct GpioCntlr { - struct IDeviceIoService service; - struct HdfDeviceObject *device; + struct PlatformDevice device; struct GpioMethod *ops; - struct DListHead list; - OsalSpinlock spin; uint16_t start; uint16_t count; struct GpioInfo *ginfos; @@ -136,6 +134,8 @@ int32_t GpioCntlrDisableIrq(struct GpioCntlr *cntlr, uint16_t local); void GpioCntlrIrqCallback(struct GpioCntlr *cntlr, uint16_t local); +struct PlatformManager *GpioManagerGet(void); + struct GpioCntlr *GpioGetCntlr(uint16_t gpio); static inline uint16_t GpioToLocal(uint16_t gpio) diff --git a/support/platform/include/mmc/mmc_block.h b/support/platform/include/gpio/gpio_service.h similarity index 60% rename from support/platform/include/mmc/mmc_block.h rename to support/platform/include/gpio/gpio_service.h index bec2bb785c3e1b8a73fb816c99ca64dd5193e679..80e2b4dcfbc5f813a22c129b9efbdd3599d8e2c3 100644 --- a/support/platform/include/mmc/mmc_block.h +++ b/support/platform/include/gpio/gpio_service.h @@ -1,15 +1,13 @@ /* - * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * Copyright (c) 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 MMC_BLOCK_H -#define MMC_BLOCK_H - -#include "mmc_corex.h" +#ifndef GPIO_SERVICE_H +#define GPIO_SERVICE_H #ifdef __cplusplus #if __cplusplus @@ -17,8 +15,12 @@ extern "C" { #endif #endif /* __cplusplus */ -int32_t MmcBlockAdd(struct MmcDevice *mmc); -void MmcBlockDel(struct MmcDevice *mmc); +enum GpioIoCmd { + GPIO_IO_READ = 0, + GPIO_IO_WRITE = 1, + GPIO_IO_GETDIR = 2, + GPIO_IO_SETDIR = 3, +}; #ifdef __cplusplus #if __cplusplus @@ -26,4 +28,4 @@ void MmcBlockDel(struct MmcDevice *mmc); #endif #endif /* __cplusplus */ -#endif /* MMC_BLOCK_H */ +#endif /* GPIO_SERVICE_H */ diff --git a/support/platform/include/hdmi/hdmi_cec.h b/support/platform/include/hdmi/hdmi_cec.h new file mode 100644 index 0000000000000000000000000000000000000000..838547c4fd84f8197cb4b116b293cafcca43cd59 --- /dev/null +++ b/support/platform/include/hdmi/hdmi_cec.h @@ -0,0 +1,1735 @@ +/* + * Copyright (c) 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 HDMI_CEC_H +#define HDMI_CEC_H + +#include "hdf_base.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/* + * CEC(Consumer Electronics Control). + * CEC is a protocol that provides high-level control functions between all of the various audiovisual products + * in a user's environment. + */ + +/* + * One Touch Play Feature/Routing Control Feature. + * Used by a new source to indicate that it has started to transmit a stream OR + * used in response to a . + * Param: [Physical Address], 2 bytes. + * Broadcast message. + */ +#define HDMI_CEC_OPCODE_ACTIVE_SOURCE 0x82 + +#define HDMI_CEC_ACTIVE_SOURCE_MSG_PARAM_LEN 2 + +/* + * One Touch Play Feature. + * Sent by a source device to the TV whenever it enters the + * active state(alternatively it may send ). + * Param: None. + */ +#define HDMI_CEC_OPCODE_IMAGE_VIEW_ON 0x04 + +/* + * One Touch Play Feature. + * As , but should also remove any text, menus and PIP windows from the TV's display. + * Param: None. + */ +#define HDMI_CEC_OPCODE_TEXT_VIEW_ON 0x0D + +/* + * Routing Control Feature. + * Used by currently active source to inform the TV that it has no video to be presented to the user, + * or is going into the Standby state as the result of a local user command on the device. + * Param: [Physical Address], 2 bytes. + */ +#define HDMI_CEC_OPCODE_INACTIVE_SOURCE 0x9D + +#define HDMI_CEC_INACTIVE_SOURCE_MSG_PARAM_LEN 2 + +/* + * Routing Control Feature. + * Used by a new device to discover the status of the system. + * Param: None. + * Broadcast message. + */ +#define HDMI_CEC_OPCODE_REQUEST_ACTIVE_SOURCE 0x85 + +/* + * Routing Control Feature. + * Sent By CEC Switch when it is manually switched to inform all other devices on the network that + * the active route below the switch has changed. + * Param: [Original(Physical) Address], 2 bytes. [New(Physical) Address], 2 bytes. + * Broadcast message. + */ +#define HDMI_CEC_OPCODE_ROUTING_CHANGE 0x80 + +#define HDMI_CEC_ROUTING_CHANGE_MSG_PARAM_LEN 4 + +/* + * Routing Control Feature. + * Sent By a CEC Switch to indicate the active route below the switch. + * Param: [Physical Address], 2 bytes. + * Broadcast message. + */ +#define HDMI_CEC_OPCODE_ROUTING_INFORMATION 0x81 + +#define HDMI_CEC_ROUTING_INFORMATIO_MSG_PARAM_LEN 2 + +/* + * Routing Control Feature. + * Used by the TV to request a streaming path from the specified Physical Address. + * Param: [Physical Address], 2 bytes. + * Broadcast message. + */ +#define HDMI_CEC_OPCODE_SET_STREAM_PATH 0x86 + +#define HDMI_CEC_SET_STREAM_PATH_MSG_PARAM_LEN 2 + +/* + * Routing Control Feature. + * Switches one or all devices into the Standby state. + * Can be used as a broadcast message or be addressed to a specific device. + * Param: None. + */ +#define HDMI_CEC_OPCODE_STANDBY 0x36 + +/* + * One Touch Record Feature. + * Request a device stop a recording. + * Param: None. + */ +#define HDMI_CEC_OPCODE_RECORD_OFF 0x0B + +/* + * One Touch Record Feature. + * Attempt to record the specified source. + * Param: [Record Source], 1~8 bytes. + */ +#define HDMI_CEC_OPCODE_RECORD_ON 0x09 + +/* Record Source Type, 1 byte. */ +#define HDMI_CEC_RECORD_SOURCE_TYPE_LEN 1 +enum HdmiCecRecordSourceType { + HDMI_CEC_RECORD_SRC_OWN = 1, + HDMI_CEC_RECORD_SRC_DIGITAL = 2, + HDMI_CEC_RECORD_SRC_ANALOG = 3, + HDMI_CEC_RECORD_SRC_EXT_PLUG = 4, + HDMI_CEC_RECORD_SRC_EXT_PHY_ADDR = 5, +}; + +/* + * Digital Service Identification. 7 bytes. + * [Service Identification Method] 1 bit + * [Digital Broadcast System] 7 bits + * [Service Identification] 6 bytes + */ +#define HDMI_CEC_DIGITAL_SERVICE_ID_LEN 7 +#define HDMI_CEC_SERVICE_ID_METHOD_BY_DIGITAL_IDS 0 +#define HDMI_CEC_SERVICE_ID_METHOD_BY_CHANNEL 1 + +enum HdmiCecDigitalBroadcastSystem { + HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ARIB_GEN = 0x00, + HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ATSC_GEN = 0x01, + HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_DVB_GEN = 0x02, + HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ARIB_BS = 0x08, + HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ARIB_CS = 0x09, + HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ARIB_T = 0x0A, + HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ATSC_CABLE = 0x10, + HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ATSC_SATELLITE = 0x11, + HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ATSC_TERRESTRIAL = 0x12, + HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_DVB_C = 0x18, + HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_DVB_S = 0x19, + HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_DVB_S2 = 0x1A, + HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_DVB_T = 0x1B, +}; + +/* + * Service Identification, 6 bytes. + * [ARIB Data] | [ATSC Data] | [DVB Data] | [Channel Data] + * Channel Data, 6 bytes. + * [Channel Identifier] 4 bytes, [Reserved] 2 bytes. + * Channel Identifier, 4 bytes. + * [Channel Number Format] 6 bits. + * [Major Channel Number] 10 bits. + * [Minor Channel Number] 16 bits + */ +#define HDMI_CEC_CHANNEL_NUMBER_FORMAT_1_PART 0x01 +#define HDMI_CEC_CHANNEL_NUMBER_FORMAT_2_PART 0x02 +#define HDMI_CEC_CHANNEL_NUMBER_FORMAT_SHIFT 2 + +struct HdmiCecDigitalServiceAribData { + uint16_t transportId; + uint16_t serviceId; + uint16_t orgNetworkId; +}; + +struct HdmiCecDigitalServiceAtscData { + uint16_t transportId; + uint16_t programNumber; +}; + +struct HdmiCecDigitalServiceDvbData { + uint16_t transportId; + uint16_t serviceId; + uint16_t orgNetworkId; +}; + +#define HDMI_CEC_CHANNEL_IDENTIFIER_LEN 4 +struct HdmiCecChannelIdentifier { + uint8_t format; + uint16_t major; + uint16_t minor; +}; + +#define HDMI_CEC_DIGITAL_SERVICE_ID_METHOD_SHIFT 7 + +struct HdmiCecDigitalServiceId { + uint8_t method; + uint8_t system; + union { + struct HdmiCecDigitalServiceAribData arib; + struct HdmiCecDigitalServiceAtscData atsc; + struct HdmiCecDigitalServiceDvbData dvb; + struct HdmiCecChannelIdentifier channel; + } systemData; +}; + +/* + * Record Source. + * {[Record Source Type]} | {[Record Source Type] [Digital Service Identification]} | + * {[Record Source Type] [Analogue Broadcast Type] [Analogue Frequency] [Broadcast System]} | + * {[Record Source Type] [External Plug]} | {[Record Source Type] [External Physical Address]} + */ +#define HDMI_CEC_ANALOGUE_BROADCAST_TYPE_LEN 1 +#define HDMI_CEC_ANALOGUE_FREQ_LEN 2 +#define HDMI_CEC_BROADCAST_SYSTEM_LEN 1 +#define HDMI_CEC_EXT_PLUG_LEN 1 +#define HDMI_CEC_EXT_PHY_ADDRESS_LEN 2 +#define HDMI_CEC_RECORD_ON_OWN_MSG_PARAM_LEN HDMI_CEC_RECORD_SOURCE_TYPE_LEN +#define HDMI_CEC_RECORD_ON_DIGITAL_MSG_PARAM_LEN (HDMI_CEC_RECORD_SOURCE_TYPE_LEN + HDMI_CEC_DIGITAL_SERVICE_ID_LEN) +#define HDMI_CEC_RECORD_ON_ANALOG_MSG_PARAM_LEN (HDMI_CEC_RECORD_SOURCE_TYPE_LEN + \ + HDMI_CEC_ANALOGUE_BROADCAST_TYPE_LEN + HDMI_CEC_ANALOGUE_FREQ_LEN + HDMI_CEC_BROADCAST_SYSTEM_LEN) +#define HDMI_CEC_RECORD_ON_EXT_PLUG_MSG_PARAM_LEN (HDMI_CEC_RECORD_SOURCE_TYPE_LEN + HDMI_CEC_EXT_PLUG_LEN) +#define HDMI_CEC_RECORD_ON_EXT_PHY_ADDR_MSG_PARAM_LEN (HDMI_CEC_RECORD_SOURCE_TYPE_LEN + HDMI_CEC_EXT_PHY_ADDRESS_LEN) + +struct HdmiCecRecordSource { + uint8_t type; + union { + struct HdmiCecDigitalServiceId id; + struct { + uint8_t anaBcastType; + uint16_t anaFreq; + uint8_t bcstSystem; + } analog; + uint8_t extPlug; + uint16_t extPhyAddr; + } data; +}; + +/* + * One Touch Record Feature. + * Used by a Recording Device to inform the Initiator of the message about its status. + * Param: [Record Status Info], 1 byte. + */ +#define HDMI_CEC_OPCODE_RECORD_STATUS 0x0A + +#define HDMI_CEC_RECORD_STATUS_MSG_PARAM_LEN 1 + +/* Record Status Info */ +enum HdmiCecRecordStatusInfo { + HDMI_CEC_RECORD_STATUS_CUR_SRC = 0x01, + HDMI_CEC_RECORD_STATUS_DIG_SERVICE = 0x02, + HDMI_CEC_RECORD_STATUS_ANA_SERVICE = 0x03, + HDMI_CEC_RECORD_STATUS_EXT_INPUT = 0x04, + HDMI_CEC_RECORD_STATUS_NO_DIG_SERVICE = 0x05, + HDMI_CEC_RECORD_STATUS_NO_ANA_SERVICE = 0x06, + HDMI_CEC_RECORD_STATUS_NO_SERVICE = 0x07, + HDMI_CEC_RECORD_STATUS_INVALID_EXT_PLUG = 0x09, + HDMI_CEC_RECORD_STATUS_INVALID_EXT_PHYS_ADDR = 0x0A, + HDMI_CEC_RECORD_STATUS_UNSUP_CA = 0x0B, + HDMI_CEC_RECORD_STATUS_NO_CA_ENTITLEMENTS = 0x0C, + HDMI_CEC_RECORD_STATUS_NO_COPY_SRC = 0x0D, + HDMI_CEC_RECORD_STATUS_NO_MORE_COPIES = 0x0E, + HDMI_CEC_RECORD_STATUS_NO_MEDIA = 0x10, + HDMI_CEC_RECORD_STATUS_PLAYING = 0x11, + HDMI_CEC_RECORD_STATUS_ALREADY_RECORDING = 0x12, + HDMI_CEC_RECORD_STATUS_MEDIA_PROTECTED = 0x13, + HDMI_CEC_RECORD_STATUS_NO_SRC_SIGNAL = 0x14, + HDMI_CEC_RECORD_STATUS_MEDIA_PROBLEM = 0x15, + HDMI_CEC_RECORD_STATUS_NO_SPACE = 0x16, + HDMI_CEC_RECORD_STATUS_PARENTAL_LOCK = 0x17, + HDMI_CEC_RECORD_STATUS_TERMINATED_OK = 0x1A, + HDMI_CEC_RECORD_STATUS_ALREADY_TERMINATED = 0x1B, + HDMI_CEC_RECORD_STATUS_OTHER = 0x1F, +}; + +/* + * One Touch Record Feature. + * Request by The Recording Device to record the presently displayed source. + */ +#define HDMI_CEC_OPCODE_RECORD_TV_SCREEN 0x0F + +/* + * Timer Programming Feature. + * Used to clear an Analogue timer block of a device. + * Param: see param. + */ +#define HDMI_CEC_OPCODE_CLEAR_ANALOGUE_TIMER 0x33 + +/* + * Timer Programming Feature. + * Used to clear a Digital timer block of a device. + * Param: see param. + */ +#define HDMI_CEC_OPCODE_CLEAR_DIGITAL_TIMER 0x99 + +/* + * Timer Programming Feature. + * Used to clear a External timer block of a device. + * Param: see param. + */ +#define HDMI_CEC_OPCODE_CLEAR_EXTERNAL_TIMER 0xA1 + +/* + * Timer Programming Feature. + * Used to set a single timer block on an Analogue Recording device. + * Param: [Day of Month], 1 byte; [Month of Year], 1 byte; [Start Time], 2 byte; [Duration], 2 byte; + * [Recording Sequence], 1 byte; [Analogue Broadcast Type], 1 byte; [Analogue Frequency], 2 byte; + * [Broadcast System], 1 byte. + */ +#define HDMI_CEC_OPCODE_SET_ANALOGUE_TIMER 0x34 + +/* Analogue Broadcast Type, 1 byte. */ +enum HdmiCecAnalogueBroadcastType { + HDMI_CEC_ANALOGUE_BROADCAST_CABLE = 0, + HDMI_CEC_ANALOGUE_BROADCAST_SATELITE = 1, + HDMI_CEC_ANALOGUE_BROADCAST_TERRESTRIAL = 2, +}; + +/* Recording Sequence, 8 bits. */ +enum HdmiCecRecordingSequence { + HDMI_CEC_RECORDING_SEQ_ONCE_ONLY = 0x00, + HDMI_CEC_RECORDING_SEQ_SUNDAY = 0x01, + HDMI_CEC_RECORDING_SEQ_MONDAY = 0x02, + HDMI_CEC_RECORDING_SEQ_TUESDAY = 0x04, + HDMI_CEC_RECORDING_SEQ_WEDNESDAY = 0x08, + HDMI_CEC_RECORDING_SEQ_THURSDAY = 0x10, + HDMI_CEC_RECORDING_SEQ_FRIDAY = 0x20, + HDMI_CEC_RECORDING_SEQ_SATERDAY = 0x40, +}; + +#define HDMI_CEC_ANALOGUE_TIMER_INFO_LEN 11 +/* Hour and Minute are in BCD format. */ +#define HDMI_CEC_BCD_FORMAT_TIME(time) (((time / 10) << 4) | (time % 10)) + +#define HDMI_CEC_COMM_TIMER_INFO_LEN 7 +struct HdmiCecCommTimerInfo { + uint8_t data; + uint8_t month; + uint8_t startHour; + uint8_t startMinute; + uint8_t durationHour; + uint8_t durationMinute; + uint8_t recordingSeq; +}; + +struct HdmiCecAnalogueTimerInfo { + struct HdmiCecCommTimerInfo commInfo; + uint8_t anaBcastType; + uint16_t anaFreq; + uint8_t bcstSystem; +}; + +/* + * Timer Programming Feature. + * Used to set a single timer block on a Digital Recording device. + * Param: [Day of Month], 1 byte; [Month of Year], 1 byte; [Start Time], 2 byte; [Duration], 2 byte; + * [Recording Sequence], 1 byte; [Digtial Service Identification], 7 byte. + */ +#define HDMI_CEC_OPCODE_SET_DIGITAL_TIMER 0x97 + +#define HDMI_CEC_DIGITAL_TIMER_INFO_LEN 14 +struct HdmiCecDigitalTimerInfo { + struct HdmiCecCommTimerInfo commInfo; + struct HdmiCecDigitalServiceId id; +}; + +/* + * Timer Programming Feature. + * Used to set a single timer block to record from an External device. + * Param: [Day of Month], 1 byte; [Month of Year], 1 byte; [Start Time], 2 byte; [Duration], 2 byte; + * [Recording Sequence], 1 byte; [External Source Specifier], 1 byte; [External Plug], 1 byte; + * [External Physical address], 2 byte. + */ +#define HDMI_CEC_OPCODE_SET_EXTERNAL_TIMER 0xA2 + +#define HDMI_CEC_EXTERNAL_TIMER_INFO_LEN 11 + +/* External Source Specifier */ +#define HDMI_CEC_EXT_PLUG 4 +#define HDMI_CEC_EXT_PHYS_ADDR 5 + +struct HdmiCecExternalTimerInfo { + struct HdmiCecCommTimerInfo commInfo; + uint8_t extSrcSpec; + uint8_t extPlug; + uint16_t extPhyAddr; +}; + +/* + * Timer Programming Feature. + * Used to set the name of a program associate with a timer block. + * Sent directly after sending a or message. + * The name is then associated with that timer block. + * Param: [Program Title String], 1~14 bytes. + */ +#define HDMI_CEC_OPCODE_SET_TIMER_PROGRAM_TITLE 0x67 + +#define HDMI_CEC_PROGRAM_TITLE_STR_MIN_LEN 1 +#define HDMI_CEC_PROGRAM_TITLE_STR_MAX_LEN 14 + +/* + * Timer Programming Feature. + * Used to give the status of a , + * or message. + * Param: [Timer Cleared Status Data], 1 byte. + */ +#define HDMI_CEC_OPCODE_TIMER_CLEARED_STATUS 0x43 + +#define HDMI_CEC_TIMER_CLEARED_STATUS_MSG_PARAM_LEN 1 + +/* Timer Cleared Status Data */ +enum HdmiCecTimerClearedStatus { + HDMI_CEC_TIMER_CLR_STAT_NO_CLEARED_RECORDING = 0x00, + HDMI_CEC_TIMER_CLR_STAT_NO_CLEARED_NO_MATCHING = 0x01, + HDMI_CEC_TIMER_CLR_STAT_NO_CLEARED_NO_INFO = 0x02, + HDMI_CEC_TIMER_CLR_STAT_CLEARED = 0x80, +}; + +/* + * Timer Programming Feature. + * Used to send timer status to the Initiator of a message. + * Param: [Timer Status Data], 1 byte or 3 bytes. + */ +#define HDMI_CEC_OPCODE_TIMER_STATUS 0x35 + +#define HDMI_CEC_TIMER_STATUS_DATA_MIN_LEN 1 +#define HDMI_CEC_TIMER_STATUS_DATA_MAX_LEN 3 + +/* + * Timer Status Data. 1 byte or 3 bytes. + * [Timer overlap warning] 1bit. + * [Media Info] 2 bits. + * [Timer Progremmed Info] 5 bits or 21 bits. + */ +#define HDMI_CEC_TIMER_OVERLAP_WARNING_NO_OVERLAP 0 +#define HDMI_CEC_TIMER_OVERLAP_WARNING_TIMER_BLOCK_OVERLAP 1 + +enum HdmiCecMediaInfo { + HDMI_CEC_MEDIA_PRESENT_NOT_POTECTED = 0, + HDMI_CEC_MEDIA_PRESENT_POTECTED = 1, + HDMI_CEC_MEDIA_NOT_PRESENT = 2, + HDMI_CEC_MEDIA_BUTT, +}; + +/* + * Timer Progremmed Info, 5 bits or 21 bits. + * [Progremmed Indicator], 1 bit. + * {[Progremmed Info], 4 bits. [Duration Available], 2bytes.} | + * {[Not Progremmed Error Info], 4 bits. [Duration Available], 2bytes.} + */ +/* Progremmed Indicator, 1 bit */ +#define HDMI_CEC_PROG_IND_NOT_PROGRAMMED 0 +#define HDMI_CEC_PROG_IND_PROGRAMMED 1 + +/* Progremmed Info, 4 bits */ +enum HdmiCecProgremmedInfo { + HDMI_CEC_PROGRAMMED_INFO_ENOUGH_SPAC = 0x08, + HDMI_CEC_PROGRAMMED_INFO_NOT_ENOUGH_SPAC = 0x09, + HDMI_CEC_PROGRAMMED_INFO_NO_MEDIA_INFO = 0x0A, + HDMI_CEC_PROGRAMMED_INFO_MIGHT_NOT_BE_ENOUGH_SPACE = 0x0B, +}; + +/* Not Progremmed Error Info */ +enum HdmiCecNotProgremmedErrorInfo { + HDMI_CEC_NOT_PROG_ERR_NO_FREE_TIMER = 0x01, + HDMI_CEC_NOT_PROG_ERR_DATE_OUT_OF_RANGE = 0x02, + HDMI_CEC_NOT_PROG_ERR_RECORDING_SEQ_ERROR = 0x03, + HDMI_CEC_NOT_PROG_ERR_INVALID_EXT_PLUG = 0x04, + HDMI_CEC_NOT_PROG_ERR_INVALID_EXT_PHYS_ADDR = 0x05, + HDMI_CEC_NOT_PROG_ERR_CA_UNSUPP = 0x06, + HDMI_CEC_NOT_PROG_ERR_INSUF_CA_ENTITLEMENTS = 0x07, + HDMI_CEC_NOT_PROG_ERR_RESOLUTION_UNSUPP = 0x08, + HDMI_CEC_NOT_PROG_ERR_PARENTAL_LOCK = 0x09, + HDMI_CEC_NOT_PROG_ERR_CLOCK_FAILURE = 0x0A, + HDMI_CEC_NOT_PROG_ERR_DUPLICATE = 0x0E, +}; + +struct HdmiCecTimerProgremmedInfo { + uint8_t indicator; + uint8_t info; /* Progremmed Info/Not Progremmed Error Info */ + uint8_t durationHour; + uint8_t durationMinute; +}; + +struct HdmiCecTimerStatusData { + uint8_t timerOverlap; + uint8_t mediaInfo; + struct HdmiCecTimerProgremmedInfo progInfo; +}; + +/* + * System Information Feature/Vendor Specific Commands Feature. + * Used to indicate the version number of the CEC Specification which was used to design the device, + * in response to a . + * Param: [CEC Version], 1 byte. + */ +#define HDMI_CEC_OPCODE_CEC_VERSION 0x9E + +#define HDMI_CEC_CEC_VERSION_MSG_PARAM_LEN 1 + +/* CEC Version */ +#define HDMI_CEC_VERSION_1_3A 4 +#define HDMI_CEC_VERSION_1_4 5 +#define HDMI_CEC_VERSION_2_0 6 + +/* + * System Information Feature/Vendor Specific Commands Feature. + * Used by a device to enquire which version number of the CEC Specification + * was used to design the Follwer device. + * Param: None. + */ +#define HDMI_CEC_OPCODE_GET_CEC_VERSION 0x9F + +/* + * System Information Feature. + * A request to a device return its Physical Address. + * Param: None. + */ +#define HDMI_CEC_OPCODE_GIVE_PHYSICAL_ADDRESS 0x83 + +/* + * System Information Feature. + * Sent by a device capable of character generation(for OSD and Menus) to a TV in order to + * discover the currently selected Menu language on the TV. + * Param: None. + */ +#define HDMI_CEC_OPCODE_GET_MENU_LANGUAGE 0x91 + +/* + * System Information Feature. + * Used to inform all other devices of the mapping between + * physical and Logical address of the Initiator. + * Param: [Physical Address], 2 bytes. [Device Type], 1 byte. + * Broadcast message. + */ +#define HDMI_CEC_OPCODE_REPORT_PHYSICAL_ADDRESS 0x84 + +#define HDMI_CEC_REPORT_PHYSICAL_ADDRESS_MSG_PARAM_LEN 3 + +/* + * Device Type/Primary Device Type. + * The HDMI 1.4b operand [Device Type] has been extended as [Primary Device Type]. + */ +enum HdmiCecDeviceType { + HDMI_CEC_DEVICE_TYPE_TV = 0, + HDMI_CEC_DEVICE_TYPE_RECORDING_DEVICE = 1, + HDMI_CEC_DEVICE_TYPE_RESERVED = 2, + HDMI_CEC_DEVICE_TYPE_TUNER = 3, + HDMI_CEC_DEVICE_TYPE_PLAYBACK_DEVICE = 4, + HDMI_CEC_DEVICE_TYPE_AUDIO_SYSTEM = 5, + HDMI_CEC_DEVICE_TYPE_PURE_CEC_SWITCH = 6, + HDMI_CEC_DEVICE_TYPE_PROCESSOR = 7, +}; + +/* + * System Information Feature. + * Used by a TV to indicate its currently selected menu language. + * Param: [Language], 3 bytes. + * Broadcast message. + */ +#define HDMI_CEC_OPCODE_SET_MENU_LANGUAGE 0x32 + +#define HDMI_CEC_SET_MENU_LANGUAGE_MSG_PARAM_LEN 3 + +/* + * System Information Feature. + * Used by a device to announce its version, features and device type. + * Param: [CEC Version], 1 byte. [All Device Types], 1 byte. [RC Profile], 1..N bytes. [Device Features], 1..N bytes. + */ +#define HDMI_CEC_OPCODE_REPORT_FEATURES 0xA6 + +#define HDMI_CEC_REPORT_FEATURES_MSG_PARAM_MIN_LEN 4 + +/* All Device Types */ +enum HdmiCecAllDevType { + HDMI_CEC_ALL_DEV_TYPE_CEC_SWITCH = 0x04, + HDMI_CEC_ALL_DEV_TYPE_AUDIO_SYSTEM = 0x08, + HDMI_CEC_ALL_DEV_TYPE_PLAYBACK = 0x10, + HDMI_CEC_ALL_DEV_TYPE_TUNER = 0x20, + HDMI_CEC_ALL_DEV_TYPE_RECORD = 0x40, + HDMI_CEC_ALL_DEV_TYPE_TV = 0x80, +}; + +/* + * RC Profile, 1..N bytes. + * [RC Profile 1]; or [RC Profile 1]..[RC Profile N](where N >= 2) + * RC Profile 1, 1 byte. + * [RC Profile Externsion], bit 7 + * if bit6 is 0, [RC Profile TV] in bit5-0; if bit6 is 1, [RC Profile Source] in bit5-0. + */ +#define HDMI_CEC_RC_PROFILE_MAX_NUM 6 +#define HDMI_CEC_RC_PROFILE_EXTERNSION_MARK (1 << 7) +#define HDMI_CEC_RC_PROFILE_TV_OR_SOURCE_MARK (1 << 6) + +/* RC Profile Source, 6 bits. */ +#define HDMI_CEC_RC_PROFILE_SOURCE_ROOT_MENU (1 << 4) +#define HDMI_CEC_RC_PROFILE_SOURCE_SETUP_MENU (1 << 3) +#define HDMI_CEC_RC_PROFILE_SOURCE_CONTENTS_MENU (1 << 2) +#define HDMI_CEC_RC_PROFILE_SOURCE_MEDIA_TOP_MENU (1 << 1) +#define HDMI_CEC_RC_PROFILE_SOURCE_MEDIA_CONTEXT_SENSITIVE_MENU (1 << 0) + +/* + * RC Profile TV, 6 bits. + * [RC Profile ID], Bit3-0. + */ +enum HdmiCecRcProfileId { + HDMI_CEC_RC_PROFILE_NONE = 0x00, + HDMI_CEC_RC_PROFILE_1 = 0x02, + HDMI_CEC_RC_PROFILE_2 = 0x06, + HDMI_CEC_RC_PROFILE_3 = 0x0A, + HDMI_CEC_RC_PROFILE_4 = 0x0E, + HDMI_CEC_RC_PROFILE_BUTT, +}; + +/* + * Device Features, 1..N bytes. + * [Device Features 1], 1 byte. + */ +#define HDMI_CEC_DEVICE_FEATURES_MAX_NUM 6 +#define HDMI_CEC_DEVICE_FEATURES_EXTERNSION_MARK (1 << 7) /* 0 the last; 1 continues. */ +#define HDMI_CEC_DEVICE_FEATURES_TV_SUPP_RECORD_TV_SCREEN (1 << 6) +#define HDMI_CEC_DEVICE_FEATURES_TV_SUPP_SET_OSD_STRING (1 << 5) +#define HDMI_CEC_DEVICE_FEATURES_DECK_SUPP_CONTROL (1 << 4) +#define HDMI_CEC_DEVICE_FEATURES_SRC_SUPP_SET_AUDIO_RATE (1 << 3) +#define HDMI_CEC_DEVICE_FEATURES_SINK_SUPP_ARC_TX (1 << 2) +#define HDMI_CEC_DEVICE_FEATURES_SRC_SUPP_ARC_RX (1 << 1) + +/* + * System Information Feature. + * Used by a device to request another device's features. + * Param: None. + */ +#define HDMI_CEC_OPCODE_GIVE_FEATURES 0xA5 + +/* + * Deck Control Feature. + * Used to control a device's media functions. + * Param: [Deck Control Mode], 1 byte. + */ +#define HDMI_CEC_OPCODE_DECK_CONTROL 0x42 + +#define HDMI_CEC_DECK_CONTROL_MSG_PARAM_LEN 1 + +/* Deck Control Mode */ +enum HdmiCecDeckControlMode { + HDMI_CEC_DECK_CONTROL_MODE_SKIP_FWD = 1, + HDMI_CEC_DECK_CONTROL_MODE_SKIP_REV = 2, + HDMI_CEC_DECK_CONTROL_MODE_STOP = 3, + HDMI_CEC_DECK_CONTROL_MODE_EJECT = 4, +}; + +/* + * Deck Control Feature. + * Used to provide a deck's status to the indicate of the message. + * Param: [Deck Info], 1 byte. + */ +#define HDMI_CEC_OPCODE_DECK_STATUS 0x1B + +#define HDMI_CEC_DECK_STATUS_MSG_PARAM_LEN 1 + +/* Deck Info. Indicate the current status of a tape or disk deck. */ +enum HdmiCecDeckInfo { + HDMI_CEC_DECK_PLAY = 0x11, + HDMI_CEC_DECK_RECORD = 0x12, + HDMI_CEC_DECK_PLAY_REVERSE = 0x13, + HDMI_CEC_DECK_STILL = 0x14, + HDMI_CEC_DECK_SLOW = 0x15, + HDMI_CEC_DECK_SLOW_REVERSE = 0x16, + HDMI_CEC_DECK_FAST_FORWARD = 0x17, + HDMI_CEC_DECK_FAST_REVERSE = 0x18, + HDMI_CEC_DECK_NO_MEDIA = 0x19, + HDMI_CEC_DECK_STOP = 0x1A, + HDMI_CEC_DECK_SKIP_FORWARD = 0x1B, + HDMI_CEC_DECK_SKIP_REVERSE = 0x1C, + HDMI_CEC_DECK_INDEX_SEARCH_FORWARD = 0x1D, + HDMI_CEC_DECK_INDEX_SEARCH_REVERSE = 0x1E, + HDMI_CEC_DECK_OTHER_STATUS = 0x1F, +}; + +/* + * Deck Control Feature. + * Used to request the status of a device, + * regardless of whether or not it is the current active source. + * Param: [Status Request], 1 byte. + */ +#define HDMI_CEC_OPCODE_GIVE_DECK_STATUS 0x1A + +#define HDMI_CEC_GIVE_DECK_STATUS_MSG_PARAM_LEN 1 + +/* Status Request */ +enum HdmiCecStatusRequest { + HDMI_CEC_STATUS_REQUEST_ON = 1, + HDMI_CEC_STATUS_REQUEST_OFF = 2, + HDMI_CEC_STATUS_REQUEST_ONCE = 3, +}; + +/* + * Deck Control Feature. + * Used to control the playback bahavior of a source device. + * Param: [Play Mode], 1 byte. + */ +#define HDMI_CEC_OPCODE_PLAY 0x41 + +#define HDMI_CEC_PLAY_MSG_PARAM_LEN 1 + +/* Play Mode */ +enum HdmiCecPlayMode { + HDMI_CEC_PLAY_MODE_PLAY_FAST_FWD_MIN = 0x05, + HDMI_CEC_PLAY_MODE_PLAY_FAST_FWD_MED = 0x06, + HDMI_CEC_PLAY_MODE_PLAY_FAST_FWD_MAX = 0x07, + HDMI_CEC_PLAY_MODE_PLAY_FAST_REV_MIN = 0x09, + HDMI_CEC_PLAY_MODE_PLAY_FAST_REV_MED = 0x0A, + HDMI_CEC_PLAY_MODE_PLAY_FAST_REV_MAX = 0x0B, + HDMI_CEC_PLAY_MODE_PLAY_SLOW_FWD_MIN = 0x15, + HDMI_CEC_PLAY_MODE_PLAY_SLOW_FWD_MED = 0x16, + HDMI_CEC_PLAY_MODE_PLAY_SLOW_FWD_MAX = 0x17, + HDMI_CEC_PLAY_MODE_PLAY_SLOW_REV_MIN = 0x19, + HDMI_CEC_PLAY_MODE_PLAY_SLOW_REV_MED = 0x1A, + HDMI_CEC_PLAY_MODE_PLAY_SLOW_REV_MAX = 0x1B, + HDMI_CEC_PLAY_MODE_PLAY_REV = 0x20, + HDMI_CEC_PLAY_MODE_PLAY_FWD = 0x24, + HDMI_CEC_PLAY_MODE_PLAY_STILL = 0x25, +}; + +/* + * Tuner Control Feature. + * Used to request the status of a tuner device. + * Param: [Status Request], 1 byte. + */ +#define HDMI_CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS 0x08 + +#define HDMI_CEC_GIVE_TUNER_DEVICE_STATU_MSG_PARAM_LEN 1 + +/* + * Tuner Control Feature. + * Directly selects a Digital TV, Radio or Data Briadcast service. + * Param: [Digital Service Identification], 7 bytes. + */ +#define HDMI_CEC_OPCODE_SELECT_DIGITAL_SERVICE 0x93 + +#define HDMI_CEC_SELECT_DIGITAL_SERVICE_MSG_PARAM_LEN HDMI_CEC_DIGITAL_SERVICE_ID_LEN + +/* + * Tuner Control Feature. + * Used by a tuner device to provide its status to the initiator of + * the message. + * Param: [Tuner Device Info], 5 bytes(analogue service), 8 bytes(digital service). + */ +#define HDMI_CEC_OPCODE_TUNER_DEVICE_STATUS 0x07 + +#define HDMI_CEC_TUNER_DEVICE_STATUS_MSG_ANA_PARAM_LEN 5 +#define HDMI_CEC_TUNER_DEVICE_STATUS_MSG_DIG_PARAM_LEN 8 + +/* + * Tuner Device Info, 5 bytes(analogue service), 8 bytes(digital service). + * [Recording Flag], 1 bit. [Tuner Display Info], 7 bits. + * {[Analogue Broadcast Type], 1 byte. [Analogue Frequency], 2 bytes. [Broadcast System], 1 byte.} | + * {[Digital Service Identification], 7 bytes}. + */ +#define HDMI_CEC_RECORDING_FALG_NOT_USED 0 +#define HDMI_CEC_RECORDING_FALG_USED 1 + +enum HdmiCecTunerDisplayInfo { + HDMI_CEC_TUNER_DISP_DIGITAL = 0, + HDMI_CEC_TUNER_DISP_NOT_DISP = 1, + HDMI_CEC_TUNER_DISP_ANALOGUE = 2, +}; + +struct HdmiCecTunerDeviceInfo { + uint8_t recordingFlag; + uint8_t dispInfo; + bool isAnalogService; + union { + struct HdmiCecDigitalServiceId digital; + struct { + uint8_t anaBcastType; + uint16_t anaFreq; + uint8_t bcstSystem; + } analog; + } data; +}; + +/* + * Tuner Control Feature. + * Used to tune to next lowest service in a tuner's service list. Can used for PIP. + * Param: None. + */ +#define HDMI_CEC_OPCODE_TUNER_STEP_DECREMENT 0x06 + +/* + * Tuner Control Feature. + * Used to tune to next highest service in a tuner's service list. Can used for PIP. + * Param: None. + */ +#define HDMI_CEC_OPCODE_TUNER_STEP_INCREMENT 0x05 + +/* + * Vendor Specific Commands Feature. + * Reports the vendor ID of this device. + * Param: [Vendor ID], 3 bytes. + * Broadcast message. + */ +#define HDMI_CEC_OPCODE_DEVICE_VENDOR_ID 0x87 + +#define HDMI_CEC_DEVICE_VENDOR_ID_MSG_PARAM_LEN 3 + +/* + * Indicates the vendor ID should be disabled. + */ +#define HDMI_CEC_VENDOR_ID_UNKNOWN 0xFFFFFFFF + +/* + * Vendor Specific Commands Feature. + * Requests the Vendor ID from a device. + * Param: None. + */ +#define HDMI_CEC_OPCODE_GIVE_DEVICE_VENDOR_ID 0x8C + +/* + * Vendor Specific Commands Feature. + * Allows vendor specific commands to be sent between two devices. + * Param: [Vendor Specific Data], <= 14 bytes. + */ +#define HDMI_CEC_OPCODE_VENDOR_COMMAND 0x89 + +#define HDMI_CEC_VENDOR_SPECIFIC_DATA_MAX_LEN 14 + +/* + * Vendor Specific Commands Feature. + * Allows vendor specific commands to be sent between two devices or broadcast. + * Param: [Vendor ID], 3 bytes. [Vendor Specific Data], <= 11 bytes. + * Broadcast/Directly addressed message. + */ +#define HDMI_CEC_OPCODE_VENDOR_COMMAND_WITH_ID 0xA0 + +#define HDMI_CEC_VENDOR_ID_LEN 3 +#define HDMI_CEC_VENDOR_SPECIFIC_DATA_WITH_ID_MAX_LEN 11 + +/* + * Vendor Specific Commands Feature. + * Indicates that a remote control button has been depressed. + * Param: [Vendor Specific RC Code], <= 14 bytes. + * Broadcast/Directly addressed message. + */ +#define HDMI_CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN 0x8A + +#define HDMI_CEC_VENDOR_SPECIFIC_RC_CODE_MAX_LEN 14 + +/* + * Vendor Specific Commands Feature. + * Indicates that a remote control button(the last button pressed indicated + * by the Vendor Remote Button Down message) has been released. + * Param: None. + * Broadcast/Directly addressed message. + */ +#define HDMI_CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP 0x8B + +/* + * OSD Display Feature. + * Used to send a text massage to output on a TV. + * OSD(on-screen display). + * Param: [Display Control], 1 byte. [OSD String], 1-13 bits. + */ +#define HDMI_CEC_OPCODE_SET_OSD_STRING 0x64 + +#define HDMI_CEC_DISPLAY_CONTROL_LEN 1 +#define HDMI_CEC_OSD_STRING_MAX_LEN 13 + +/* Display Control */ +enum HdmiCecDisplayControl { + HDMI_CEC_DISPLAY_FOR_DEFAULT_TIME = 0x00, + HDMI_CEC_DISPLAY_UNTIL_CLEARED = 0x40, + HDMI_CEC_DISPLAY_CLEAR_PREVIOUS_MESSAGE = 0x80, + HDMI_CEC_DISPLAY_BUTT, +}; + +/* + * OSD Display Feature. + * Used to request the preferred OSD name of a device for use in menus associated with that device. + * Param: None. + */ +#define HDMI_CEC_OPCODE_GIVE_OSD_NAME 0x46 + +/* + * OSD Display Feature. + * Used to set the preferred OSD name of a device for use in menus associated with that device. + * Param: [OSD Name], 1-14 bytes. + */ +#define HDMI_CEC_OPCODE_SET_OSD_NAME 0x47 + +#define HDMI_CEC_OSD_NAME_MAX_LEN 14 + +/* + * Device Menu Control Feature. + * A request from the TV for a device to show/remove a menu or to + * query if a device is currently showing a menu. + * Param: [Menu Request Type], 1 byte. + */ +#define HDMI_CEC_OPCODE_MENU_REQUEST 0x8D + +#define HDMI_CEC_MENU_REQUEST_MSG_PARAM_LEN 1 + +/* Menu Request Type */ +enum HdmiCecMenuRequestType { + HDMI_CEC_MENU_REQUEST_ACTIVE = 0, + HDMI_CEC_MENU_REQUEST_DEACTIVE = 1, + HDMI_CEC_MENU_REQUEST_QUERY = 2, +}; + +/* + * Device Menu Control Feature. + * Used to indicate to the TV that the device is showing/has removed a menu and + * requests the remote control keys to be passed throuh. + * Param: [Menu State], 1 byte. + */ +#define HDMI_CEC_OPCODE_MENU_STATUS 0x8E + +#define HDMI_CEC_MENU_STATUS_MSG_PARAM_LEN 1 + +/* Menu State */ +#define HDMI_CEC_MENU_STATE_ACTIVE 0 +#define HDMI_CEC_MENU_STATE_DEACTIVE 1 + +/* + * Device Menu Control Feature/Remote Contro Passthrough Feature/System Audio Control Feature. + * Used to indicate that the user pressed a remote control button or switched from + * one remote control button to another. Can also be used as a command that is not directly initiated by the user. + * Param: [UI Command], 1 byte. + * Note that some [UI Command] messages also have further operands. See CEC Table 6 and CEC Table 7. + */ +#define HDMI_CEC_OPCODE_USER_CONTROL_PRESSED 0x44 + +#define HDMI_CEC_UI_COMMAND_LEN 1 + +/* UI Command */ +enum HdmiCecUiCmdType { + HDMI_CEC_UI_CMD_SELECT = 0x00, + HDMI_CEC_UI_CMD_UP = 0x01, + HDMI_CEC_UI_CMD_DOWN = 0x02, + HDMI_CEC_UI_CMD_LEFT = 0x03, + HDMI_CEC_UI_CMD_RIGHT = 0x04, + HDMI_CEC_UI_CMD_RIGHT_UP = 0x05, + HDMI_CEC_UI_CMD_RIGHT_DOWN = 0x06, + HDMI_CEC_UI_CMD_LEFT_UP = 0x07, + HDMI_CEC_UI_CMD_LEFT_DOWN = 0x08, + HDMI_CEC_UI_CMD_DEVICE_ROOT_MENU = 0x09, + HDMI_CEC_UI_CMD_DEVICE_SETUP_MENU = 0x0a, + HDMI_CEC_UI_CMD_CONTENTS_MENU = 0x0b, + HDMI_CEC_UI_CMD_FAVORITE_MENU = 0x0c, + HDMI_CEC_UI_CMD_EXIT = 0x0d, + HDMI_CEC_UI_CMD_MEDIA_TOP_MENU = 0x10, + HDMI_CEC_UI_CMD_MEDIA_CONTEXT_SENSITIVE_MENU = 0x11, + HDMI_CEC_UI_CMD_NUMBER_ENTRY_MODE = 0x1d, + HDMI_CEC_UI_CMD_NUMBER_11 = 0x1e, + HDMI_CEC_UI_CMD_NUMBER_12 = 0x1f, + HDMI_CEC_UI_CMD_NUMBER_0_OR_NUMBER_10 = 0x20, + HDMI_CEC_UI_CMD_NUMBER_1 = 0x21, + HDMI_CEC_UI_CMD_NUMBER_2 = 0x22, + HDMI_CEC_UI_CMD_NUMBER_3 = 0x23, + HDMI_CEC_UI_CMD_NUMBER_4 = 0x24, + HDMI_CEC_UI_CMD_NUMBER_5 = 0x25, + HDMI_CEC_UI_CMD_NUMBER_6 = 0x26, + HDMI_CEC_UI_CMD_NUMBER_7 = 0x27, + HDMI_CEC_UI_CMD_NUMBER_8 = 0x28, + HDMI_CEC_UI_CMD_NUMBER_9 = 0x29, + HDMI_CEC_UI_CMD_DOT = 0x2a, + HDMI_CEC_UI_CMD_ENTER = 0x2b, + HDMI_CEC_UI_CMD_CLEAR = 0x2c, + HDMI_CEC_UI_CMD_NEXT_FAVORITE = 0x2f, + HDMI_CEC_UI_CMD_CHANNEL_UP = 0x30, + HDMI_CEC_UI_CMD_CHANNEL_DOWN = 0x31, + HDMI_CEC_UI_CMD_PREVIOUS_CHANNEL = 0x32, + HDMI_CEC_UI_CMD_SOUND_SELECT = 0x33, + HDMI_CEC_UI_CMD_INPUT_SELECT = 0x34, + HDMI_CEC_UI_CMD_DISPLAY_INFORMATION = 0x35, + HDMI_CEC_UI_CMD_HELP = 0x36, + HDMI_CEC_UI_CMD_PAGE_UP = 0x37, + HDMI_CEC_UI_CMD_PAGE_DOWN = 0x38, + HDMI_CEC_UI_CMD_POWER = 0x40, + HDMI_CEC_UI_CMD_VOLUME_UP = 0x41, + HDMI_CEC_UI_CMD_VOLUME_DOWN = 0x42, + HDMI_CEC_UI_CMD_MUTE = 0x43, + HDMI_CEC_UI_CMD_PLAY = 0x44, + HDMI_CEC_UI_CMD_STOP = 0x45, + HDMI_CEC_UI_CMD_PAUSE = 0x46, + HDMI_CEC_UI_CMD_RECORD = 0x47, + HDMI_CEC_UI_CMD_REWIND = 0x48, + HDMI_CEC_UI_CMD_FAST_FORWARD = 0x49, + HDMI_CEC_UI_CMD_EJECT = 0x4a, + HDMI_CEC_UI_CMD_SKIP_FORWARD = 0x4b, + HDMI_CEC_UI_CMD_SKIP_BACKWARD = 0x4c, + HDMI_CEC_UI_CMD_STOP_RECORD = 0x4d, + HDMI_CEC_UI_CMD_PAUSE_RECORD = 0x4e, + HDMI_CEC_UI_CMD_ANGLE = 0x50, + HDMI_CEC_UI_CMD_SUB_PICTURE = 0x51, + HDMI_CEC_UI_CMD_VIDEO_ON_DEMAND = 0x52, + HDMI_CEC_UI_CMD_ELECTRONIC_PROGRAM_GUIDE = 0x53, + HDMI_CEC_UI_CMD_TIMER_PROGRAMMING = 0x54, + HDMI_CEC_UI_CMD_INITIAL_CONFIGURATION = 0x55, + HDMI_CEC_UI_CMD_SELECT_BROADCAST_TYPE = 0x56, /* Additional Operands: [UI Broadcast Type] */ + HDMI_CEC_UI_CMD_SELECT_SOUND_PRESENTATION = 0x57, /* Additional Operands: [UI Sound Presentation Control] */ + HDMI_CEC_UI_CMD_AUDIO_DESCRIPTION = 0x58, + HDMI_CEC_UI_CMD_INTERNET = 0x59, + HDMI_CEC_UI_CMD_3D_MODE = 0x5a, + HDMI_CEC_UI_CMD_PLAY_FUNCTION = 0x60, /* Additional Operands: [Play Mode] */ + HDMI_CEC_UI_CMD_PAUSE_PLAY_FUNCTION = 0x61, + HDMI_CEC_UI_CMD_RECORD_FUNCTION = 0x62, + HDMI_CEC_UI_CMD_PAUSE_RECORD_FUNCTION = 0x63, + HDMI_CEC_UI_CMD_STOP_FUNCTION = 0x64, + HDMI_CEC_UI_CMD_MUTE_FUNCTION = 0x65, + HDMI_CEC_UI_CMD_RESTORE_VOLUME_FUNCTION = 0x66, + HDMI_CEC_UI_CMD_TUNE_FUNCTION = 0x67, /* Additional Operands: [Channel Identifier] */ + HDMI_CEC_UI_CMD_SELECT_MEDIA_FUNCTION = 0x68, /* Additional Operands: [UI Function Media] */ + HDMI_CEC_UI_CMD_SELECT_AV_INPUT_FUNCTION = 0x69, /* Additional Operands: [UI Function Select A/V Input] */ + HDMI_CEC_UI_CMD_SELECT_AUDIO_INPUT_FUNCTION = 0x6a, /* Additional Operands: [UI Function Select Audio Input] */ + HDMI_CEC_UI_CMD_POWER_TOGGLE_FUNCTION = 0x6b, + HDMI_CEC_UI_CMD_POWER_OFF_FUNCTION = 0x6c, + HDMI_CEC_UI_CMD_POWER_ON_FUNCTION = 0x6d, + HDMI_CEC_UI_CMD_F1_BLUE = 0x71, + HDMI_CEC_UI_CMD_F2_RED = 0x72, + HDMI_CEC_UI_CMD_F3_GREEN = 0x73, + HDMI_CEC_UI_CMD_F4_YELLOW = 0x74, + HDMI_CEC_UI_CMD_F5 = 0x75, + HDMI_CEC_UI_CMD_DATA = 0x76, +}; + +enum HdmiCecUiBroadcastType { + HDMI_CEC_UI_BROADCAST_TYPE_TOGGLE_ALL = 0x00, + HDMI_CEC_UI_BROADCAST_TYPE_TOGGLE_DIG_ANA = 0x01, + HDMI_CEC_UI_BROADCAST_TYPE_ANA = 0x10, + HDMI_CEC_UI_BROADCAST_TYPE_ANA_TERRESTRIAL = 0x20, + HDMI_CEC_UI_BROADCAST_TYPE_ANA_CABLE = 0x30, + HDMI_CEC_UI_BROADCAST_TYPE_ANA_SATELLITE = 0x40, + HDMI_CEC_UI_BROADCAST_TYPE_DIG = 0x50, + HDMI_CEC_UI_BROADCAST_TYPE_DIG_TERRESTRIAL = 0x60, + HDMI_CEC_UI_BROADCAST_TYPE_DIG_CABLE = 0x70, + HDMI_CEC_UI_BROADCAST_TYPE_DIG_SATELLITE = 0x80, + HDMI_CEC_UI_BROADCAST_TYPE_DIG_COM_SATELLITE = 0x90, + HDMI_CEC_UI_BROADCAST_TYPE_DIG_COM_SATELLITE2 = 0x91, + HDMI_CEC_UI_BROADCAST_TYPE_IP = 0xA0, +}; + +/* UI Sound Presentation Control */ +enum HdmiCecUiSoundPresCtl { + HDMI_CEC_UI_SOUND_PRES_CTL_DUAL_MONO = 0x20, + HDMI_CEC_UI_SOUND_PRES_CTL_KARAOKE = 0x30, + HDMI_CEC_UI_SOUND_PRES_CTL_DOWNMIX = 0x80, + HDMI_CEC_UI_SOUND_PRES_CTL_REVERB_PROCESS = 0x90, + HDMI_CEC_UI_SOUND_PRES_CTL_EQUALIZER = 0xA0, + HDMI_CEC_UI_SOUND_PRES_CTL_BASS_STEP_UP = 0xB1, + HDMI_CEC_UI_SOUND_PRES_CTL_BASS_NEUTRAL = 0xB2, + HDMI_CEC_UI_SOUND_PRES_CTL_BASS_STEP_DOWN = 0xB3, + HDMI_CEC_UI_SOUND_PRES_CTL_TREBLE_STEP_UP = 0xC1, + HDMI_CEC_UI_SOUND_PRES_CTL_TREBLE_NEUTRAL = 0xC2, + HDMI_CEC_UI_SOUND_PRES_CTL_TREBLE_STEP_DOWN = 0xC3, +}; + +struct HdmiCecUiCmd { + uint8_t cmdType; + bool hasAddOp; + union { + uint8_t uiBroadcastType; + uint8_t uiSoundPresCtl; + uint8_t playMode; + uint8_t uiFunctionMedia; + uint8_t uiFunctionSelectAvInput; + uint8_t uiFunctionSelectAudioInput; + struct HdmiCecChannelIdentifier channel; + } addOperands; +}; + +/* + * Device Menu Control Feature/Remote Contro Passthrough Feature/System Audio Control Feature. + * Indicates that user released a remote control button(the last one indicated by the + * message). Also used after a command that is not directly initiated by the user. + * Param: None. + */ +#define HDMI_CEC_OPCODE_USER_CONTROL_RELEASED 0x45 + +/* + * Remote Contro Passthrough Feature. + * Used to determine the current power status of a target device. + * Param: None. + */ +#define HDMI_CEC_OPCODE_GIVE_DEVICE_POWER_STATUS 0x8F + +/* + * Remote Contro Passthrough Feature. + * Used to inform a requesting device of the current power status. + * Param: [Power Status], 1 byte. + * Broadcast(Hdmi Spec2.0)/Directly addressed message. + */ +#define HDMI_CEC_OPCODE_REPORT_POWER_STATUS 0x90 + +#define HDMI_CEC_REPORT_POWER_STATUS_MSG_PARA_LEN 1 + +/* Power Status */ +enum HdmiCecPowerStatus { + HDMI_CEC_POWER_STATUS_ON = 0x00, + HDMI_CEC_POWER_STATUS_STANDBY = 0x01, + HDMI_CEC_POWER_STATUS_IN_TRANSITION_STANDBY_TO_ON = 0x02, + HDMI_CEC_POWER_STATUS_IN_TRANSITION_ON_TO_STANDBY = 0x03, +}; + +/* + * General Protocol Messages. + * Used as a response to indicate that the device does not support the requested message type, + * or that is cannot execute it at the present time. + * Param: [Feature Opcode], 1 byte. [Abort Reason], 1 byte. + */ +#define HDMI_CEC_OPCODE_FEATURE_ABORT 0x00 + +#define HDMI_CEC_FEATURE_ABORT_MSG_PARA_LEN 2 + +/* Abort Reason */ +enum HdmiCecAbortReason { + HDMI_CEC_ABORT_UNRECOGNIZED_OPCODE = 0, + HDMI_CEC_ABORT_NOT_IN_CORRECT_MODE_TO_RESPOND = 1, + HDMI_CEC_ABORT_CANNOT_PROVIDE_SOURCE = 2, + HDMI_CEC_ABORT_INVALID_OPERAND = 3, + HDMI_CEC_ABORT_REFUSED = 4, + HDMI_CEC_ABORT_UNABLE_TO_DETERMINE = 5, +}; + +/* + * General Protocol Messages. + * This message is reversed for testing purposes. + * Param: None. + */ +#define HDMI_CEC_OPCODE_ABORT 0xFF + +/* + * System Audio Control Feature. + * Requests an Amplifier to send its volume and mute status. + * Param: None. + */ +#define HDMI_CEC_OPCODE_GIVE_AUDIO_STATUS 0x71 + +/* + * System Audio Control Feature. + * Requests the status of the System Audio Mode. + * Param: None. + */ +#define HDMI_CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS 0x7D + +/* + * System Audio Control Feature. + * Reports an Amplifier's volume and mute status. + * Param: [Audio Status], 1 byte. + */ +#define HDMI_CEC_OPCODE_REPORT_AUDIO_STATUS 0x7A + +#define HDMI_CEC_REPORT_AUDIO_STATUSMSG_PARAM_LEN 1 + +/* + * Audio Status, 1 byte. + * [Audio Mute Status], Bit 7; [Audio Volume Status], Bits 6-0. + */ +#define HDMI_CEC_AUDIO_MUTE_STATUS_MARK 0x80 +#define HDMI_CEC_AUDIO_MUTE_STATUS_SHIFT 7 +#define HDMI_CEC_AUDIO_VOLUME_STATUS_MARK 0x7F +/* Audio Mute Status */ +#define HDMI_CEC_AUDIO_MUTE_STATUS_OFF 0 +#define HDMI_CEC_AUDIO_MUTE_STATUS_ON 1 +/* Audio Volume Status, 0%~100% */ +#define HDMI_CEC_AUDIO_VOLUME_STATUS_MIN_VAL 0x00 +#define HDMI_CEC_AUDIO_VOLUME_STATUS_MAX_VAL 0x64 +#define HDMI_CEC_AUDIO_VOLUME_STATUS_UNKNOWN 0x7F + +/* + * System Audio Control Feature. + * Report Audio Capability. + * Param: [Short Audio Descriptor], 3 bytes. Up to 4 Short Audio Descriptor identifying supported audio formats. + */ +#define HDMI_CEC_OPCODE_REPORT_SHORT_AUDIO_DESCRIPTOR 0xA3 + +#define HDMI_CEC_SHORT_AUDIO_DESCRIPTOR_LEN 3 +#define HDMI_CEC_MAX_SHORT_AUDIO_DESCRIPTOR_NUM 4 + +/* + * System Audio Control Feature. + * Report Audio Capability. + * Param: [Audio Format ID], 2 bits. [Audio Format Code], 6 bits. Up to 4 Audio Format ID and Audio Format Code. + */ +#define HDMI_CEC_OPCODE_REQUEST_SHORT_AUDIO_DESCRIPTOR 0xA4 + +#define HDMI_CEC_AUDIO_FORMAT_LEN 1 +#define HDMI_CEC_MAX_AUDIO_FORMAT_NUM 4 +#define HDMI_CEC_AUDIO_FORMAT_ID_SHIFT 6 +#define HDMI_CEC_AUDIO_FORMAT_CODE_MARK 0x3F + +/* + * System Audio Control Feature. + * Turns the System Audio Mode On or Off. + * Param: [System Audio Status], 1 byte. + * Broadcast/Directly addressed message. + */ +#define HDMI_CEC_OPCODE_SET_SYSTEM_AUDIO_MODE 0x72 + +#define HDMI_CEC_SYSTEM_AUDIO_STATUS_LEN 1 + +/* System Audio Status */ +#define HDMI_CEC_SYSTEM_AUDIO_STATUS_OFF 0 +#define HDMI_CEC_SYSTEM_AUDIO_STATUS_ON 1 + +/* + * System Audio Control Feature. + * A device implementing System Audio Control and which has volume control + * RC buttons(e.g. TV or STB) requests to use System Audio Mode to the Amplifier. + # Param: [Physical Address], 2 bytes. + */ +#define HDMI_CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST 0x70 + +#define HDMI_CEC_SYSTEM_AUDIO_MODE_REQUEST_PARAM_LEN 2 + +/* + * System Audio Control Feature. + * Reports the current status of the System Audio Mode. + * Param: [System Audio Status], 1 byte. + */ +#define HDMI_CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS 0x7E + +/* + * Audio Rate Control Feature. + * Used to control audio rate from Source Device. + * Param: [Audio Rate], 1 byte. + */ +#define HDMI_CEC_OPCODE_SET_AUDIO_RATE 0x9A + +#define HDMI_CEC_SET_AUDIO_RATE_PARAM_LEN 1 + +/* Audio Rate */ +enum HdmiCecAudioRate { + HDMI_CEC_AUDIO_RATE_OFF = 0, /* Rate Control Off */ + HDMI_CEC_AUDIO_RATE_WIDE_STD = 1, /* Standard Rate: 100% rate */ + HDMI_CEC_AUDIO_RATE_WIDE_FAST = 2, /* Fast Rate: Max 101% rate */ + HDMI_CEC_AUDIO_RATE_WIDE_SLOW = 3, /* Slow Rate: Min 99% rate */ + HDMI_CEC_AUDIO_RATE_NARROW_STD = 4, /* Standard Rate: 100.0% rate */ + HDMI_CEC_AUDIO_RATE_NARROW_FAST = 5, /* Fast Rate: Max 100.1% rate */ + HDMI_CEC_AUDIO_RATE_NARROW_SLOW = 6, /* Slow Rate: Min 99.9% rate */ +}; + +/* + * Audio Return Channel Control Feature. + * Used by an ARC RX device to active the ARC functionality in an ARC TX device. + * Param: None. + */ +#define HDMI_CEC_OPCODE_INITIATE_ARC 0xC0 + +/* + * Audio Return Channel Control Feature. + * Used by an ARC RX device to indicate that its ARC functionality has been actived. + * Param: None. + */ +#define HDMI_CEC_OPCODE_REPORT_ARC_INITIATED 0xC1 + +/* + * Audio Return Channel Control Feature. + * Used by an ARC RX device to indicate that its ARC functionality has been deactived. + * Param: None. + */ +#define HDMI_CEC_OPCODE_REPORT_ARC_TERMINATION 0xC2 + +/* + * Audio Return Channel Control Feature. + * Used by an ARC TX device to request an ARC RX device to + * active the ARC functionality in the ARC TX device. + * Param: None. + */ +#define HDMI_CEC_OPCODE_REQUEST_ARC_INITIATION 0xC3 + +/* + * Audio Return Channel Control Feature. + * Used by an ARC TX device to request an ARC RX device to + * deactive the ARC functionality in the ARC TX device. + * Param: None. + */ +#define HDMI_CEC_OPCODE_REQUEST_ARC_TERMINATION 0xC4 + +/* + * Audio Return Channel Control Feature. + * Used by an ARC TX device to deactive the ARC functionality in the ARC TX device. + * Param: None. + */ +#define HDMI_CEC_OPCODE_TERMINATE_ARC 0xC5 + +/* + * Capability Discovery and Control Feature. + * Used for Capability Discovery and Control. + * Broadcast message. + */ +#define HDMI_CEC_OPCODE_CDC_MESSAGE 0xF8 + +/* + * Dynamic Auto Lispync Feature. + * Used by Amplifier(or other device) to request current latency values. + * Param: [Physical Address], 2 byte. + */ +#define HDMI_CEC_OPCODE_REQUEST_CURRENT_LATENCY 0xA7 + +#define HDMI_CEC_REQUEST_CURRENT_LATENCY_MSG_LEN 2 + +/* + * Dynamic Auto Lispync Feature. + * Used by TV(or other Initiator) to report updates of latency. + * Param: [Physical Address], 2 byte. [Video Latency], 1 byte. [Latency Flags], 1 byte. + * [Audio Output Delay], 1 byte, optional. + */ +#define HDMI_CEC_OPCODE_REPORT_CURRENT_LATENCY 0xA8 + +#define HDMI_CEC_REPORT_CURRENT_LATENCY_MSG_PARAM_MAX_LEN 5 +#define HDMI_CEC_REPORT_CURRENT_LATENCY_MSG_PARAM_MIN_LEN 4 + +/* + * Latency Flags, 1 byte. + * Bit 7..3 reversed; Bit 2 [Low Latency Mode]; Bit 1-0 [Audio Output Compensated]. + */ +#define HDMI_CEC_LOW_LATENCY_MODE_SHIFT 2 +#define HDMI_CEC_NORMAL_LATENCY_MODE 0 +#define HDMI_CEC_LOW_LATENCY_MODE 1 + +#define HDMI_CEC_AUDIO_OUTPUT_COMPENSATED_NA 0 +#define HDMI_CEC_AUDIO_OUTPUT_COMPENSATED_DELAY 1 +#define HDMI_CEC_AUDIO_OUTPUT_COMPENSATED_NO_DELAY 2 +#define HDMI_CEC_AUDIO_OUTPUT_COMPENSATED_PARTIAL_DELAY 3 + +struct HdmiCecLatencyInfo { + uint8_t videoLatency; + uint8_t lowLatencyMode; + uint8_t audioOutputCompensated; + uint8_t audioOutputDelay; +}; + + +/* Broadcast System, 0~31. See hdmi spec1.4, CEC Table 31. */ +enum HdmiCecBroadcastSystem { + HDMI_CEC_BROADCAST_SYSTEM_PAL_BG = 0, + HDMI_CEC_BROADCAST_SYSTEM_SECAM_LQ = 1, + HDMI_CEC_BROADCAST_SYSTEM_PAL_M = 2, + HDMI_CEC_BROADCAST_SYSTEM_NTSC_M = 3, + HDMI_CEC_BROADCAST_SYSTEM_PAL_I = 4, + HDMI_CEC_BROADCAST_SYSTEM_SECAM_DK = 5, + HDMI_CEC_BROADCAST_SYSTEM_SECAM_BG = 6, + HDMI_CEC_BROADCAST_SYSTEM_SECAM_L = 7, + HDMI_CEC_BROADCAST_SYSTEM_PAL_DK = 8, + HDMI_CEC_BROADCAST_SYSTEM_OTHER = 31, +}; + +/* CDC(Capability Discovery and Control) Message */ + +/* + * HDMI Ethernet Channel Feature. + * Used to inquire the state of an HDMI Ethernet Channel. + * Param: [Physical Address], 2 byte. [Physical Address], 2 byte. + */ +#define HDMI_CDC_HEC_INQUIRE_STATE 0x00 + +#define HDMI_CDC_HEC_INQUIRE_STATE_MSG_PARAM_LEN 4 + +/* + * HDMI Ethernet Channel Feature. + * Used to report capabilities and states of a device that supports functionality. + * Param: [Physical Address], 2 bytes. [HEC State], 1 byte. [HEC Support Field], 2 bytes. + * [HEC Activation Field], 2 bytes. + */ +#define HDMI_CDC_HEC_REPORT_STATE 0x01 + +#define HDMI_CDC_HEC_REPORT_STATE_MSG_PARAM_MAX_LEN 5 +#define HDMI_CDC_HEC_REPORT_STATE_MSG_PARAM_MIN_LEN 3 + +/* + * HEC State, 1 byte + * [HEC Functionality State], 2 bits. + * [Host Functionality State], 2 bits. + * [ENC Functionality State], 2 bits. + * [CDC Error Code], 2 bits. + */ +#define HDMI_CDC_HEC_FUNC_STATE_SHIFT 6 +#define HDMI_CDC_HOST_FUNC_STATE_SHIFT 4 +#define HDMI_CDC_ENC_FUNC_STATE_SHIFT 2 + +enum HdmiCdcHecFuncState { + HDMI_CDC_HEC_FUNC_STATE_NOT_SUPPORTED = 0, + HDMI_CDC_HEC_FUNC_STATE_INACTIVE = 1, + HDMI_CDC_HEC_FUNC_STATE_ACTIVE = 2, + HDMI_CDC_HEC_FUNC_STATE_ACTIVATION_FIELD = 3, +}; + +enum HdmiCdcHostFuncState { + HDMI_CDC_HOST_HEC_STATE_NOT_SUPPORTED = 0, + HDMI_CDC_HOST_HEC_STATE_NOT_INACTIVE = 1, + HDMI_CDC_HOST_HEC_STATE_NOT_ACTIVE = 2, +}; + +enum HdmiCdcEncFuncState { + HDMI_CDC_ENC_FUNC_STATE_EXT_CON_NOT_SUPPORTED = 0, + HDMI_CDC_ENC_FUNC_STATE_EXT_CON_INACTIVE = 1, + HDMI_CDC_ENC_FUNC_STATE_EXT_CON_ACTIVE = 2, +}; + +enum HdmiCdcErrCode { + HDMI_CDC_ERR_CODE_NO_ERROR = 0, + HDMI_CDC_ERR_CODE_CAP_UNSUPPORTED = 1, + HDMI_CDC_ERR_CODE_WRONG_STATE = 2, + HDMI_CDC_ERR_CODE_OTHER = 3, +}; + +/* + * HEC Support Field, 2 bytes. + * [HEC Support], Bit 14. {14[HEC Support]}, Bit 13-0. + */ +#define HDMI_CDC_HEC_SUPPORT_MAKR (1 << 14) +#define HDMI_CDC_HEC_NOT_SUPPORT 0 +#define HDMI_CDC_HEC_SUPPORT 1 + +/* + * HEC Activation Field, 2 bytes. + * [HEC Activation], Bit 14. {14[HEC Activation]}, Bit 13-0. + */ +#define HDMI_CDC_HEC_ACTIVATION_MAKR (1 << 14) +#define HDMI_CDC_HEC_INACTIVE 0 +#define HDMI_CDC_HEC_ACTIVE 1 + +struct HdmiCdcHecState { + uint8_t hecFuncState; + uint8_t hostFuncState; + uint8_t encFuncState; + uint8_t cdcErrCode; + bool haveHecField; + uint16_t hecField; +}; + +/* + * HDMI Ethernet Channel Feature. + * Used to active or de-active an HDMI Ethernet Channel to an adjacent device. + * Param: [Physical Address], 2 bytes. [HEC Set State], 1 byte. + */ +#define HDMI_CDC_HEC_SET_STATE_ADJACENT 0x02 + +#define HDMI_CDC_HEC_SET_STATE_ADJACENT_MSG_PARAM_LEN 3 + +/* HEC Set State, 1 byte. */ +#define HDMI_CDC_DEACTIVATE_HEC 0 +#define HDMI_CDC_ACTIVATE_HEC 1 + +/* + * HDMI Ethernet Channel Feature. + * Used to active or de-active an HDMI Ethernet Channel to an adjacent device. + * Param: [Physical Address], 2 bytes. [Physical Address], 2 bytes. [HEC Set State], 1 byte. + * [Physical Address], 2 bytes. [Physical Address], 2 bytes. [Physical Address], 2 bytes. + * The last three [PA] parameters shall not be incorporated if only one HEC shall activated. + */ +#define HDMI_CDC_HEC_SET_STATE 0x03 + +#define HDMI_CDC_HEC_SET_STATE_MSG_MIN_LEN 5 +#define HDMI_CDC_HEC_SET_STATE_MSG_OPTIONAL_PA_MAX_NUM 3 + +struct HemiCdcHecStateInfo { + uint16_t phyAddr1; + uint16_t phyAddr2; + uint8_t hecSetState; + uint16_t phyAddr[HDMI_CDC_HEC_SET_STATE_MSG_OPTIONAL_PA_MAX_NUM]; + uint32_t phyAddrLen; +}; + +/* + * HDMI Ethernet Channel Feature. + * Used to request the deactivation of an HDMI Ethernet Channel. + * Param: [Physical Address], 2 bytes. [Physical Address], 2 bytes. [Physical Address], 2 bytes. + */ +#define HDMI_CDC_HEC_REQUEST_DEACTIVATION 0x04 + +#define HDMI_CDC_HEC_REQUEST_DEACTIVATION_MSG_PHY_ADDR_NUM 3 +#define HDMI_CDC_HEC_REQUEST_DEACTIVATION_MSG_PARAM_LEN 6 + +/* + * HDMI Ethernet Channel Feature. + * Used to keep alive HDMI Ethernet Channels active. + */ +#define HDMI_CDC_HEC_NOTIFY_ALIVE 0x05 + +/* + * HDMI Ethernet Channel Feature. + * Used to discover all HEC capabilities of devices within the HDMI network. + */ +#define HDMI_CDC_HEC_DISCOVER 0x06 + +/* + * CDC HPD Feature. + * Used to substitute physical HPD pin signaling. + * Param: [Input port number], 4 bits. [HPD State], 4 bits. + */ +#define HDMI_CDC_HPD_SET_STATE 0x10 + +#define HDMI_CDC_HPD_SET_STATE_MSG_LEN 1 +#define HDMI_CDC_INPUT_PORT_NUMBER_SHIFT 4 + +enum HdmiCdcHpdState { + HDMI_CDC_HDP_STATE_CP_EDID_DISABLE = 0, + HDMI_CDC_HDP_STATE_CP_EDID_ENABLE = 1, + HDMI_CDC_HDP_STATE_CP_EDID_DISABLE_ENABLE = 2, + HDMI_CDC_HDP_STATE_EDID_DISABLE = 3, + HDMI_CDC_HDP_STATE_EDID_ENABLE = 4, + HDMI_CDC_HDP_STATE_EDID_DISABLE_ENABLE = 5, + HDMI_CDC_HDP_STATE_BUTT, +}; + +/* + * CDC HPD Feature. + * Used to report the state of a device using the CDC HPD signaling. + * Param: [HPD State], 4 bits. [CDC_HPD_Error_Code], 4 bits. + */ +#define CEC_MSG_CDC_HPD_REPORT_STATE 0x11 + +#define HDMI_CDC_HPD_REPORT_STATE_MSG_LEN 1 +#define HDMI_CDC_HPD_STATE_SHIFT 4 + +enum HdmiCdcHpdErrCode { + HDMI_CDC_HPD_NO_ERR = 0, + HDMI_CDC_HPD_ERR_INITIATOR_NOT_CAPABLE = 1, + HDMI_CDC_HPD_ERR_INITIATOR_WRONG_STATE = 2, + HDMI_CDC_HPD_ERR_OTHER = 3, + HDMI_CDC_HPD_NO_ERR_NO_VIDEO_STREAM = 4, + HDMI_CDC_HPD_ERR_BUTT, +}; + +/* + * CEC message frame. + * + * 1 block 1 block 0-14 blocks + * Start_Bit CEC_Header_Block CEC_Opcode_Block CEC_Operand_Blocks + * + * CDC message frame. + * + * 1 block 1 block 2 blocks 1 block 0~11 blocks + * Start_Bit CEC_Header_Block CEC_Opcode_Block(0xF8) Initiator_Phy_Address CDC_Opcode CDC_Parameters + * + * Header Block. + * high 4 bits low 4 bits + * Initiator Logic Address field Destination Logic Address field + * + */ +#define HDMI_CEC_MSG_MAX_LEN 20 /* Make sure it has enough space. */ +#define HDMI_CEC_HEADER_LEN 1 +#define HDMI_CEC_OPCODE_LEN 1 +#define HDMI_CEC_MSG_MIN_LEN (HDMI_CEC_HEADER_LEN + HDMI_CEC_OPCODE_LEN) +#define HDMI_POLLING_MSG_LEN 1 +#define HDMI_CEC_INITIATOR_PHY_ADDRESS_LEN 2 +#define HDMI_CEC_GET_MSG_LEN(len) (HDMI_CEC_HEADER_LEN + HDMI_CEC_OPCODE_LEN + len) +#define HDMI_CDC_OPCODE_LEN 1 +#define HDMI_CDC_GET_MSG_LEN(len) \ + (HDMI_CEC_HEADER_LEN + HDMI_CEC_OPCODE_LEN + HDMI_CEC_INITIATOR_PHY_ADDRESS_LEN + HDMI_CDC_OPCODE_LEN + len) + +#define HDMI_CEC_HEADER_BLOCK_INITIATOR_MARK 0xF0 +#define HDMI_CEC_HEADER_BLOCK_DESTINATION_MARK 0x0F +#define HDMI_CEC_HEADER_BLOCK_INITIATOR_SHIFT 4 + +#define HDMI_CEC_INVALID_PHY_ADDR 0xFFFF +#define HDMI_CEC_INVALID_LOGICAL_ADDR 0xFF + +enum HdmiCecLogicalAddr { + HDMI_CEC_LOG_ADDR_TV = 0, + HDMI_CEC_LOG_ADDR_RECORDING_DEVICE_1 = 1, + HDMI_CEC_LOG_ADDR_RECORDING_DEVICE_2 = 2, + HDMI_CEC_LOG_ADDR_TUNER_1 = 3, + HDMI_CEC_LOG_ADDR_PLAYBACK_DEVICE_1 = 4, + HDMI_CEC_LOG_ADDR_AUDIO_SYSTEM = 5, + HDMI_CEC_LOG_ADDR_TUNER_2 = 6, + HDMI_CEC_LOG_ADDR_TUNER_3 = 7, + HDMI_CEC_LOG_ADDR_PLAYBACK_DEVICE_2 = 8, + HDMI_CEC_LOG_ADDR_RECORDING_DEVICE_3 = 9, + HDMI_CEC_LOG_ADDR_TUNER_4 = 10, + HDMI_CEC_LOG_ADDR_PLAYBACK_DEVICE_3 = 11, + HDMI_CEC_LOG_ADDR_BACKUP_1 = 12, + HDMI_CEC_LOG_ADDR_BACKUP_2 = 13, + HDMI_CEC_LOG_ADDR_SPECIFIC_USE = 14, + HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST = 15, /* + * Unregistered(as initiator address); + * Broadcast(as destination address). + */ + HDMI_CEC_LOG_ADDR_BUTT, +}; + +enum HdmiCecLogicalAddrMark { + HDMI_CEC_LOG_ADDR_MASK_TV = (1 << HDMI_CEC_LOG_ADDR_TV), + HDMI_CEC_LOG_ADDR_MASK_RECORD = ((1 << HDMI_CEC_LOG_ADDR_RECORDING_DEVICE_1) | + (1 << HDMI_CEC_LOG_ADDR_RECORDING_DEVICE_2) | (1 << HDMI_CEC_LOG_ADDR_RECORDING_DEVICE_3)), + HDMI_CEC_LOG_ADDR_MASK_TUNER = ((1 << HDMI_CEC_LOG_ADDR_TUNER_1) | (1 << HDMI_CEC_LOG_ADDR_TUNER_2) | + (1 << HDMI_CEC_LOG_ADDR_TUNER_3) | (1 << HDMI_CEC_LOG_ADDR_TUNER_4)), + HDMI_CEC_LOG_ADDR_MASK_PLAYBACK = ((1 << HDMI_CEC_LOG_ADDR_PLAYBACK_DEVICE_1) | + (1 << HDMI_CEC_LOG_ADDR_PLAYBACK_DEVICE_2) | (1 << HDMI_CEC_LOG_ADDR_PLAYBACK_DEVICE_3)), + HDMI_CEC_LOG_ADDR_MASK_AUDIOSYSTEM = (1 << HDMI_CEC_LOG_ADDR_AUDIO_SYSTEM), + HDMI_CEC_LOG_ADDR_MASK_BACKUP = ((1 << HDMI_CEC_LOG_ADDR_BACKUP_1) | (1 << HDMI_CEC_LOG_ADDR_BACKUP_2)), + HDMI_CEC_LOG_ADDR_MASK_SPECIFIC = (1 << HDMI_CEC_LOG_ADDR_SPECIFIC_USE), + HDMI_CEC_LOG_ADDR_MASK_UNREGISTERED = (1 << HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST), +}; + +enum HdmiCecLogicalAddrType { + HDMI_CEC_LOG_ADDR_TYPE_TV = 0, + HDMI_CEC_LOG_ADDR_TYPE_RECORD = 1, + HDMI_CEC_LOG_ADDR_TYPE_TUNER = 2, + HDMI_CEC_LOG_ADDR_TYPE_PLAYBACK = 3, + HDMI_CEC_LOG_ADDR_TYPE_AUDIOSYSTEM = 4, + HDMI_CEC_LOG_ADDR_TYPE_SPECIFIC = 5, + HDMI_CEC_LOG_ADDR_TYPE_UNREGISTERED = 6, +}; + +enum HdmiCecMsgType { + HDMI_CEC_MSG_BROADCAST_1_4 = 0x01, + HDMI_CEC_MSG_BROADCAST_2_0 = 0x02, + HDMI_CEC_MSG_BROADCAST = 0x03, + HDMI_CEC_MSG_DIRECTED = 0x04, + HDMI_CEC_MSG_DIRECTED_OR_BROADCAST_1_4 = 0x05, + HDMI_CEC_MSG_DIRECTED_OR_BROADCAST_2_0 = 0x06, + HDMI_CEC_MSG_ALL = 0x07, +}; + +struct HdmiCecMsgLenInfo { + uint8_t opcode; + uint8_t minLen; + uint8_t type; +}; + +#define HDMI_CEC_WAIT_RESPONSE_MSG_MAX_TIME 1000 /* 1s */ +struct HdmiCecMsg { + uint32_t len; + uint8_t data[HDMI_CEC_MSG_MAX_LEN]; + uint8_t rspMsg; + bool response; + uint32_t timeout; /* Indicates the maximum time(in ms) for the peer to reply to a message. */ +}; + +#define HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT 0 +#define HDMI_CEC_MSG_DATA_FIRST_ELEMENT 1 +#define HDMI_CEC_MSG_DATA_SECOND_ELEMENT 2 +#define HDMI_CEC_MSG_DATA_THIRD_ELEMENT 3 +#define HDMI_CEC_MSG_DATA_FORTH_ELEMENT 4 +#define HDMI_CEC_MSG_DATA_FIFTH_ELEMENT 5 +#define HDMI_CEC_MSG_DATA_SIXTH_ELEMENT 6 +#define HDMI_CEC_MSG_DATA_SEVENTH_ELEMENT 7 +#define HDMI_CEC_MSG_DATA_EIGHTH_ELEMENT 8 +#define HDMI_CEC_MSG_DATA_NINTH_ELEMENT 9 + +#define DATA_ZEROTH_OFFSET_ELEMENT 0 +#define DATA_FIRST_OFFSET_ELEMENT 1 +#define DATA_SECOND_OFFSET_ELEMENT 2 +#define DATA_THIRD_OFFSET_ELEMENT 3 +#define DATA_FORTH_OFFSET_ELEMENT 4 +#define DATA_FIFTH_OFFSET_ELEMENT 5 +#define DATA_SIXTH_OFFSET_ELEMENT 6 +#define DATA_SEVENTH_OFFSET_ELEMENT 7 +#define DATA_EIGHTH_OFFSET_ELEMENT 8 +#define DATA_NINTH_OFFSET_ELEMENT 9 +#define DATA_TENTH_OFFSET_ELEMENT 10 + +struct HdmiCecInfo { + uint8_t logAddr; + uint8_t logAddrType; + uint16_t logAddrMask; + uint8_t primaryDeviceType; + uint8_t cecVersion; + uint16_t phyAddr; + uint32_t vendorId; + uint32_t flags; + uint8_t osdName[HDMI_CEC_OSD_NAME_MAX_LEN + 1]; + uint8_t osdNameLen; + uint8_t allDeviceType; + uint8_t rcProfile[HDMI_CEC_RC_PROFILE_MAX_NUM]; + uint8_t devFeatures[HDMI_CEC_DEVICE_FEATURES_MAX_NUM]; + bool isWaitingResponse; + uint8_t response; +}; + +struct HdmiCec { + struct HdmiCecInfo info; + void *priv; +}; + +static inline bool HdmiCecIsBroadcastMsg(struct HdmiCecMsg *msg) +{ + if ((msg->data[0] & HDMI_CEC_HEADER_BLOCK_DESTINATION_MARK) == + HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST) { + return true; + } + return false; +} + +static inline uint8_t HdmiCecGetMsgInitiator(struct HdmiCecMsg *msg) +{ + return ((msg->data[0] & HDMI_CEC_HEADER_BLOCK_INITIATOR_MARK) >> HDMI_CEC_HEADER_BLOCK_INITIATOR_SHIFT); +} + +static inline uint8_t HdmiCecGetMsgDestination(struct HdmiCecMsg *msg) +{ + return (msg->data[0] & HDMI_CEC_HEADER_BLOCK_DESTINATION_MARK); +} + +static inline bool HdmiCecLogAddrValid(struct HdmiCec *cec, uint8_t logAddr) +{ + return (cec->info.logAddr & (1 << logAddr)); +} + +static inline bool HdmiCecIsCdcOnlyDevice(struct HdmiCec *cec) +{ + return ((cec->info.logAddr == HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST) && + (cec->info.primaryDeviceType == HDMI_CEC_DEVICE_TYPE_PURE_CEC_SWITCH)); +} + +static inline void HdmiCecFillMsgHeader(struct HdmiCecMsg *destMsg, struct HdmiCecMsg *srcMsg) +{ + destMsg->data[0] = (HdmiCecGetMsgDestination(srcMsg) << HDMI_CEC_HEADER_BLOCK_INITIATOR_SHIFT) | + HdmiCecGetMsgInitiator(srcMsg); +} + +int32_t HdmiCecReceivedMsg(struct HdmiCec *cec, struct HdmiCecMsg *msg); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_CEC_H */ diff --git a/support/platform/include/hdmi/hdmi_common.h b/support/platform/include/hdmi/hdmi_common.h new file mode 100644 index 0000000000000000000000000000000000000000..7f8a6486e1a408ec2b252d0db60b9cfe05855550 --- /dev/null +++ b/support/platform/include/hdmi/hdmi_common.h @@ -0,0 +1,366 @@ +/* + * Copyright (c) 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 HDMI_COMMON_H +#define HDMI_COMMON_H + +#include "hdf_base.h" +#include "hdmi_if.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +#define HDMI_CEA_VIDEO_CODE_MAX 44 +#define HDMI_VESA_VIDEO_CODE_MAX 31 +#define HDMI_VIDEO_4K_CODES_MAX 4 + +#define HDMI_BIT0_MARK 0x01 +#define HDMI_BIT1_MARK 0x02 +#define HDMI_BIT2_MARK 0x04 +#define HDMI_BIT3_MARK 0x08 +#define HDMI_BIT4_MARK 0x10 +#define HDMI_BIT5_MARK 0x20 +#define HDMI_BIT6_MARK 0x40 +#define HDMI_BIT7_MARK 0x80 +#define HDMI_UPPER_NIBBLE_MARK 0xf0 +#define HDMI_LOWER_NIBBLE_MARK 0x0f +#define HDMI_BITS_OF_ONE_BYTE 8 +#define HDMI_ONE_BYTE_SHIFT 8 +#define HDMI_6_BITS_SHIFT 6 +#define HDMI_NIBBLE_SHIFT 4 +#define HDMI_2_BITS_SHIFT 2 +#define HDMI_ONE_BYTE_MARK 0xFF +#define HDMI_TWO_BYTES_SHIFT 16 + +#define HDMI_HDMI14_MAX_TMDS_RATE 340000 /* unit: KHz */ +#define HDMI_HDMI20_MAX_TMDS_RATE 600000 /* unit: KHz */ +#define HDMI_MULTIPLE_2P0(x) (2 * x) +#define HDMI_MULTIPLE_1P5(x) (((x) * 3) >> 1) +#define HDMI_MULTIPLE_1P25(x) (((x) * 5) >> 2) +#define HDMI_MULTIPLE_0P5(x) ((x) >> 1) + +enum HdmiTmdsModeType { + HDMI_TMDS_MODE_NULL = 0, + HDMI_TMDS_MODE_DVI = 1, + HDMI_TMDS_MODE_HDMI_1_4 = 2, + HDMI_TMDS_MODE_HDMI_2_0 = 3, + HDMI_TMDS_MODE_AUTO = 4, + HDMI_TMDS_MODE_HDMI_2_1 = 5, + HDMI_TMDS_MODE_BUTT, +}; + +/* + * Video Identification Code (VIC). + * see CTA-861-G, table 3. + */ +enum HdmiVic { + HDMI_VIC_NONE = 0, /* No Video Identification Code Avaiable(Used with AVI InfoFrame only) */ + HDMI_VIC_640X480P60_4_3 = 1, + HDMI_VIC_720X480P60_4_3 = 2, + HDMI_VIC_720X480P60_16_9 = 3, + HDMI_VIC_1280X720P60_16_9 = 4, + HDMI_VIC_1920X1080I60_16_9 = 5, + HDMI_VIC_1440X480I60_4_3 = 6, + HDMI_VIC_1440X480I60_16_9 = 7, + HDMI_VIC_1440X240P60_4_3 = 8, + HDMI_VIC_1440X240P60_16_9 = 9, + HDMI_VIC_2880X480I60_4_3 = 10, + HDMI_VIC_2880X480I60_16_9 = 11, + HDMI_VIC_2880X240P60_4_3 = 12, + HDMI_VIC_2880X240P60_16_9 = 13, + HDMI_VIC_1440X480P60_4_3 = 14, + HDMI_VIC_1440X480P60_16_9 = 15, + HDMI_VIC_1920X1080P60_16_9 = 16, + HDMI_VIC_720X576P50_4_3 = 17, + HDMI_VIC_720X576P50_16_9 = 18, + HDMI_VIC_1280X720P50_16_9 = 19, + HDMI_VIC_1920X1080I50_16_9 = 20, + HDMI_VIC_1440X576I50_4_3 = 21, + HDMI_VIC_1440X576I50_16_9 = 22, + HDMI_VIC_1440X288P50_4_3 = 23, + HDMI_VIC_1440X288P50_16_9 = 24, + HDMI_VIC_2880X576I50_4_3 = 25, + HDMI_VIC_2880X576I50_16_9 = 26, + HDMI_VIC_2880X288P50_4_3 = 27, + HDMI_VIC_2880X288P50_16_9 = 28, + HDMI_VIC_1440X576P50_4_3 = 29, + HDMI_VIC_1440X576P50_16_9 = 30, + HDMI_VIC_1920X1080P50_16_9 = 31, + HDMI_VIC_1920X1080P24_16_9 = 32, + HDMI_VIC_1920X1080P25_16_9 = 33, + HDMI_VIC_1920X1080P30_16_9 = 34, + HDMI_VIC_2880X480P60_4_3 = 35, + HDMI_VIC_2880X480P60_16_9 = 36, + HDMI_VIC_2880X576P50_4_3 = 37, + HDMI_VIC_2880X576P50_16_9 = 38, + HDMI_VIC_1920X1080I50_1250_16_9 = 39, + HDMI_VIC_1920X1080I100_16_9 = 40, + HDMI_VIC_1280X720P100_16_9 = 41, + HDMI_VIC_720X576P100_4_3 = 42, + HDMI_VIC_720X576P100_16_9 = 43, + HDMI_VIC_1440X576I100_4_3 = 44, + HDMI_VIC_1440X576I100_16_9 = 45, + HDMI_VIC_1920X1080I120_16_9 = 46, + HDMI_VIC_1280X720P120_16_9 = 47, + HDMI_VIC_720X480P120_4_3 = 48, + HDMI_VIC_720X480P120_16_9 = 49, + HDMI_VIC_1440X480I120_4_3 = 50, + HDMI_VIC_1440X480I120_16_9 = 51, + HDMI_VIC_720X576P200_4_3 = 52, + HDMI_VIC_720X576P200_16_9 = 53, + HDMI_VIC_1440X576I120_4_3 = 54, + HDMI_VIC_1440X576I120_16_9 = 55, + HDMI_VIC_720X480P240_4_3 = 56, + HDMI_VIC_720X480P240_16_9 = 57, + HDMI_VIC_1440X480I240_4_3 = 58, + HDMI_VIC_1440X480I240_16_9 = 59, + HDMI_VIC_1280X720P24_16_9 = 60, + HDMI_VIC_1280X720P25_16_9 = 61, + HDMI_VIC_1280X720P30_16_9 = 62, + HDMI_VIC_1920X1080P120_16_9 = 63, + HDMI_VIC_1920X1080P100_16_9 = 64, + HDMI_VIC_1280X720P24_64_27 = 65, + HDMI_VIC_1280X720P25_64_27 = 66, + HDMI_VIC_1280X720P30_64_27 = 67, + HDMI_VIC_1280X720P50_64_27 = 68, + HDMI_VIC_1280X720P60_64_27 = 69, + HDMI_VIC_1280X720P100_64_27 = 70, + HDMI_VIC_1280X720P120_64_27 = 71, + HDMI_VIC_1920X1080P24_64_27 = 72, + HDMI_VIC_1920X1080P25_64_27 = 73, + HDMI_VIC_1920X1080P30_64_27 = 74, + HDMI_VIC_1920X1080P50_64_27 = 75, + HDMI_VIC_1920X1080P60_64_27 = 76, + HDMI_VIC_1920X1080P100_64_27 = 77, + HDMI_VIC_1920X1080P120_64_27 = 78, + HDMI_VIC_1680X720P24_64_27 = 79, + HDMI_VIC_1680X720P25_64_27 = 80, + HDMI_VIC_1680X720P30_64_27 = 81, + HDMI_VIC_1680X720P50_64_27 = 82, + HDMI_VIC_1680X720P60_64_27 = 83, + HDMI_VIC_1680X720P100_64_27 = 84, + HDMI_VIC_1680X720P120_64_27 = 85, + HDMI_VIC_2560X1080P24_64_27 = 86, + HDMI_VIC_2560X1080P25_64_27 = 87, + HDMI_VIC_2560X1080P30_64_27 = 88, + HDMI_VIC_2560X1080P50_64_27 = 89, + HDMI_VIC_2560X1080P60_64_27 = 90, + HDMI_VIC_2560X1080P100_64_27 = 91, + HDMI_VIC_2560X1080P120_64_27 = 92, + HDMI_VIC_3840X2160P24_16_9 = 93, + HDMI_VIC_3840X2160P25_16_9 = 94, + HDMI_VIC_3840X2160P30_16_9 = 95, + HDMI_VIC_3840X2160P50_16_9 = 96, + HDMI_VIC_3840X2160P60_16_9 = 97, + HDMI_VIC_4096X2160P24_256_135 = 98, + HDMI_VIC_4096X2160P25_256_135 = 99, + HDMI_VIC_4096X2160P30_256_135 = 100, + HDMI_VIC_4096X2160P50_256_135 = 101, + HDMI_VIC_4096X2160P60_256_135 = 102, + HDMI_VIC_3840X2160P24_64_27 = 103, + HDMI_VIC_3840X2160P25_64_27 = 104, + HDMI_VIC_3840X2160P30_64_27 = 105, + HDMI_VIC_3840X2160P50_64_27 = 106, + HDMI_VIC_3840X2160P60_64_27 = 107, + HDMI_VIC_1280X720P48_16_9 = 108, + HDMI_VIC_1280X720P48_64_27 = 109, + HDMI_VIC_1680X720P48_64_27 = 110, + HDMI_VIC_1920X1080P48_16_9 = 111, + HDMI_VIC_1920X1080P48_64_27 = 112, + HDMI_VIC_2560X1080P48_64_27 = 113, + HDMI_VIC_3840X2160P48_16_9 = 114, + HDMI_VIC_4096X2160P48_256_135 = 115, + HDMI_VIC_3840X2160P48_64_27 = 116, + HDMI_VIC_3840X2160P100_16_9 = 117, + HDMI_VIC_3840X2160P120_16_9 = 118, + HDMI_VIC_3840X2160P100_64_27 = 119, + HDMI_VIC_3840X2160P120_64_27 = 120, + HDMI_VIC_5120X2160P24_64_27 = 121, + HDMI_VIC_5120X2160P25_64_27 = 122, + HDMI_VIC_5120X2160P30_64_27 = 123, + HDMI_VIC_5120X2160P48_64_27 = 124, + HDMI_VIC_5120X2160P50_64_27 = 125, + HDMI_VIC_5120X2160P60_64_27 = 126, + HDMI_VIC_5120X2160P100_64_27 = 127, + HDMI_VIC_5120X2160P120_64_27 = 193, + HDMI_VIC_7680X4320P24_16_9 = 194, + HDMI_VIC_7680X4320P25_16_9 = 195, + HDMI_VIC_7680X4320P30_16_9 = 196, + HDMI_VIC_7680X4320P48_16_9 = 197, + HDMI_VIC_7680X4320P50_16_9 = 198, + HDMI_VIC_7680X4320P60_16_9 = 199, + HDMI_VIC_7680X4320P100_16_9 = 200, + HDMI_VIC_7680X4320P120_16_9 = 201, + HDMI_VIC_7680X4320P24_64_27 = 202, + HDMI_VIC_7680X4320P25_164_27 = 203, + HDMI_VIC_7680X4320P30_64_27 = 204, + HDMI_VIC_7680X4320P48_64_27 = 205, + HDMI_VIC_7680X4320P50_64_27 = 206, + HDMI_VIC_7680X4320P60_64_27 = 207, + HDMI_VIC_7680X4320P100_64_27 = 208, + HDMI_VIC_7680X4320P120_64_27 = 209, + HDMI_VIC_10240X4320P24_64_27 = 210, + HDMI_VIC_10240X4320P25_64_27 = 211, + HDMI_VIC_10240X4320P30_64_27 = 212, + HDMI_VIC_10240X4320P48_64_27 = 213, + HDMI_VIC_10240X4320P50_64_27 = 214, + HDMI_VIC_10240X4320P60_64_27 = 215, + HDMI_VIC_10240X4320P100_64_27 = 216, + HDMI_VIC_10240X4320P120_64_27 = 217, + HDMI_VIC_4096X2160P100_256_135 = 218, + HDMI_VIC_4096X2160P120_256_135 = 219, +}; + +enum HdmiVideoFormatType { + HDMI_VIDEO_FORMAT_NULL = 0, + HDMI_VIDEO_FORMAT_PROGRESSIVE = 1, + HDMI_VIDEO_FORMA_INTERLACE = 2, + HDMI_VIDEO_FORMA_BUTT, +}; + +enum HdmiColorDeep { + HDMI_COLOR_DEEP_8BITS = 8, + HDMI_COLOR_DEEP_10BITS = 10, + HDMI_COLOR_DEEP_12BITS = 12, + HDMI_COLOR_DEEP_16BITS = 16, + HDMI_COLOR_DEEP_BUTT, +}; + +enum HdmiPhyModeCfg { + HDMI_PHY_MODE_TMDS = 0, + HDMI_PHY_MODE_FRL = 1, + HDMI_PHY_MODE_TXFFE = 2, + HDMI_PHY_MODE_BUTT, +}; + +enum HdmiHdcpMode { + HDMI_HDCP_MODE_AUTO = 0, + HDMI_HDCP_MODE_1_4 = 1, + HDMI_HDCP_MODE_2_2 = 2, + HDMI_HDCP_MODE_BUTT +}; + +struct HdmiVideoDefInfo { + enum HdmiVic vic; + uint32_t pixclk; + uint32_t rate; + uint32_t hactive; + uint32_t vactive; + uint32_t hblank; + uint32_t vblank; + uint32_t hfront; + uint32_t hsync; + uint32_t hback; + uint32_t vfront; + uint32_t vsync; + uint32_t vback; + enum HdmiPictureAspectRatio aspect; + enum HdmiVideoTiming timing; + enum HdmiVideoFormatType formatType; +}; + +/* see hdmi spec2.0 table 10-2. */ +enum Hdmi4kVic { + HDMI_4K_VIC_3840X2160_30 = 1, + HDMI_4K_VIC_3840X2160_25, + HDMI_4K_VIC_3840X2160_24, + HDMI_4K_VIC_4096X2160_24 +}; + +struct HdmiVideo4kInfo { + enum Hdmi4kVic _4kVic; + enum HdmiVic vic; + uint32_t pixclk; + uint32_t rate; + uint32_t hactive; + uint32_t vactive; + enum HdmiPictureAspectRatio aspect; + enum HdmiVideoTiming timing; + enum HdmiVideoFormatType formatType; +}; + +struct HdmiCommonStatus { + bool hotplug; + bool avmute; + bool sinkPowerOn; + enum HdmiTmdsModeType tmdsMode; +}; + +struct HdmiAudioStatus { + bool mute; + bool enable; + bool downSample; + enum HdmiSampleRate sampleRate; + enum HdmiAudioInterfaceType interface; + enum HdmiAudioBitDepth bitDepth; + enum HdmiAudioFormatChannel channel; + uint32_t refN; + uint32_t regN; + uint32_t refCts; + uint32_t regCts; +}; + +struct HdmiVideoStatus { + bool mute; + bool ycbcr2Rgb; + bool rgb2Ycbcr; + bool ycbcr444422; + bool ycbcr422420; + bool ycbcr420422; + bool ycbcr422444; + bool in420Ydemux; + bool out420Ydemux; + bool vSyncPol; + bool hSyncPol; + bool syncPol; + bool dePol; + bool swapHsCs; + enum HdmiColorSpace inColorSpace; + enum HdmiColorSpace outColorSpace; + enum HdmiVideoBitDepth outBitDepth; + enum HdmiQuantizationRange quantization; +}; + +struct HdmiCommonAttr { + bool enableHdmi; + bool enableVideo; + bool enableAudio; + bool xvyccMode; + bool avi; + bool spd; + bool mpeg; + bool audio; + bool drm; + bool hdcpEnable; + bool vsifDolby; + enum HdmiColorSpace colorSpace; + enum HdmiQuantizationRange quantization; + enum HdmiDeepColor deepColor; + enum HdmiHdcpMode hdcpMode; +}; + +enum HdmiVideoBitDepth HdmiCommonDeepClolorConvertToColorDepth(enum HdmiDeepColor deepColor); +enum HdmiDeepColor HdmiCommonColorDepthConvertToDeepClolor(enum HdmiVideoBitDepth colorDepth); +enum HdmiVic HdmiCommonGetVic(enum HdmiVideoTiming timing, + enum HdmiPictureAspectRatio aspect, bool enable3d); +struct HdmiVideoDefInfo *HdmiCommonGetVideoDefInfo(enum HdmiVideoTiming timing, + enum HdmiPictureAspectRatio aspect, bool enable3d); +struct HdmiVideo4kInfo *HdmiCommonGetVideo4kInfo(uint32_t _4kVic); +enum HdmiVideoTiming HdmiCommonGetVideoTiming(enum HdmiVic vic, enum HdmiPictureAspectRatio aspect); +enum HdmiVideoTiming HdmiCommonGetVideo4kTiming(uint32_t _4kVic); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_COMMON_H */ diff --git a/support/platform/include/hdmi/hdmi_core.h b/support/platform/include/hdmi/hdmi_core.h new file mode 100644 index 0000000000000000000000000000000000000000..f54c6910fdd4afe1346a0943f2fcc6afa1677b03 --- /dev/null +++ b/support/platform/include/hdmi/hdmi_core.h @@ -0,0 +1,390 @@ +/* + * Copyright (c) 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 HDMI_CORE_H +#define HDMI_CORE_H + +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "hdmi_cec.h" +#include "hdmi_common.h" +#include "hdmi_ddc.h" +#include "hdmi_edid.h" +#include "hdmi_event.h" +#include "hdmi_frl.h" +#include "hdmi_hdcp.h" +#include "hdmi_hdr.h" +#include "hdmi_if.h" +#include "hdmi_infoframe.h" +#include "hdmi_scdc.h" +#include "osal_mutex.h" +#include "platform_core.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +#define HDMI_ONE_BYTE_MARK 0xFF +#define HDMI_ONE_BYTE_SHIFT 8 +#define HDMI_TWO_BYTES_SHIFT 16 + +struct HdmiPhyCfg { + uint32_t pixelClk; + uint32_t tmdsClk; /* TMDS colck, KHz */ + enum HdmiDeepColor deepColor; /* deep color(color depth) */ + enum HdmiPhyModeCfg modeCfg; /* TMDS/FRL/tx_ffe */ + enum HdmiColorSpace colorSpace; + enum HdmiFrlWorkMode rate; /* lane and rate */ + enum HdmiFrlTxffeMode txffe[4]; /* tx_ffe */ +}; + +struct HdmiTmdsConfig { + uint32_t pixelClk; + uint32_t tmdsClk; + enum HdmiPhyModeCfg mode; + enum HdmiDeepColor deepColor; +}; + +struct HdmiCntlr; + +union HdmiCap { + uint32_t data; + struct CapBitsData { + uint32_t scdc : 1; /* bit0: support scdc */ + uint32_t frl : 1; /* bit1: support frl */ + uint32_t hdr : 1; /* bit2: support hdr */ + uint32_t hdcp : 1; /* bit3: support hdcp */ + uint32_t cec : 1; /* bit4: support cec */ + uint32_t hdmi14 : 1; /* bit5: support hdmi1.4 spec */ + uint32_t hdmi20 : 1; /* bit6: support hdmi2.0 spec */ + uint32_t hdmi21 : 1; /* bit7: support hdmi2.1 spec */ + uint32_t hdcp14 : 1; /* bit8: support hdcp1.4 spec */ + uint32_t hdcp22 : 1; /* bit9: support hdcp2.2 spec */ + uint32_t rgb444 : 1; /* bit10: support rgb444 */ + uint32_t ycbcr444 : 1; /* bit11: support ycbcr444 */ + uint32_t ycbcr422 : 1; /* bit12: support ycbcr422 */ + uint32_t ycbcr420 : 1; /* bit13: support ycbcr420 */ + uint32_t deepColor10bits : 1; /* bit14: support deep color 10 bits */ + uint32_t deepColor12bits : 1; /* bit15: support deep color 12 bits */ + uint32_t deepColor16bits : 1; /* bit16: support deep color 16 bits */ + uint32_t scramble : 1; /* bit17: support scramble */ + uint32_t cecRc : 1; /* bit18: support CEC Remote Control */ + uint32_t rev : 13; /* bit21~31: reserved */ + } bits; +}; + +enum HdmiCapMark { + HDMI_CAP_SCDC_MARK = (1 << 0), + HDMI_CAP_FRL_MARK = (1 << 1), + HDMI_CAP_HDR_MARK = (1 << 2), + HDMI_CAP_HDCP_MARK = (1 << 3), + HDMI_CAP_CEC_MARK = (1 << 4), + HDMI_CAP_HDMI14_MARK = (1 << 5), + HDMI_CAP_HDMI20_MARK = (1 << 6), + HDMI_CAP_HDMI21_MARK = (1 << 7), + HDMI_CAP_HDCP14_MARK = (1 << 8), + HDMI_CAP_HDCP22_MARK = (1 << 9), + HDMI_CAP_RGB444_MARK = (1 << 10), + HDMI_CAP_YCBCR444_MARK = (1 << 11), + HDMI_CAP_YCBCR422_MARK = (1 << 12), + HDMI_CAP_YCBCR420_MARK = (1 << 13), + HDMI_CAP_DEEP_COLOR_10BITES_MARK = (1 << 14), + HDMI_CAP_DEEP_COLOR_12BITES_MARK = (1 << 15), + HDMI_CAP_DEEP_COLOR_16BITES_MARK = (1 << 16), + HDMI_CAP_SCRAMBLE_MARK = (1 << 17), +}; + +struct HdmiCntlrCap { + union HdmiCap baseCap; + uint32_t maxTmdsClock; + uint32_t defTmdsClock; /* unit: MHz */ + uint32_t maxFrlRate; + uint32_t videoTiming; + uint32_t quantization; + uint32_t colorSpace; + uint32_t colorimetry; + uint32_t audioIfType; + uint32_t audioBitDepth; + uint32_t audioSampleRate; + uint32_t audioChannels; + uint32_t hdrColorimetry; + uint32_t hdrUserMode; +}; + +struct HdmiHardwareStatus { + struct HdmiCommonStatus commonStatus; + struct HdmiAudioStatus audioStatus; + struct HdmiVideoStatus videoStatus; + struct HdmiInfoFrameStatus infoFrameStatus; + struct HdmiHdcpStatus hdcpstatus; +}; + +struct HdmiAudioConfigInfo { + bool enable; + bool downSample; + uint32_t tmdsClock; + uint32_t pixelRepeat; + enum HdmiAudioInterfaceType ifType; + enum HdmiAudioBitDepth bitDepth; + enum HdmiSampleRate sampleRate; + enum HdmiAudioFormatChannel channels; +}; + +struct HdmiCntlrOps { + void (*hardWareInit)(struct HdmiCntlr *cntlr); + void (*hardWareStatusGet)(struct HdmiCntlr *cntlr, struct HdmiHardwareStatus *status); + void (*controllerReset)(struct HdmiCntlr *cntlr); + bool (*hotPlugStateGet)(struct HdmiCntlr *cntlr); + bool (*hotPlugInterruptStateGet)(struct HdmiCntlr *cntlr); + void (*lowPowerSet)(struct HdmiCntlr *cntlr, bool enable); + void (*tmdsModeSet)(struct HdmiCntlr *cntlr, enum HdmiTmdsModeType mode); + int32_t (*tmdsConfigSet)(struct HdmiCntlr *cntlr, struct HdmiTmdsConfig mode); + void (*infoFrameEnable)(struct HdmiCntlr *cntlr, enum HdmiPacketType infoFrameType, bool enable); + int32_t (*infoFrameSend)(struct HdmiCntlr *cntlr, enum HdmiPacketType infoFrameType, uint8_t *data, uint32_t len); + int32_t (*infoFrameDataSet)(struct HdmiCntlr *cntlr, uint32_t type, uint8_t *data, uint32_t len); + int32_t (*cecMsgSend)(struct HdmiCntlr *cntlr, struct HdmiCecMsg *msg); + void (*audioPathEnable)(struct HdmiCntlr *cntlr, bool enable); + void (*audioPathSet)(struct HdmiCntlr *cntlr, struct HdmiAudioConfigInfo *config); + void (*phyOutputEnable)(struct HdmiCntlr *cntlr, bool enable); + void (*phyOutputSet)(struct HdmiCntlr *cntlr, struct HdmiPhyCfg *cfg); + void (*blackDataSet)(struct HdmiCntlr *cntlr, bool enable); + void (*videoMuteEnable)(struct HdmiCntlr *cntlr, bool enable); + void (*videoPathSet)(struct HdmiCntlr *cntlr, struct HdmiVideoAttr *attr); + void (*audioMuteEnable)(struct HdmiCntlr *cntlr, bool enable); + void (*avmuteSet)(struct HdmiCntlr *cntlr, bool enable); + int32_t (*ddcTransfer)(struct HdmiCntlr *cntlr, struct HdmiDdcCfg *ddcCfg); + bool (*scdcSourceScrambleGet)(struct HdmiCntlr *cntlr); + int32_t (*scdcSourceScrambleSet)(struct HdmiCntlr *cntlr, bool enable); + void (*frlSet)(struct HdmiCntlr *cntlr); + int32_t (*frlEnable)(struct HdmiCntlr *cntlr, bool enable); + int32_t (*audioNctsSet)(struct HdmiCntlr *cntlr, struct HdmiFrlAudioNctsConfig *cfg); + void (*frlTrainingConfigSet)(struct HdmiCntlr *cntlr, struct HdmiFrlTrainConfig *cfg); + void (*frlTrainingStart)(struct HdmiCntlr *cntlr); + void (*frlGetTriningRslt)(struct HdmiCntlr *cntlr, struct HdmiFrlTrainRslt *rslt); + void (*hdcpRegInit)(struct HdmiCntlr *cntlr); + int32_t (*hdcpGenerateAksvAndAn)(struct HdmiCntlr *cntlr); + int32_t (*hdcpOptReg)(struct HdmiCntlr *cntlr, enum HdmiHdcpRegOptType type, uint8_t *data, uint32_t len); + void (*hdrTimerSet)(struct HdmiCntlr *cntlr, struct HdmiHdrTimerConfig *config); +}; + +enum HdmiCntlrState { + HDMI_CNTLR_STATE_NONE = 0, + HDMI_CNTLR_STATE_OPEN = (1 << 0), + HDMI_CNTLR_STATE_START = (1 << 1), + HDMI_CNTLR_STATE_STOP = (1 << 2), + HDMI_CNTLR_STATE_CLOSE = (1 << 3), +}; + +struct HdmiDevice { + struct HdmiEdid edid; /* device cap */ + struct HdmiCntlr *cntlr; + void *priv; +}; + +struct HdmiAttr { + struct HdmiCommonAttr commAttr; + struct HdmiAudioAttr audioAttr; + struct HdmiVideoAttr videoAttr; + struct HdmiHdrAttr hdrAttr; +}; + +struct HdmiCntlr { + struct IDeviceIoService service; + struct HdfDeviceObject *hdfDevObj; + struct PlatformDevice device; + struct OsalMutex mutex; + struct PlatformQueue *msgQueue; + struct HdmiCntlrCap cap; + struct HdmiAttr attr; + struct HdmiCntlrOps *ops; + uint32_t deviceIndex; + uint32_t state; /* cntlr state. */ + enum HdmiTmdsModeType tmdsMode; + struct HdmiDevice *hdmi; + struct HdmiInfoFrame infoFrame; + struct HdmiScdc *scdc; + struct HdmiDdc ddc; + struct HdmiFrl *frl; + struct HdmiHdcp *hdcp; + struct HdmiCec *cec; + struct HdmiEvent event; + struct HdmiHdr *hdr; + void *priv; +}; + +static inline void HdmiCntlrLock(struct HdmiCntlr *cntlr) +{ + if (cntlr != NULL) { + (void)OsalMutexLock(&cntlr->mutex); + } +} + +static inline void HdmiCntlrUnlock(struct HdmiCntlr *cntlr) +{ + if (cntlr != NULL) { + (void)OsalMutexUnlock(&cntlr->mutex); + } +} + +static inline struct HdmiCntlr *HdmiCntlrGetByBusNum(uint16_t num) +{ + struct PlatformDevice *device = PlatformManagerGetDeviceByNumber(PlatformManagerGet(PLATFORM_MODULE_HDMI), num); + + if (device == NULL) { + return NULL; + } + return CONTAINER_OF(device, struct HdmiCntlr, device); +} + +static inline void HdmiCntlrLowPowerSet(struct HdmiCntlr *cntlr, bool enable) +{ + if (cntlr->ops != NULL && cntlr->ops->lowPowerSet != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->lowPowerSet(cntlr, enable); + HdmiCntlrUnlock(cntlr); + } +} + +static inline void HdmiCntlrHardWareInit(struct HdmiCntlr *cntlr) +{ + if (cntlr->ops != NULL && cntlr->ops->hardWareInit != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->hardWareInit(cntlr); + HdmiCntlrUnlock(cntlr); + } +} + +static inline void HdmiCntlrAudioPathEnable(struct HdmiCntlr *cntlr, bool enable) +{ + if (cntlr->ops != NULL && cntlr->ops->audioPathEnable != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->audioPathEnable(cntlr, enable); + HdmiCntlrUnlock(cntlr); + } +} + +static inline void HdmiCntlrAudioPathSet(struct HdmiCntlr *cntlr, struct HdmiAudioConfigInfo *config) +{ + if (cntlr->ops != NULL && cntlr->ops->audioPathSet != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->audioPathSet(cntlr, config); + HdmiCntlrUnlock(cntlr); + } +} + +static inline void HdmiCntlrAudioMuteEnable(struct HdmiCntlr *cntlr, bool enable) +{ + if (cntlr->ops != NULL && cntlr->ops->audioMuteEnable != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->audioMuteEnable(cntlr, enable); + HdmiCntlrUnlock(cntlr); + } +} + +static inline void HdmiCntlrVideoPathSet(struct HdmiCntlr *cntlr, struct HdmiVideoAttr *attr) +{ + if (cntlr->ops != NULL && cntlr->ops->videoPathSet != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->videoPathSet(cntlr, attr); + HdmiCntlrUnlock(cntlr); + } +} + +static inline void HdmiCntlrTmdsModeSet(struct HdmiCntlr *cntlr, enum HdmiTmdsModeType mode) +{ + if (cntlr->ops != NULL && cntlr->ops->tmdsModeSet != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->tmdsModeSet(cntlr, mode); + HdmiCntlrUnlock(cntlr); + } +} + +static inline void HdmiCntlrReset(struct HdmiCntlr *cntlr) +{ + if (cntlr->ops != NULL && cntlr->ops->controllerReset != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->controllerReset(cntlr); + HdmiCntlrUnlock(cntlr); + } +} + +static inline void HdmiCntlrBlackDataSet(struct HdmiCntlr *cntlr, bool enable) +{ + if (cntlr->ops != NULL && cntlr->ops->blackDataSet != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->blackDataSet(cntlr, enable); + HdmiCntlrUnlock(cntlr); + } +} + +static inline void HdmiCntlrPhyOutputEnablet(struct HdmiCntlr *cntlr, bool enable) +{ + if (cntlr->ops != NULL && cntlr->ops->phyOutputEnable != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->phyOutputEnable(cntlr, enable); + HdmiCntlrUnlock(cntlr); + } +} + +static inline void HdmiCntlrHdrTimerSet(struct HdmiCntlr *cntlr, struct HdmiHdrTimerConfig *config) +{ + if (cntlr->ops != NULL && cntlr->ops->hdrTimerSet != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->hdrTimerSet(cntlr, config); + HdmiCntlrUnlock(cntlr); + } +} + +static inline void HdmiCntlrAvmuteSet(struct HdmiCntlr *cntlr, bool enable) +{ + if (cntlr->ops != NULL && cntlr->ops->avmuteSet != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->avmuteSet(cntlr, enable); + HdmiCntlrUnlock(cntlr); + } +} + +int32_t HdmiCntlrParse(struct HdmiCntlr *cntlr, struct HdfDeviceObject *obj); +int32_t HdmiCntlrAdd(struct HdmiCntlr *cntlr); +void HdmiCntlrRemove(struct HdmiCntlr *cntlr); + +int32_t HdmiCntlrOpen(struct HdmiCntlr *cntlr); +int32_t HdmiCntlrGetSinkEdid(struct HdmiCntlr *cntlr, uint8_t *buffer, uint32_t len); +int32_t HdmiCntlrStart(struct HdmiCntlr *cntlr); +int32_t HdmiCntlrStop(struct HdmiCntlr *cntlr); +int32_t HdmiCntlrDeepColorSet(struct HdmiCntlr *cntlr, enum HdmiDeepColor color); +int32_t HdmiCntlrDeepColorGet(struct HdmiCntlr *cntlr, enum HdmiDeepColor *color); +int32_t HdmiCntlrSetVideoAttribute(struct HdmiCntlr *cntlr, struct HdmiVideoAttr *attr); +int32_t HdmiCntlrSetAudioAttribute(struct HdmiCntlr *cntlr, struct HdmiAudioAttr *attr); +int32_t HdmiCntlrSetHdrAttribute(struct HdmiCntlr *cntlr, struct HdmiHdrAttr *attr); +int32_t HdmiCntlrInfoFrameGet(struct HdmiCntlr *cntlr, enum HdmiPacketType type, union HdmiInfoFrameInfo *frame); +int32_t HdmiCntlrInfoFrameSet(struct HdmiCntlr *cntlr, enum HdmiPacketType type, union HdmiInfoFrameInfo *frame); +int32_t HdmiCntlrRegisterHpdCallbackFunc(struct HdmiCntlr *cntlr, struct HdmiHpdCallbackInfo *callback); +int32_t HdmiCntlrUnregisterHpdCallbackFunc(struct HdmiCntlr *cntlr); +void HdmiCntlrClose(struct HdmiCntlr *cntlr); + +bool HdmiHpdStatusDelayGet(struct HdmiCntlr *cntlr); +bool HdmiHpdStatusGet(struct HdmiCntlr *cntlr); +int32_t HdmiEventHandle(struct HdmiCntlr *cntlr, enum HdmiEventType event, void *data); +int32_t HdmiEventMsgHandleDefault(struct PlatformQueue *queue, struct PlatformMsg *msg); + +bool HdmiEdidSupportFrl(struct HdmiDevice *hdmi); +uint8_t HdmiEdidGetMaxFrlRate(struct HdmiDevice *hdmi); +bool HdmiEdidScdcSupport(struct HdmiDevice *hdmi); +int32_t HdmiCntlrAllocDev(struct HdmiCntlr *cntlr); +void HdmiCntlrFreeDev(struct HdmiCntlr *cntlr); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_CORE_H */ diff --git a/support/platform/include/hdmi/hdmi_ddc.h b/support/platform/include/hdmi/hdmi_ddc.h new file mode 100644 index 0000000000000000000000000000000000000000..4dbcc25b29867c2a4043857cc943c065e1842081 --- /dev/null +++ b/support/platform/include/hdmi/hdmi_ddc.h @@ -0,0 +1,77 @@ +/* + * Copyright (c) 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 HDMI_DDC_H +#define HDMI_DDC_H + +#include "hdf_base.h" +#include "osal_mutex.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/* + * DDC(Display Data Channel) + * The DDC channel is used by an HDMI Source to determine the capabilities and characteristics of + * the Sink by reading the E-EDID data structure. + * The DDC is also uesd to exchange point-to-point dynamic data between the Source and the Sink + * using a new DDC address for the HDMI Status and Control Data Channel(SCDC). + * In addition, The DDC is also uesd for HDCP to exchange key selection vector and other information. + */ +#define HDMI_DDC_EDID_DEV_ADDRESS 0xA0 +#define HDMI_DDC_SCDC_DEV_ADDRESS 0xA8 +#define HDMI_DDC_HDCP_DEV_ADDRESS 0x74 + +enum HdmiDdcDeviceType { + HDMI_DDC_DEV_EDID = 0, + HDMI_DDC_DEV_SCDC = 1, + HDMI_DDC_DEV_HDCP = 2, + HDMI_DDC_DEV_BUTT, +}; + +enum HdmiDdcMode { + HDMI_DDC_MODE_READ_SINGLE_NO_ACK = 0, + HDMI_DDC_MODE_READ_SINGLE_ACK = 1, + HDMI_DDC_MODE_READ_MUTIL_NO_ACK = 2, + HDMI_DDC_MODE_READ_MUTIL_ACK = 3, + HDMI_DDC_MODE_READ_SEGMENT_NO_ACK = 4, + HDMI_DDC_MODE_READ_SEGMENT_ACK = 5, + HDMI_DDC_MODE_WRITE_MUTIL_NO_ACK = 6, + HDMI_DDC_MODE_WRITE_MUTIL_ACK = 7, + HDMI_DDC_MODE_BUTT, +}; + +struct HdmiDdcCfg { + enum HdmiDdcDeviceType type; + enum HdmiDdcMode mode; + bool readFlag; + uint32_t devAddr; + uint8_t offset; + uint8_t segment; /* see VESA spec. 1 segment is 256 bytes. */ + uint32_t dataLen; + uint8_t *data; +}; + +struct HdmiDdc { + struct OsalMutex ddcMutex; + bool init; + void *priv; +}; + +int32_t HdmiDdcTransfer(struct HdmiDdc *ddc, struct HdmiDdcCfg *cfg); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_DDC_H */ diff --git a/support/platform/include/hdmi/hdmi_dfm.h b/support/platform/include/hdmi/hdmi_dfm.h new file mode 100644 index 0000000000000000000000000000000000000000..c40456a5689dbbfa2a5e387b29ffd6cfc919113e --- /dev/null +++ b/support/platform/include/hdmi/hdmi_dfm.h @@ -0,0 +1,163 @@ +/* + * Copyright (c) 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 HDMI_DFM_H +#define HDMI_DFM_H + +#include "hdmi_common.h" +#include "hdmi_if.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/* + * DFM(Data Flow Metering). + * During data transmission in FRL mode, there is a lot of bandwidth redundancy (blanking period) or slight bandwidth + * insufficiency (active video). In order for the link to tolerate these fluctuations, source and sink need to use + * buffers. To limit the size of the buffer required, the protocol adds the Data Flow Metering requirement. + */ +#define HDMI_DFM_FRL_CHAR_NUM_PER_CB 502 +#define HDMI_DFM_RS_NUM_PER_CB 8 +/* A FRL Character Block(CB) contains 502 FRL Characters and 8 RS check characters. */ +#define HDMI_DFM_CHAR_NUM_PER_CB (HDMI_DFM_FRL_CHAR_NUM_PER_CB + HDMI_DFM_RS_NUM_PER_CB) + +/* + * A FRL Super Block(SB) contains four FRL Character Blocks. + * Each FRL Super Block is preceded by a group of three or four Start Super Blocks (SSB) or a group of three or + * four Scrambler Reset (SR) characters. + */ +#define HDMI_DFM_FRL_CB_NUM_PER_SB 4 +#define HDMI_DFM_FRL_SB_LEN(lane) (HDMI_DFM_FRL_CB_NUM_PER_SB * HDMI_DFM_CHAR_NUM_PER_CB + lane) + +#define HDMI_DFM_FRL_PIXELCLK_TOLERANCE 5 /* 0.50% */ +#define HDMI_DFM_FRL_BITRATE_TOLERANCE 3 /* 300 */ +#define HDMI_DFM_FRL_AUDIOCLK_TOLERANCE 1 +#define HDMI_DFM_MAGNIFICATION_8 8 +#define HDMI_DFM_FRL_MAX_TB_BORROW 400 +#define HDMI_DFM_RATE_MAGNIFICATION 100000 +#define HDMI_DFM_OVERHEAD_SIZE 300 + +#define HDMI_AUDIO_CHANNEL_ALLOC_TYPE1 1 +#define HDMI_AUDIO_CHANNEL_ALLOC_TYPE2 2 +#define HDMI_AUDIO_CHANNEL_ALLOC_TYPE3 3 + +/* + * Packets per sample. + * This is the number of audio packets required to carry each sample. + * x100. + */ +#define HDMI_AUDIO_AP_SIZE_25 25 +#define HDMI_AUDIO_AP_SIZE_100 100 +#define HDMI_AUDIO_AP_SIZE_200 200 +#define HDMI_AUDIO_AP_SIZE_300 300 +#define HDMI_AUDIO_AP_SIZE_400 400 + +enum HdmiAudioPacketType { + HDMI_AUDIO_SAMPLE_PACKET = 0x02, + HDMI_ONE_BIT_AUDIO_SAMPLE_PACKET = 0x07, + HDMI_DTS_AUDIO_PACKET = 0x08, + HDMI_HBR_AUDIO_PACKET = 0x09, + HDMI_AUDIO_3D_SAMPLE_PACKET = 0x0B, + HDMI_ONE_BIT_AUDIO_3D_SAMPLE_PACKET = 0x0C, + HDMI_MULTI_STREAM_AUDIO_SAMPLE_PACKET = 0x0E, + HDMI_ONE_BIT_MULTI_STREAM_AUDIO_SAMPLE_PACKET = 0x0F, +}; + +enum HdmiDfmPixelFormatMode { + HDMI_DFM_PIXEL_FORMAT_MODE_0 = 0, + HDMI_DFM_PIXEL_FORMAT_MODE_1, + HDMI_DFM_PIXEL_FORMAT_MODE_2, + HDMI_DFM_PIXEL_FORMAT_MODE_3 +}; + +struct HdmiDfmInfo { + bool audioSupport; + bool videoSupport; + bool uncompressSupport; + bool isExtraMode; + bool canbeTrans; + uint32_t htotal; + uint32_t vtotal; + uint32_t bpp; /* Bits per Pixel */ + uint32_t cFrlSb; /* Total FRL Characters Per SuperBlock(include SSB/SR) */ + uint32_t overheadSb; + uint32_t overheadRs; + uint32_t overheadMap; + uint32_t overheadMin; + uint32_t overheadMax; + uint32_t lineMinTime; /* minimum Video Line period */ + uint32_t lineMaxTime; /* maximum Video Line period */ + uint32_t audioAp; /* the number of audio packets required to carry each sample */ + uint32_t audioRap; /* Average Audio Related Packet Rate */ + uint32_t avgAudioPacketsPerLine; /* Average Required Packets per line */ + uint32_t audioPacketsLine; /* Packets per Hblank that must be supportable. */ + uint32_t hblankAudioMin; /* */ + uint32_t cFrlFree; + uint32_t cFrlRcMargin; + uint32_t cFrlRcSavings; + uint32_t activeBytesPerLine; /* Video Bytes per line */ + uint32_t activeTbPerLine; /* Required Characters to carry Active Video per line */ + uint32_t hblankTbPerLine; /* Required Characters to carry H-Blank Video per line */ + uint32_t activeTimeRef; + uint32_t blankTimeRef; + uint32_t activeTimeMin; + uint32_t blankTimeMin; + int32_t tBorrow; + int32_t tbBorrow; + uint32_t cFrlActualPayload; + uint32_t utilization; + int32_t margin; + uint32_t avgTbRate; + uint64_t pixelClk; + uint64_t maxPixelClk; /* maximum legal pixel rate */ + uint64_t minPixelClk; /* minimum legal pixel rate */ + uint64_t maxBitRate; /* FRL max bit rate */ + uint64_t minBitRate; /* FRL min bit rate */ + uint64_t maxFrlCharRate; /* max FRL Character Rate */ + uint64_t minFrlCharRate; /* min FRL Character Rate */ + uint32_t maxFrlCharsPerLine; /* max FRL Characters per line Period */ + uint32_t minFrlCharsPerLine; /* min FRL Characters per line Period */ +}; + +struct HdmiDfmParam { + uint32_t hactive; + uint32_t vactive; + uint32_t hblank; + uint32_t vblank; + uint32_t hsync; + uint32_t hback; + uint32_t hfront; + uint32_t vsync; + uint32_t vback; + uint32_t vfront; + uint32_t vfreq; + uint32_t colorDepth; + uint32_t pixelFormat; /* 1:420, 2:422, 3:RGB444 */ + uint32_t laneNum; + uint32_t bitRate; + uint32_t audioRate; + uint32_t packetType; + uint32_t layout; + uint32_t acat; +}; + +uint32_t HdmiDfmGetPixelFormat(enum HdmiColorSpace colorSpace); +void HdmiDfmFillParam(struct HdmiDfmParam *param, struct HdmiVideoDefInfo *videoInfo, + struct HdmiAudioAttr *audioAttr, enum HdmiColorSpace colorSpace, enum HdmiDeepColor deepColor); +bool HdmiDfmFormatSupport(struct HdmiDfmParam *param); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_DFM_H */ diff --git a/support/platform/include/hdmi/hdmi_dispatch.h b/support/platform/include/hdmi/hdmi_dispatch.h new file mode 100644 index 0000000000000000000000000000000000000000..cc680781e217a0abbdedce06e71ee3da29c13283 --- /dev/null +++ b/support/platform/include/hdmi/hdmi_dispatch.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 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 HDMI_DISPATCH_H +#define HDMI_DISPATCH_H + +#include "hdf_base.h" + +#ifndef __USER__ +#include "devsvc_manager_clnt.h" +#endif + +#ifdef __USER__ +#include "hdf_io_service_if.h" +#endif + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +#ifndef __USER__ +int32_t HdmiIoDispatch(struct HdfDeviceIoClient *client, int cmd, struct HdfSBuf *data, struct HdfSBuf *reply); +#endif + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_NCTS_H */ diff --git a/support/platform/include/hdmi/hdmi_edid.h b/support/platform/include/hdmi/hdmi_edid.h new file mode 100644 index 0000000000000000000000000000000000000000..5678ab9771e4b6928544b9ed0c52e6a6b18b2020 --- /dev/null +++ b/support/platform/include/hdmi/hdmi_edid.h @@ -0,0 +1,643 @@ +/* + * Copyright (c) 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 HDMI_EDID_H +#define HDMI_EDID_H + +#include "hdf_base.h" +#include "hdmi_ddc.h" +#include "hdmi_if.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +#define VIDEO_LENGTH_4 4 +#define VIDEO_LENGTH_5 5 +#define VIDEO_LENGTH_16 16 +#define VIDEO_WIDTH_3 3 +#define VIDEO_WIDTH_4 4 +#define VIDEO_WIDTH_9 9 +#define VIDEO_WIDTH_10 10 + +#define UINT8_ARRAY_TElEMENT_0 0 +#define UINT8_ARRAY_TElEMENT_1 1 +#define UINT8_ARRAY_TElEMENT_2 2 +#define UINT8_ARRAY_TElEMENT_3 3 +#define UINT8_ARRAY_TElEMENT_4 4 +#define UINT8_ARRAY_TElEMENT_5 5 +#define UINT8_ARRAY_TElEMENT_6 6 +#define UINT8_ARRAY_TElEMENT_7 7 +#define UINT8_ARRAY_TElEMENT_8 8 +#define UINT8_ARRAY_TElEMENT_9 9 +#define UINT8_ARRAY_TElEMENT_10 10 +#define UINT8_ARRAY_TElEMENT_11 11 +#define UINT8_ARRAY_TElEMENT_12 12 +#define UINT8_ARRAY_TElEMENT_13 13 +#define UINT8_ARRAY_TElEMENT_14 14 +#define UINT8_ARRAY_TElEMENT_15 15 +#define UINT8_ARRAY_TElEMENT_16 16 +#define UINT8_ARRAY_TElEMENT_17 17 +#define UINT8_ARRAY_TElEMENT_18 18 +#define UINT8_ARRAY_TElEMENT_19 19 +#define UINT8_ARRAY_TElEMENT_20 20 + +/* (EDID)Extended Display Identification Data */ +#define HDMI_EDID_SINGLE_BLOCK_SIZE 128 +#define HDMI_EDID_MAX_BLOCK_NUM 4 +#define HDMI_EDID_TOTAL_SIZE (HDMI_EDID_SINGLE_BLOCK_SIZE * HDMI_EDID_MAX_BLOCK_NUM) +#define HDMI_EDID_MAX_VIC_COUNT 128 +#define HDMI_EDID_CHECK_SUM_MARK 0xff + +/* edid header */ +#define HDMI_EDID_BLOCK_HEADER_FIELD_LEN 8 + +/* edid vendor/product info */ +#define HDMI_EDID_MANUFACRURER_NAME_FIELD_LEN 2 +#define HDMI_EDID_MANUFACRURER_NAME_MAX_LEN 4 +#define HDMI_EDID_MANUFACRURER_NAME_CHAR_MARK 0x1F /* 5 bits */ +#define HDMI_EDID_MANUFACRURER_NAME_CHAR_SHIFT 5 +#define HDMI_EDID_MANUFACRURER_NAME_LOW_INVALID 0 +#define HDMI_EDID_MANUFACRURER_NAME_HIGH_INVALID 27 +#define HDMI_EDID_MANUFACRURER_NAME_SHIFT 8 +#define HDMI_EDID_PRODUCT_CODE_FIELD_LEN 2 +#define HDMI_EDID_PRODUCT_CODE_SHIFT 8 +#define HDMI_EDID_SERIAL_NUMBER_FIELD_LEN 4 +#define HDMI_EDID_SERIAL_NUMBER_SHIFT 8 +#define HDMI_EDID_YEAR_BASE 1990 + +struct HdmiEdidVendorInfo { + char mfrName[HDMI_EDID_MANUFACRURER_NAME_MAX_LEN]; + uint16_t productCode; + uint32_t serialNumber; + uint8_t week; + uint8_t year; +}; + +#define HDMI_EDID_VERSION_NUM 1 +#define HDMI_EDID_REVISION_NUM 3 + +/* edid version info */ +struct HdmiEdidVersionInfo { + uint8_t version; + uint8_t revision; +}; + +/* edid basic display parameters and features */ +struct HdmiEdidBasicDispParamInfo { + uint8_t width; /* unit: cm */ + uint8_t height; /* unit: cm */ +}; + +/* edid color characteristics */ +#define HDMI_EDID_COLOR_LOW_BITS_MARK 0x03 +#define HDMI_EDID_COLOR_RED_X_LOW_OFFSET 6 +#define HDMI_EDID_COLOR_RED_Y_LOW_OFFSET 4 +#define HDMI_EDID_COLOR_GREEN_X_LOW_OFFSET 2 +#define HDMI_EDID_COLOR_BLUE_X_LOW_OFFSET 6 +#define HDMI_EDID_COLOR_BLUE_Y_LOW_OFFSET 4 +#define HDMI_EDID_COLOR_WHITE_X_LOW_OFFSET 2 +#define HDMI_EDID_COLOR_HIGH_OFFSET 2 + +struct HdmiEdidColorInfo { + uint16_t redX; + uint16_t redY; + uint16_t greenX; + uint16_t greenY; + uint16_t blueX; + uint16_t blueY; + uint16_t whiteX; + uint16_t whiteY; +}; + +/* edid established timings */ +#define HDMI_EDID_ESTABLISHED_TIMINGS_FIELD_LEN 3 + +enum HdmiEdidEstablishTiming { + HDMI_EDID_ESTABLISHED_TIMING_VESA_800X600_60 = 0, + HDMI_EDID_ESTABLISHED_TIMING_VESA_800X600_56 = 1, + HDMI_EDID_ESTABLISHED_TIMING_VESA_640X480_75 = 2, + HDMI_EDID_ESTABLISHED_TIMING_VESA_640X480_72 = 3, + HDMI_EDID_ESTABLISHED_TIMING_640X480_67 = 4, + HDMI_EDID_ESTABLISHED_TIMING_VGA_640X480_60 = 5, + HDMI_EDID_ESTABLISHED_TIMING_XGA_720X400_88 = 6, + HDMI_EDID_ESTABLISHED_TIMING_VGA_720X400_70 = 7, + HDMI_EDID_ESTABLISHED_TIMING_VESA_1280X1024_75 = 8, + HDMI_EDID_ESTABLISHED_TIMING_VESA_1024X768_75 = 9, + HDMI_EDID_ESTABLISHED_TIMING_VESA_1024X768_70 = 10, + HDMI_EDID_ESTABLISHED_TIMING_VESA_1024X768_60 = 11, + HDMI_EDID_ESTABLISHED_TIMING_1024X768_87 = 12, + HDMI_EDID_ESTABLISHED_TIMING_832X624_75 = 13, + HDMI_EDID_ESTABLISHED_TIMING_VESA_800X600_75 = 14, + HDMI_EDID_ESTABLISHED_TIMING_VESA_800X600_72 = 15, + HDMI_EDID_ESTABLISHED_TIMING_VESA_1152X870_75 = 16, + HDMI_EDID_ESTABLISHED_TIMING_BUTT, +}; + +struct HdmiEdidEstablishedTimingsInfo { + uint32_t estTimingsNum; + uint32_t estTimings[HDMI_EDID_ESTABLISHED_TIMING_BUTT]; +}; + +/* edid standard timing */ +#define HDMI_EDID_STANDARD_TIMING_FIELD_LEN 16 +#define HDMI_EDID_STANDARD_TIMING_COUNT 8 +#define HDMI_EDID_PER_STANDARD_TIMING_BYTE_NUM 2 +#define HDMI_EDID_STANDARD_TIMING_UNUSED_FLAG 0x01 +#define HDMI_EDID_STANDARD_TIMING_HORIZ_PIXEL_BASE 31 +#define HDMI_EDID_STANDARD_TIMING_HORIZ_PIXEL_FACTOR 8 +#define HDMI_EDID_STANDARD_TIMING_REFRESH_RATE_BASE 60 +#define HDMI_EDID_STANDARD_TIMING_REFRESH_RATE_MARK 0x3F + +#define HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_MARK 0xC0 +#define HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_SHIFT 6 + +enum HdmiEdidStdTimingAspectRate { + HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_16_10 = 0, + HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_5_4 = 1, + HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_4_3 = 2, + HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_16_9 = 3, +}; + +struct HdmiEdidStdTimingInfo { + uint32_t horizPixel; + uint32_t vertPixel; + uint32_t refreshRate; +}; + +/* edid detailed timing descriptor */ +#define HDMI_EDID_DETAILED_TIMING_DESCRIPTOR_FIELD_LEN 18 +#define HDMI_EDID_DETAILED_TIMING_PIXEL_CLK_FIELD_LEN 2 +#define HDMI_EDID_DETAILED_TIMING_PIXEL_CLK_KHZ_FACTOR 10 +#define HDMI_EDID_DETAILED_TIMING_UPPER_4BITS_MARK 0xF0 +#define HDMI_EDID_DETAILED_TIMING_LOWER_4BITS_MARK 0x0F +#define HDMI_EDID_DETAILED_TIMING_HS_OFFSET_MARK 0xC0 +#define HDMI_EDID_DETAILED_TIMING_HS_PULSE_WIDTH_MARK 0x30 +#define HDMI_EDID_DETAILED_TIMING_VS_OFFSET_MARK 0x0C +#define HDMI_EDID_DETAILED_TIMING_VS_PULSE_WIDTH_MARK 0x03 +#define HDMI_EDID_DETAILED_TIMING_STEREO_MARK 0x60 +#define HDMI_EDID_DETAILED_TIMING_STEREO_SEQUENTIAL_R 0x02 +#define HDMI_EDID_DETAILED_TIMING_STEREO_SEQUENTIAL_L 0x04 +#define HDMI_EDID_DETAILED_TIMING_STEREO_INTERLEAVED_2R 0x03 +#define HDMI_EDID_DETAILED_TIMING_STEREO_INTERLEAVED_2L 0x05 +#define HDMI_EDID_DETAILED_TIMING_STEREO_INTERLEAVED_4 0x06 +#define HDMI_EDID_DETAILED_TIMING_STEREO_INTERLEAVED_SBS 0x07 +#define HDMI_EDID_DETAILED_TIMING_SYNC_SIGNAL_TYPE_MARK 0x0E +#define HDMI_EDID_DETAILED_TIMING_SYNC_DCS_WS_0 0x00 +#define HDMI_EDID_DETAILED_TIMING_SYNC_DCS_WS_1 0x01 +#define HDMI_EDID_DETAILED_TIMING_SYNC_DCS_DS_2 0x02 +#define HDMI_EDID_DETAILED_TIMING_SYNC_DCS_DS_3 0x03 +#define HDMI_EDID_DETAILED_TIMING_SYNC_DSS_VN_HN_4 0x04 +#define HDMI_EDID_DETAILED_TIMING_SYNC_DSS_VN_HP_5 0x05 +#define HDMI_EDID_DETAILED_TIMING_SYNC_DSS_VP_HN_6 0x06 +#define HDMI_EDID_DETAILED_TIMING_SYNC_DSS_VP_HP_7 0x07 +#define HDMI_EDID_MAX_DETAILED_TIMING_COUNT 10 + +struct HdmiEdidDetailedTimingBlockInfo { + uint8_t pixelClk[HDMI_EDID_DETAILED_TIMING_PIXEL_CLK_FIELD_LEN]; + uint8_t hActive; + uint8_t hBlanking; + uint8_t hActiveBlanking; + uint8_t vActive; + uint8_t vBlanking; + uint8_t vActiveBlanking; + uint8_t hSyncOffset; + uint8_t hSyncPulseWidth; + uint8_t vsOffesetPulseWidth; + uint8_t hsOffsetVsOffset; + uint8_t hImageSize; + uint8_t vImageSize; + uint8_t hvImageSize; + uint8_t hBorder; + uint8_t vBorder; + uint8_t flags; +}; + +struct HdmiEdidPreferredTimingInfo { + uint32_t pixelClk; /* unit: KHz */ + uint32_t hActive; /* horizontal active area */ + uint32_t hBackBlank; /* horizontal back blank */ + uint32_t hFrontBlank; /* horizontal front blank */ + uint32_t hSyncPluseWidth; /* horizontal sync pluse width */ + uint32_t vActive; /* vertical active area */ + uint32_t vBackBlank; /* vertical back blank */ + uint32_t vFrontBlank; /* vertical front blank */ + uint32_t vSyncPluseWidth; /* vertical sync pluse width */ + uint32_t imageWidth; /* image width */ + uint32_t imageHeight; /* image height */ + bool interlaceFlag; /* interlace flag */ + bool idv; /* flag of data valid signal is needed flip */ + bool ihs; /* flag of horizontal sync pulse is needed flip */ + bool ivs; /* flag of vertical sync pulse is needed flip */ +}; + + +/* edid monitor descriptor */ +#define HDMI_EDID_MONITOR_FLAGS_FIELD_LEN 3 +#define HDMI_EDID_MONITOR_DATA_FIELD_LEN 13 +#define HDMI_EDID_MAX_SINK_NAME_COUNT 14 + +enum HdmiEdidMonitorDataType { + HDMI_EDID_MONITOR_DATA_NAME = 0xFC, + HDMI_EDID_MONITOR_DATA_RANGE_LIMIT = 0xFD, + HDMI_EDID_MONITOR_DATA_STRING = 0xFE, + HDMI_EDID_MONITOR_DATA_SERIAL_NUMBER = 0xFF, +}; + +struct HdmiEdidMonitorBlockInfo { + uint8_t flags[HDMI_EDID_MONITOR_FLAGS_FIELD_LEN]; + uint8_t dataTag; + uint8_t flag; + uint8_t data[HDMI_EDID_MONITOR_DATA_FIELD_LEN]; +}; + +/* edid extension flag and checksum */ +#define HDMI_EDID_EXTENSION_BLOCK_ADDR 0x7E +#define HDMI_EDID_CHECKSUM_ADDR 0x7F + +struct HdmiEdidFirstBlockInfo { + uint8_t header[HDMI_EDID_BLOCK_HEADER_FIELD_LEN]; + uint8_t vendorName[HDMI_EDID_MANUFACRURER_NAME_FIELD_LEN]; + uint8_t productCode[HDMI_EDID_PRODUCT_CODE_FIELD_LEN]; + uint8_t serialNumber[HDMI_EDID_SERIAL_NUMBER_FIELD_LEN]; + uint8_t week; /* + * The designated values for this field range from 1 to 53. If this field is unused, the value + * should be set to 0. If the next field is used for Model Year, then 0xFF should be set. + */ + uint8_t year; /* This value is determined by the actual year of production minus 1990. */ + uint8_t version; + uint8_t revision; + uint8_t videoInput; + uint8_t width; /* unit: cm */ + uint8_t height; /* unit: cm */ + uint8_t gamma; /* Display Transfer Characteristics */ + uint8_t features; + uint8_t redGreenLow; + uint8_t blueWhiteLow; + uint8_t redX; + uint8_t redY; + uint8_t greenX; + uint8_t greenY; + uint8_t blueX; + uint8_t blueY; + uint8_t whiteX; + uint8_t whiteY; + uint8_t estTimings[HDMI_EDID_ESTABLISHED_TIMINGS_FIELD_LEN]; + uint8_t stdTiming[HDMI_EDID_STANDARD_TIMING_FIELD_LEN]; + uint8_t detailedTiming1[HDMI_EDID_DETAILED_TIMING_DESCRIPTOR_FIELD_LEN]; + uint8_t detailedTiming2[HDMI_EDID_DETAILED_TIMING_DESCRIPTOR_FIELD_LEN]; + uint8_t detailedTiming3[HDMI_EDID_DETAILED_TIMING_DESCRIPTOR_FIELD_LEN]; + uint8_t detailedTiming4[HDMI_EDID_DETAILED_TIMING_DESCRIPTOR_FIELD_LEN]; + uint8_t extensionFlag; + uint8_t checksum; +}; + +/* edid extension block */ +#define HDMI_EDID_CTA_EXTENSION_TAG 0x02 +#define HDMI_EDID_CTA_EXTENSION3_REVISION 0x03 +#define HDMI_EDID_EXTENSION_DATA_BLOCK_LEN_MARK 0x1F +#define HDMI_EDID_EXTENSION_DATA_BLOCK_TAG_CODE_MARK 0xE0 +#define HDMI_EDID_EXTENSION_DATA_BLOCK_TAG_CODE_SHIFT 5 +#define HDMI_EDID_EXTENSION_BLOCK_OFFSET 4 +#define HDMI_EDID_EXTENSION_D_INVALID_MIN_VAL 4 + +enum HdmiEdidExtDataBlockType { + HDMI_EDID_NULL_DATA_BLOCK = 0, + HDMI_EDID_AUDIO_DATA_BLOCK = 1, + HDMI_EDID_VIDEO_DATA_BLOCK = 2, + HDMI_EDID_VENDOR_SPECIFIC_DATA_BLOCK = 3, + HDMI_EDID_SPEAKER_ALLOCATION_DATA_BLOCK = 4, + HDMI_EDID_VESA_DTC_DATA_BLOCK = 5, /* VESA Display Transfer Characteristic Data Block */ + HDMI_EDID_USE_EXT_DATA_BLOCK = 7, /* Use Extended Tag */ +}; + +struct HdmiEdidColorSpace { + bool rgb444; + bool ycbcr422; + bool ycbcr444; + bool ycbcr420; +}; + +/* edid extension block: Audio Data Block */ +#define HDMI_EDID_EXTENSION_SHORT_AUDIO_DESCRIPTOR_LEN 3 +#define HDMI_EDID_EXTENSION_MAX_SHORT_AUDIO_DESCRIPTOR_NUM 10 +#define HDMI_EDID_EXTENSION_AUDIO_FORMAT_CODE_MARK 0x78 +#define HDMI_EDID_EXTENSION_AUDIO_FORMAT_CODE_SHIFT 3 +#define HDMI_EDID_EXTENSION_AUDIO_MAX_CHANNEL_MARK 0x07 +#define HDMI_EDID_EXTENSION_AUDIO_MAX_SAMPLE_RATE_NUM 8 +#define HDMI_EDID_EXTENSION_AUDIO_MAX_BIT_DEPTH_NUM 6 +#define HDMI_EDID_EXTENSION_AUDIO_BIT_RATE_FACTOR 8 +#define HDMI_EDID_EXTENSION_AUDIO_CAP_COUNT 16 + +struct HdmiEdidAudioInfo { + enum HdmiAudioCodingType formatCode; + uint32_t sampleRateNum; + enum HdmiSampleRate sampleRate[HDMI_EDID_EXTENSION_AUDIO_MAX_SAMPLE_RATE_NUM]; + uint32_t bitDepthNum; + enum HdmiAudioBitDepth bitDepth[HDMI_EDID_EXTENSION_AUDIO_MAX_BIT_DEPTH_NUM]; + uint8_t channels; + uint32_t maxBitRate; /* unit: KHz */ +}; + +/* edid extension block: Video Data Block */ +#define HDMI_EDID_EXTENSION_VIC_NATIVE_MAX 64 +#define HDMI_EDID_EXTENSION_VIC_LOWER7_MARK 0x7F +#define HDMI_EDID_EXTENSION_MAX_VIC_COUNT 128 +#define HDMI_EDID_EXTENSION_VIC_INVALID_LOW 128 +#define HDMI_EDID_EXTENSION_VIC_INVALID_HIGH 192 + +/* + * Each supported Video Format is represented by a Short Video Descriptor (SVD) containing + * a Video Identification Code (VIC) and, in the case of VICs 1 through 64, a Native Video Format indicator. + */ +struct HdmiEdidVideoInfo { + uint32_t vicNum; + uint32_t vic[HDMI_EDID_EXTENSION_MAX_VIC_COUNT]; + uint32_t nativeFormat; +}; + +/* edid extension block: (VSDB)Vendor-Specific Data Block */ +#define HDMI_EDID_EXTENSION_VSDB_LEN 3 +#define HDMI_EDID_EXTENSION_VSDB_IEEE_1ST 0x03 +#define HDMI_EDID_EXTENSION_VSDB_IEEE_2ND 0x0C +#define HDMI_EDID_EXTENSION_VSDB_IEEE_3RD 0x00 +#define HDMI_EDID_EXTENSION_VSDB_CEC_INVALID_ADDR 0xF +#define HDMI_EDID_EXTENSION_MAX_HDMI14_TMDS_RATE 340 /* unit: Mcsc */ +#define HDMI_EDID_EXTENSION_TMDS_FACTOR 5 /* unit: MHz */ +#define HDMI_EDID_EXTENSION_VSDB_3D_LEN_MARK 0x1F +#define HDMI_EDID_EXTENSION_VSDB_VIC_LEN_MARK 0xE0 +#define HDMI_EDID_EXTENSION_VSDB_VIC_LEN_SHIFT 5 +#define HDMI_EDID_EXTENSION_VSDB_3D_MULTI_PRESENT_MARK 0x60 +#define HDMI_EDID_EXTENSION_VSDB_3D_MULTI_PRESENT_SHIFT 5 +#define HDMI_EDID_EXTENSION_VSDB_3D_STR_INVALID_MARK 0x03 + +struct HdmiEdidVsdbCecAddr { + bool addrValid; + uint8_t phyAddrA; + uint8_t phyAddrB; + uint8_t phyAddrC; + uint8_t phyAddrD; +}; + +struct HdmiEdidDeepColor { + bool dcY444; + bool dc30bit; + bool dc36bit; + bool dc48bit; +}; + +struct HdmiEdidExtVsdbInfo { + struct HdmiEdidVsdbCecAddr cecAddr; + struct HdmiEdidDeepColor deepColor; + bool supportAi; + bool supportDviDual; + bool latencyFieldsPresent; + bool iLatencyFieldsPresent; + bool hdmiVideoPresent; + uint8_t videoLatency; + uint8_t audioLatency; + uint8_t interlacedVideoLatency; + uint8_t interlacedAudioLatency; + bool _3dPresent; + uint8_t _3dMultiPresent; + bool support3dType[HDMI_VS_VIDEO_3D_BUTT]; +}; + +/* edid extension block: (HF-VSDB)HDMI Forum Vendor-Specific Data Block */ +#define HDMI_EDID_EXTENSION_HFVSDB_IEEE_1ST 0xD8 +#define HDMI_EDID_EXTENSION_HFVSDB_IEEE_2ND 0x5D +#define HDMI_EDID_EXTENSION_HFVSDB_IEEE_3RD 0xC4 +#define HDMI_EDID_EXTENSION_HFVSDB_VERSION 0x01 +#define HDMI_EDID_EXTENSION_HFVSDB_MIN_INVALID_LEN 7 +#define HDMI_EDID_EXTENSION_HFVSDB_MAX_INVALID_LEN 31 + +/* deep color Y420(4:2:0) */ +struct HdmiEdidExtHfVsdbDeepColor { + bool dc30bit; + bool dc36bit; + bool dc48bit; +}; + +/* dsc(Display Stream Compression ) */ +struct HdmiEdidExtHfVsdbDscInfo { + bool dsc1p2; + bool dscNative420; + bool dscAllBpp; + bool dsc10bpc; + bool dsc20bpc; + bool dsc16bpc; + uint8_t dscMaxSlices; + uint8_t dscMaxFrlRate; + uint8_t dscTotalChunkKBytes; +}; + +struct HdmiEdidExtHfVsdbInfo { + bool scdcPresent; + bool rrCapable; /* read request cap. */ + bool lte340McscScramble; + bool independentView; + bool dualView; + bool _3dOsdDisparity; + struct HdmiEdidExtHfVsdbDeepColor dc; + /* hdmi 2.1 */ + uint8_t maxFrlRate; + bool fapaStartLocation; + bool allm; + bool fva; + bool cnmVrr; + bool cinemaVrr; + bool mDelta; + uint8_t vrrMin; + uint16_t vrrMax; + struct HdmiEdidExtHfVsdbDscInfo dscInfo; +}; + +/* edid extension block: Speaker Allocation Data Block */ +#define HDMI_EDID_EXTENSION_SADB_MIN_INVALID_LEN 2 + +enum HdmiEdidAudioSpeaker { + HDMI_EDID_AUDIO_SPEAKER_FL_FR = 0, + HDMI_EDID_AUDIO_SPEAKER_LFE = 1, + HDMI_EDID_AUDIO_SPEAKER_FC = 2, + HDMI_EDID_AUDIO_SPEAKER_BL_BR = 3, + HDMI_EDID_AUDIO_SPEAKER_BC = 4, + HDMI_EDID_AUDIO_SPEAKER_FLC_FRC = 5, + HDMI_EDID_AUDIO_SPEAKER_RLC_RRC = 6, + HDMI_EDID_AUDIO_SPEAKER_FLW_FRW = 7, + HDMI_EDID_AUDIO_SPEAKER_TPFL_TPFH = 8, + HDMI_EDID_AUDIO_SPEAKER_TPC = 9, + HDMI_EDID_AUDIO_SPEAKER_TPFC = 10, + HDMI_EDID_AUDIO_SPEAKER_BUTT, +}; + +/* + * If the Tag Code is 7 (Use Extended Tag) then the second byte of the data block contains the Extended + * Tag Code, which indicates the actual type of the data block. + */ +enum HdmiEdidExtExtenedDataBlockType { + HDMI_EDID_EXT_VCDB = 0, /* Video Capability Data Block */ + HDMI_EDID_EXT_VSVDB = 1, /* Vendor-Specific Video Data Block */ + HDMI_EDID_EXT_VESA_DDDB = 2, /* VESA Display Device Data Block */ + HDMI_EDID_EXT_VESA_VTBE = 3, /* VESA Video Timing Block Extension */ + HDMI_EDID_EXT_CDB = 5, /* Colorimetry Data Block */ + HDMI_EDID_EXT_HDR_SMDB = 6, /* HDR Static Metadata Data Block */ + HDMI_EDID_EXT_HDR_DMDB = 7, /* HDR Dynamic Metadata Data Block */ + HDMI_EDID_EXT_VFPDB = 13, /* Video Format Preference Data Block */ + HDMI_EDID_EXT_YCBCR420_VDB = 14, /* YCBCR 4:2:0 Video Data Block */ + HDMI_EDID_EXT_YCBCR420_CMDB = 15, /* YCBCR 4:2:0 Capability Map Data Block */ + HDMI_EDID_EXT_VSADB = 17, /* Vendor-Specific Audio Data Block */ + HDMI_EDID_EXT_RCDB = 19, /* Room Configuration Data Block */ + HDMI_EDID_EXT_SLDB = 20, /* Speaker Location Data Block */ + HDMI_EDID_EXT_INFOFRAME_DB = 32, /* InfoFrame Data Block (includes one or more Short InfoFrame Descriptors) */ + HDMI_EDID_EXT_BUTT, +}; + +/* edid extension block: Colorimetry Data Block */ +#define HDMI_EDID_CDB_LEN 3 + +struct HdmiEdidColorimetry { + bool xvYcc601; + bool xvYcc709; + bool sYcc601; + bool opYcc601; + bool opRgb; + bool bt2020cYcc; + bool bt2020Ycc; + bool bt2020Rgb; + bool dciP3; + uint8_t md; +}; + +/* edid extension block: Vendor-Specific Video Data Block */ +#define HDMI_EDID_VSVDB_DOLBY_OUI 0x00D046 +#define HDMI_EDID_VSVDB_DOLBY_VERSION_0 0x00 +#define HDMI_EDID_VSVDB_DOLBY_VERSION_1 0x01 +#define HDMI_EDID_VSVDB_DOLBY_VERSION_0_LEN 27 +#define HDMI_EDID_VSVDB_DOLBY_VERSION_1_LEN 14 +#define HDMI_EDID_VSVDB_DOLBY_LOWER_2BIT_MARK 0x03 +#define HDMI_EDID_VSVDB_DOLBY_LOWER_3BIT_MARK 0x07 +#define HDMI_EDID_VSVDB_DOLBY_LOWER_7BIT_MARK 0x7F +#define HDMI_EDID_VSVDB_DOLBY_VERSION_MARK 0xE0 +#define HDMI_EDID_VSVDB_DOLBY_VERSION_SHIFT 5 +#define HDMI_EDID_VSVDB_DOLBY_DM_VER_MARK 0x1C +#define HDMI_EDID_VSVDB_DOLBY_DM_VER_SHIFT 2 + +struct HdmiEdidVsvdbDolbyCap { + uint32_t oui; + uint8_t version; + bool yuv422; + bool b2160p60; /* capable of processing a max timing 3840X2160p60. */ + bool globalDimming; + uint16_t redX; + uint16_t redY; + uint16_t greenX; + uint16_t greenY; + uint16_t blueX; + uint16_t blueY; + uint16_t whiteX; /* only version0 support */ + uint16_t whiteY; /* only version0 support */ + uint16_t minLuminance; + uint16_t maxLuminance; + uint8_t dMajorVer; /* only version0 support */ + uint8_t dMinorVer; /* only version0 support */ + bool colorimetry; /* only version1 support */ + uint8_t dmVer; /* only version1 support */ +}; + +/* edid extension block: Video Capability Data Block */ +#define HDMI_EDID_VCDB_LEN 2 + +struct HdmiEdidVideoCapability { + bool qy; /* Quantization Range(Applies to YCC only) */ + bool qs; /* Quantization Range Selectable(Applies to RGB only) */ +}; + +/* edid extension block: HDR Static Metadata Data Block */ +#define HDMI_EDID_HDR_SMDB_MIN_LEN 3 + +/* EOTF(Electro-Optical Transfer Functions) */ +struct HdmiEdidHdrSmdbEotf { + bool sdr; /* Traditional gamma - SDR Luminance Range */ + bool hdr; /* Traditional gamma - HDR Luminance Range */ + bool smpteSt2048; /* SMPTE ST 2084 */ + bool hlg; /* Hybrid Log-Gamma (HLG) based on Recommendation ITU-R BT.2100-0 */ +}; + +struct HdmiEdidHdrCap { + struct HdmiEdidHdrSmdbEotf eotf; + bool smType1; /* Static Metadata Type 1 */ + uint8_t maxLuminancedata; /* Desired Content Max Luminance data */ + uint8_t maxFrameAverageLuminanceData; /* Desired Content Max Frame-average Luminance data */ + uint8_t minLuminanceData; /* Desired Content Min Luminance data */ +}; + +/* edid extension block: YCBCR 4:2:0 Capability Map Data Block */ +struct HdmiEdidYcbcr420Cap { + uint32_t onlySupportY420VicNum; + uint32_t onlySupportY420Format[HDMI_EDID_EXTENSION_MAX_VIC_COUNT]; + uint32_t SupportY420VicNum; + uint32_t SupportY420Format[HDMI_EDID_EXTENSION_MAX_VIC_COUNT]; +}; + +/* sink device cap */ +struct HdmiSinkDeviceCapability { + uint8_t extBlockNum; + struct HdmiEdidVendorInfo vendorInfo; + struct HdmiEdidVersionInfo verInfo; + char sinkDeviceName[HDMI_EDID_MAX_SINK_NAME_COUNT]; + struct HdmiEdidBasicDispParamInfo disp; + struct HdmiEdidEstablishedTimingsInfo establishedTimingsInfo; + struct HdmiEdidStdTimingInfo stdTimingsInfo[HDMI_EDID_STANDARD_TIMING_COUNT]; + struct HdmiEdidColorInfo colorInfo; + struct HdmiEdidColorSpace colorSpace; + uint32_t preTimingCnt; + struct HdmiEdidPreferredTimingInfo preTimingInfo[HDMI_EDID_MAX_DETAILED_TIMING_COUNT]; + uint32_t audioInfoCnt; + struct HdmiEdidAudioInfo audioInfo[HDMI_EDID_EXTENSION_AUDIO_CAP_COUNT]; + struct HdmiEdidVideoInfo videoInfo; + uint32_t maxTmdsClk; + bool supportHdmi14; + bool supportHdmi20; + bool supportAudio; + struct HdmiEdidExtVsdbInfo vsdbInfo; + struct HdmiEdidExtHfVsdbInfo hfVsdbInfo; + bool supportAudioSpeaker[HDMI_EDID_AUDIO_SPEAKER_BUTT]; + struct HdmiEdidColorimetry colorimetry; + struct HdmiEdidVideoCapability videoCap; + struct HdmiEdidYcbcr420Cap y420Cap; + struct HdmiEdidHdrCap hdrCap; + struct HdmiEdidVsvdbDolbyCap dolbyCap; +}; + +/* + * EDID(Extended Display Identification Data). + * The Source read the Sink's EDID in order to discover the Sink's configuration and/or capabilities. + */ +struct HdmiEdid { + bool edidPhase; + uint32_t rawLen; + uint8_t raw[HDMI_EDID_TOTAL_SIZE]; + struct HdmiSinkDeviceCapability sinkCap; +}; + +typedef int32_t (*HdmiEdidPhaseFunc)(struct HdmiEdid *edid); + +int32_t HdmiEdidReset(struct HdmiEdid *edid); +int32_t HdmiEdidPhase(struct HdmiEdid *edid); +int32_t HdmiEdidGetRaw(struct HdmiEdid *edid, uint8_t *raw, uint32_t len); +int32_t HdmiEdidRawDataRead(struct HdmiEdid *edid, struct HdmiDdc *ddc); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_EDID_H */ diff --git a/support/platform/include/hdmi/hdmi_event.h b/support/platform/include/hdmi/hdmi_event.h new file mode 100644 index 0000000000000000000000000000000000000000..0f66458fd24e729908d198b2d4b437d1f5ad3ee5 --- /dev/null +++ b/support/platform/include/hdmi/hdmi_event.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 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 HDMI_EVENT_H +#define HDMI_EVENT_H + +#include "hdf_base.h" +#include "hdmi_if.h" +#include "platform_core.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/* HPD(hot plug detect) */ +#define HDMI_READ_HPD_STATUS_DELAY 110 /* ms */ + +enum HdmiEventType { + HDMI_EVENT_HOTPLUG = 0, + HDMI_EVENT_HOTUNPLUG = 1, + HDMI_EVENT_DETECT_SINK = 2, + HDMI_EVENT_CEC_MSG = 3, + HDMI_EVENT_HDCP_MSG = 4, + HDMI_EVENT_ZERO_DRMIF_TIMEOUT = 5, + HDMI_EVENT_SWITCH_TO_HDRMODE_TIMEOUT = 6, + HDMI_EVENT_BUTT, +}; + +struct HdmiEventMsg { + struct PlatformMsg msg; + void *priv; +}; + +struct HdmiEvent { + bool plugged; + bool hpdDetected; + struct HdmiHpdCallbackInfo callback; +}; + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_EVENT_H */ diff --git a/support/platform/include/hdmi/hdmi_frl.h b/support/platform/include/hdmi/hdmi_frl.h new file mode 100644 index 0000000000000000000000000000000000000000..4c81381f1622d0cdfdc433b844b3eb5f6096bfe3 --- /dev/null +++ b/support/platform/include/hdmi/hdmi_frl.h @@ -0,0 +1,212 @@ +/* + * Copyright (c) 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 HDMI_FRL_H +#define HDMI_FRL_H + +#include "hdf_base.h" +#include "osal_time.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/* FRL(Fix Rate Link) */ +enum HdmiFrlMode { + HDMI_FRL_MODE_TMDS = 0, + HDMI_FRL_MODE_FRL = 1, + HDMI_FRL_MODE_BUTT, +}; + +#define HDMI_FRL_3_LANES 3 +#define HDMI_FRL_4_LANES 4 + +enum HdmiFrlWorkMode { + HDMI_FRL_WORK_MODE_NONE = 0, + HDMI_FRL_WORK_MODE_3L3G = 1, /* 3 lanes, 3Gbps per lane */ + HDMI_FRL_WORK_MODE_3L6G = 2, /* 3 lanes, 6Gbps per lane */ + HDMI_FRL_WORK_MODE_4L6G = 3, /* 4 lanes, 6Gbps per lane */ + HDMI_FRL_WORK_MODE_4L8G = 4, /* 4 lanes, 8Gbps per lane */ + HDMI_FRL_WORK_MODE_4L10G = 5, /* 4 lanes, 10Gbps per lane */ + HDMI_FRL_WORK_MODE_4L12G = 6, /* 4 lanes, 12Gbps per lane */ + HDMI_FRL_WORK_MODE_BUTT, +}; + +enum HdmiFrlBitRate { + HDMI_FRL_BIT_RATE_3 = 3, + HDMI_FRL_BIT_RATE_6 = 6, + HDMI_FRL_BIT_RATE_8 = 8, + HDMI_FRL_BIT_RATE_10 = 10, + HDMI_FRL_BIT_RATE_12 = 12, + HDMI_FRL_BIT_RATE_BUTT, +}; + +enum HdmiFrlTrainPattern { + HDMI_FRL_TRAIN_PATTERN_NULL = 0, + HDMI_FRL_TRAIN_PATTERN_LP1 = 1, + HDMI_FRL_TRAIN_PATTERN_LP2 = 2, + HDMI_FRL_TRAIN_PATTERN_LP3 = 3, + HDMI_FRL_TRAIN_PATTERN_LP4 = 4, + HDMI_FRL_TRAIN_PATTERN_LP5 = 5, + HDMI_FRL_TRAIN_PATTERN_LP6 = 6, + HDMI_FRL_TRAIN_PATTERN_LP7 = 7, + HDMI_FRL_TRAIN_PATTERN_LP8 = 8, + HDMI_FRL_TRAIN_PATTERN_REV = 9, + HDMI_FRL_TRAIN_PATTERN_0E = 14, + HDMI_FRL_TRAIN_PATTERN_0F = 15, + HDMI_FRL_TRAIN_PATTERN_BUTT, +}; + +enum HdmiFrlTrainStatus { + HDMI_FRL_TRAIN_STATUS_NULL = 0, + HDMI_FRL_TRAIN_STATUS_FAIL = 1, + HDMI_FRL_TRAIN_STATUS_SUCC = 2, + HDMI_FRL_TRAIN_STATUS_BUSY = 3, + HDMI_FRL_TRAIN_STATUS_BUTT, +}; + +enum HdmiFrlTrainingFailReason { + HDMI_FRL_TRAIN_FAIL_NORMAL, + HDMI_FRL_TRAIN_FAIL_FLT_TIMEOUT, + HDMI_FRL_TRAIN_FAIL_FLT_STEP_TIMEOUT, + HDMI_FRL_TRAIN_FAIL_RATE_CHANGE, + HDMI_FRL_TRAIN_FAIL_FFE_CHANGE, + HDMI_FRL_TRAIN_FAIL_BUTT +}; + +enum HdmiFrlTrainStep { + HDMI_FRL_TRAIN_STEP_READR_CHECK = 0, + HDMI_FRL_TRAIN_STEP_TRAIN_START = 1, + HDMI_FRL_TRAIN_STEP_RESULT_CHECK = 2, + HDMI_FRL_TRAIN_STEP_RATE_CHANGE = 3, + HDMI_FRL_TRAIN_STEP_RESULT_HANDLE = 4, + HDMI_FRL_TRAIN_STEP_RETRAIN_CHECK = 5, + HDMI_FRL_TRAIN_STEP_TRAIN_STOP = 6, + HDMI_FRL_TRAIN_STEP_BUTT, +}; + +enum HdmiFrlRateSelect { + HDMI_FRL_RATE_LITTLE = 0, + HDMI_FRL_RATE_BIG = 1, + HDMI_FRL_RATE_BUTT, +}; + +enum HdmiFrlPixelFormatMode { + HDMI_FRL_PIXEL_FORMAT_MODE_0 = 0, + HDMI_FRL_PIXEL_FORMAT_MODE_1 = 1, + HDMI_FRL_PIXEL_FORMAT_MODE_2 = 2, + HDMI_FRL_PIXEL_FORMAT_MODE_3 = 3, +}; + +enum HdmiFrlBypass { + HDMI_FRL_BYPASS_READ_CHECK = 0x01, + HDMI_FRL_BYPASS_RESULT_CHECK = 0x02, + HDMI_FRL_BYPASS_RETRAIN_CHECK = 0x04, +}; + +/* + * Feed Forward Equalizer(FFE) + * Tx terminal will use 0=TxFFE0 FFE in Link Training. If higher rate signal needs to be transmitted, + * Tx will decide higher FFE compensation through Link Training to ensure + * that video and audio data can be completely transmitted to the Sink terminal. + */ +enum HdmiFrlTxffeMode { + HDMI_FRL_TXFFE_MODE_0 = 0, + HDMI_FRL_TXFFE_MODE_1 = 1, + HDMI_FRL_TXFFE_MODE_2 = 2, + HDMI_FRL_TXFFE_MODE_3 = 3, + HDMI_FRL_TXFFE_MODE_BUTT, +}; + +enum HdmiFrlStrategyMode { + HDMI_FRL_STRATEGY_MODE_1, + HDMI_FRL_STRATEGY_MODE_2, + HDMI_FRL_STRATEGY_MODE_3, + HDMI_FRL_STRATEGY_MODE_BUTT +}; + +enum HdmiFrlStateMachineRunningState { + HDMI_FRL_STATE_MACHINE_NULL = 0, + HDMI_FRL_STATE_MACHINE_START = 1, + HDMI_FRL_STATE_MACHINE_STOP = 2, +}; + +struct HdmiFrlStateMachineInfo { + bool start; + enum HdmiFrlTrainStep trainingState; + enum HdmiFrlStateMachineRunningState machineState; + uint64_t startTime; /* ms */ + uint32_t waitReadyTime; /* ms */ + uint32_t waitHandleTime; /* ms */ + uint32_t waitRetrainTime; /* ms */ + uint32_t trainTimeout; /* ms */ + uint32_t timeoutCnt; +}; + +struct HdmiFrlInfo { + uint8_t curFrlRate; + uint8_t minFrlRate; + uint8_t maxFrlRate; + uint8_t preFrlRate; + uint32_t trainFailCnt; + uint32_t trainMaxFailTimes; + uint32_t tmdsClock; + enum HdmiFrlMode perMode; + enum HdmiFrlMode mode; + enum HdmiFrlStrategyMode strategy; + enum HdmiFrlRateSelect rateSelect; + bool scdc; + bool ctsMode; + bool start; + bool work; + struct HdmiFrlStateMachineInfo machineInfo; + uint32_t trainingFailCnt; + uint32_t trainingMaxFailTimes; +}; + +struct HdmiFrl { + struct HdmiFrlInfo info; + void *priv; +}; + +struct HdmiFrlAudioNctsConfig { + enum HdmiSampleRate sampleRate; + enum HdmiFrlMode mode; + uint8_t frlRate; + uint32_t pixelClk; + uint32_t n; + uint32_t cts; +}; + +struct HdmiFrlTrainConfig { + bool frlNoTimeout; + uint8_t frlRate; + uint8_t txffe; + uint32_t trainTimeout; +}; + +struct HdmiFrlTrainRslt { + enum HdmiFrlTrainStatus status; + enum HdmiFrlTrainPattern pattern[HDMI_FRL_4_LANES]; + enum HdmiFrlTrainingFailReason failReason; +}; + +void HdmiFrlEnable(struct HdmiFrl *frl, bool enable); +bool HdmiFrlSupport(struct HdmiFrl *frl); +int32_t HdmiFrlModeSelect(struct HdmiFrl *frl); +bool HdmiFrlModeChanged(struct HdmiFrl *frl); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_FRL_H */ diff --git a/support/platform/include/hdmi/hdmi_hdcp.h b/support/platform/include/hdmi/hdmi_hdcp.h new file mode 100644 index 0000000000000000000000000000000000000000..1af81e4524c9aff26dc9509e14735e7e63cbe6f1 --- /dev/null +++ b/support/platform/include/hdmi/hdmi_hdcp.h @@ -0,0 +1,214 @@ +/* + * Copyright (c) 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 HDMI_HDCP_H +#define HDMI_HDCP_H + +#include "hdf_base.h" +#include "osal_mutex.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/* HDCP(High-bandwidth Digital Content Protection) Sysytem. */ + +enum HdmiHdcpPortOffset { + /* HDCP 1.4 Spec */ + HDMI_HDCP_BKSV = 0x00, /* Rd, 5 bytes */ + HDMI_HDCP_RI = 0x08, /* Rd, 2 bytes */ + HDMI_HDCP_PJ = 0x0A, /* Rd, 1 byte */ + HDMI_HDCP_AKSV = 0x10, /* Wr, 5 bytes */ + HDMI_HDCP_AINFO = 0x15, /* Wr, 1 byte */ + HDMI_HDCP_AN = 0x18, /* Wr, 8 bytes */ + HDMI_HDCP_V_H0 = 0x20, /* Rd, 4 bytes */ + HDMI_HDCP_V_H1 = 0x24, /* Rd, 4 bytes */ + HDMI_HDCP_V_H2 = 0x28, /* Rd, 4 bytes */ + HDMI_HDCP_V_H3 = 0x2C, /* Rd, 4 bytes */ + HDMI_HDCP_V_H4 = 0x30, /* Rd, 4 bytes */ + HDMI_HDCP_BCAPS = 0x40, /* Rd, 1 byte */ + HDMI_HDCP_BSTATUS = 0x41, /* Rd, 2 bytes */ + HDMI_HDCP_KSV_FIFO = 0x43, /* Rd, 1 byte */ + + /* HDCP 2.2 Spec */ + HDMI_HDCP_HDCP2VERSION = 0x50, /* Rd, 1 byte */ + HDMI_HDCP_WRITE_MSG = 0x60, /* Wr, 1 byte */ + HDMI_HDCP_RXSTATUS = 0x70, /* Rd, 2 bytes */ + HDMI_HDCP_READ_MSG = 0x80, /* Rd, 1 byte */ +}; + +/* HDCP 2.2 Read/Write Message Id */ +enum HdmiHdcpMsgId { + HDMI_HDCP_MSG_AKE_INIT = 2, /* Write, 12 bytes */ + HDMI_HDCP_MSG_AKE_SEND_CERT = 3, /* Read, 534 bytes */ + HDMI_HDCP_MSG_AKE_NO_STORED_KM = 4, /* Write, 129 bytes */ + HDMI_HDCP_MSG_AKE_STORED_KM = 5, /* Write, 33 bytes */ + HDMI_HDCP_MSG_AKE_SEND_H_PRIME = 7, /* Read, 33 bytes */ + HDMI_HDCP_MSG_AKE_SEND_PAIRING_INFO = 8, /* Read, 17 bytes */ + HDMI_HDCP_MSG_LC_INIT = 9, /* Write, 9 bytes */ + HDMI_HDCP_MSG_LC_SEND_L_PRIME = 10, /* Read, 33 bytes */ + HDMI_HDCP_MSG_SKE_SEND_EKS = 11, /* Write, 25 bytes */ + HDMI_HDCP_MSG_REPEATER_AUTH_SEND_RCVID_LIST = 12, /* Read, 22 + 5 * device_count bytes */ + HDMI_HDCP_MSG_REPEATER_AUTH_SEND_ACK = 15, /* Write, 17 bytes */ + HDMI_HDCP_MSG_REPEATER_AUTH_STREAM_MANAGE = 16, /* Write, 6 + 2 * k bytes */ + HDMI_HDCP_MSG_REPEATER_AUTH_STREAM_READY = 17, /* Read, 33 bytes */ +}; + +enum HdmiHdcpRegOptType { + /* HDCP 1.4 Spec */ + HDMI_HDCP_OPT_WRITE_BKSV = 0x00, + HDMI_HDCP_OPT_WRITE_RI = 0x01, + HDMI_HDCP_OPT_WRITE_PJ = 0x02, + HDMI_HDCP_OPT_WRITE_V_H0 = 0x03, + HDMI_HDCP_OPT_WRITE_V_H1 = 0x04, + HDMI_HDCP_OPT_WRITE_V_H2 = 0x05, + HDMI_HDCP_OPT_WRITE_V_H3 = 0x06, + HDMI_HDCP_OPT_WRITE_V_H4 = 0x07, + HDMI_HDCP_OPT_WRITE_V_H_ALL = 0x08, + HDMI_HDCP_OPT_WRITE_BCAPS = 0x0C, + HDMI_HDCP_OPT_WRITE_BSTATUS = 0x0D, + HDMI_HDCP_OPT_WRITE_KSV_FIFO = 0x0E, + HDMI_HDCP_OPT_RESET_SHA = 0x0F, + HDMI_HDCP_OPT_CHECK_V = 0x10, + HDMI_HDCP_OPT_CHECK_R = 0x11, + HDMI_HDCP_OPT_AUTH_FAIL = 0x12, + HDMI_HDCP_OPT_AUTH_DONE = 0x13, + HDMI_HDCP_OPT_AUTH_CLOSE = 0x14, +}; + +#define HDMI_HDCP_MSG_BKSV_LEN 5 +#define HDMI_HDCP_MSG_RI_LEN 2 +#define HDMI_HDCP_MSG_PJ_LEN 1 +#define HDMI_HDCP_MSG_AKSV_LEN 5 +#define HDMI_HDCP_MSG_AINFO_LEN 1 +#define HDMI_HDCP_MSG_AN_LEN 8 +#define HDMI_HDCP_MSG_PER_VH_LEN 4 +#define HDMI_HDCP_MSG_ALL_VH_LEN 20 +#define HDMI_HDCP_MSG_BCAPS_LEN 1 +#define HDMI_HDCP_MSG_BSTATUS_LEN 2 +#define HDMI_HDCP_MSG_KSV_FIFO_LEN 1 +#define HDMI_HDCP_DEVICE_COUNT_MAX 127 +#define HDMI_HDCP_MSG_KSV_MAX_LEN (5 * HDMI_HDCP_DEVICE_COUNT_MAX) +#define HDMI_HDCP_GET_KSV_LEN(x) (5 * x) + +#define HDMI_HDCP_AKSV_ONE_NUM 20 +#define HDMI_HDCP_BCAPS_REPEATER_MARK 0x40 +#define HDMI_HDCP_BCAPS_KSV_FIFO_READY_MARK 0x20 +#define HDMI_HDCP_DEFAULT_READ_REG_TRY 100 +#define HDMI_HDCP_WAIT_KSV_LIST_TIMES 5000 /* 5s */ +#define HDMI_HDCP_WAIT_KSV_LIST_READ_REG_INTERVAL 20 /* 20ms */ +#define HDMI_HDCP_WAIT_KSV_LIST_READ_REG_CNT \ + (HDMI_HDCP_WAIT_KSV_LIST_TIMES / HDMI_HDCP_WAIT_KSV_LIST_READ_REG_INTERVAL) + +#define HDMI_HDCP_BSTATUS_DEVICE_COUNT_MARK 0x7F +#define HDMI_HDCP_BSTATUS_MAX_DEVS_EXCEEDED_MARK (1 << 7) +#define HDMI_HDCP_BSTATUS_MAX_CASCADE_EXCEEDED_MARK (1 << 11) +#define HDMI_HDCP_BSTATUS_DEPTH_MARK 0x07 +#define HDMI_HDCP_BSTATUS_DEPTH_SHIFT 8 + + +#define HDMI_HDCP_MSG_HDCP2VERSION_LEN 1 +#define HDMI_HDCP_MSG_RXSTATUS_LEN 2 +#define HDMI_HDCP_MSG_AKE_INIT_LEN 12 +#define HDMI_HDCP_MSG_AKE_CERT_LEN 534 +#define HDMI_HDCP_MSG_AKE_NO_STORED_KM_LEN 129 +#define HDMI_HDCP_MSG_AKE_STORED_KM_LEN 33 +#define HDMI_HDCP_MSG_AKE_H_PRIME_LEN 33 +#define HDMI_HDCP_MSG_AKE_PAIRING_INFO 17 +#define HDMI_HDCP_MSG_LC_INIT_LEN 9 +#define HDMI_HDCP_MSG_LC_L_PRIME_LEN 33 +#define HDMI_HDCP_MSG_SKE_EKS_LEN 25 +#define HDMI_HDCP_MSG_AUTH_RCVID_LIST_LEN (22 + 5 * 31) +#define HDMI_HDCP_MSG_REPEATER_AUTH_ACK_LEN 17 +#define HDMI_HDCP_MSG_REPEATER_AUTH_STREAM_MANAGE_LEN (6 + 2 * 31) +#define HDMI_HDCP_MSG_REPEATER_AUTH_STREAM_READY_LEN 33 + +#define HDMI_HDCP_2_2_VERSION 2 +#define HDMI_HDCP_GET_AUTH_RCVID_LIST_LEN(x) (22 + 5 * x) + +struct HdmiHdcpMsg { + /* HDCP 1.4 message */ + uint8_t bksv[HDMI_HDCP_MSG_BKSV_LEN]; + uint8_t ri[HDMI_HDCP_MSG_RI_LEN]; + uint8_t pj; + uint8_t aksv[HDMI_HDCP_MSG_AKSV_LEN]; + uint8_t ainfo; + uint8_t an[HDMI_HDCP_MSG_AN_LEN]; + uint8_t vh[HDMI_HDCP_MSG_ALL_VH_LEN]; + uint8_t bcaps; + uint8_t bstatus[HDMI_HDCP_MSG_BSTATUS_LEN]; + uint8_t ksvList[HDMI_HDCP_MSG_KSV_MAX_LEN]; + uint32_t ksvLen; + + /* HDCP 2.2 Message */ + uint8_t Hdcp2Version; + uint8_t rxStatus[HDMI_HDCP_MSG_RXSTATUS_LEN]; + uint8_t akeInit[HDMI_HDCP_MSG_AKE_INIT_LEN]; + uint8_t akeCert[HDMI_HDCP_MSG_AKE_CERT_LEN]; + uint8_t akeNoStoredKm[HDMI_HDCP_MSG_AKE_NO_STORED_KM_LEN]; + uint8_t akeStoredKm[HDMI_HDCP_MSG_AKE_STORED_KM_LEN]; + uint8_t akeHPrime[HDMI_HDCP_MSG_AKE_H_PRIME_LEN]; + uint8_t akePairingInfo[HDMI_HDCP_MSG_AKE_PAIRING_INFO]; + uint8_t lcInit[HDMI_HDCP_MSG_LC_INIT_LEN]; + uint8_t lcLPrime[HDMI_HDCP_MSG_LC_L_PRIME_LEN]; + uint8_t skeEks[HDMI_HDCP_MSG_SKE_EKS_LEN]; + uint8_t rxIdList[HDMI_HDCP_MSG_AUTH_RCVID_LIST_LEN]; + uint32_t rxIdListLen; + uint8_t authAck[HDMI_HDCP_MSG_REPEATER_AUTH_ACK_LEN]; + uint8_t authStreamManage[HDMI_HDCP_MSG_REPEATER_AUTH_STREAM_MANAGE_LEN]; + uint32_t authStreamManageLen; + uint8_t authStreamReady[HDMI_HDCP_MSG_REPEATER_AUTH_STREAM_READY_LEN]; +}; + +enum HdmiHdcpAuthState { + HDMI_HDCP_AUTH_INACTIVE = 0, + HDMI_HDCP_AUTH_AKSV_INVALID = 1, + HDMI_HDCP_AUTH_DOING = 2, + HDMI_HDCP_AUTH_DONE = 3, + HDMI_HDCP_AUTH_FAIL = 4, +}; + +#define HDMI_HDCP_AUTH_MAX_RETRY_CNT 10 +struct HdmiHdcp { + struct OsalMutex hdcpMutex; + enum HdmiHdcpAuthState state; + uint8_t authRetryCnt; + /* HDCP 1.4 */ + uint8_t aksv[HDMI_HDCP_MSG_AKSV_LEN]; /* need driver to generate */ + uint8_t an[HDMI_HDCP_MSG_AN_LEN]; /* need driver to generate */ + uint8_t bksv[HDMI_HDCP_MSG_BKSV_LEN]; + uint8_t bcaps; + uint8_t ri[HDMI_HDCP_MSG_RI_LEN]; + uint8_t bstatus[HDMI_HDCP_MSG_BSTATUS_LEN]; + uint8_t deviceCount; + uint8_t ksvList[HDMI_HDCP_MSG_KSV_MAX_LEN]; + uint32_t ksvLen; + uint8_t vh[HDMI_HDCP_MSG_ALL_VH_LEN]; + bool aksvValid; + void *priv; +}; + +struct HdmiHdcpStatus { + bool hdcp22; + bool hdcp14; + uint8_t bksv[HDMI_HDCP_MSG_BKSV_LEN]; + uint8_t aksv[HDMI_HDCP_MSG_AKSV_LEN]; +}; + +int32_t HdmiHdcpOpen(struct HdmiHdcp *hdcp); +void HdmiHdcpClose(struct HdmiHdcp *hdcp); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_HDCP_H */ diff --git a/support/platform/include/hdmi/hdmi_hdr.h b/support/platform/include/hdmi/hdmi_hdr.h new file mode 100644 index 0000000000000000000000000000000000000000..e77f76032fa164dd6f78e3ef1566e08d7856fc6b --- /dev/null +++ b/support/platform/include/hdmi/hdmi_hdr.h @@ -0,0 +1,65 @@ +/* + * Copyright (c) 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 HDMI_HPR_H +#define HDMI_HPR_H + +#include "hdf_base.h" +#include "hdmi_if.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/* HDR(High Dynamic Range) Sysytem. */ +#define HDMI_ZERO_DRMIF_SEND_TIME 2000 +#define HDMI_HDR_STATE_CHANGE_TIME 500 + +enum HdmiHdrTimerType { + HDMI_HDR_TIMER_ZERO_DRMIF, + HDMI_HDR_TIMER_SDR_TO_HDR10, + HDMI_HDR_TIMER_TYPE_BUTT +}; + +enum HdmiHdrState { + HDMI_HDR_STATE_NONE, /* HDR state change, SDR->HDR10 don't change anything */ + HDMI_HDR_STATE_OE, /* HDR state change, SDR->HDR10 output disable and enable */ + HDMI_HDR_STATE_AVMUTE, /* HDR state change, SDR->HDR10 send avmute */ + HDMI_HDR_STATE_BUTT +}; + +struct HdmiHdrTimerConfig { + enum HdmiHdrTimerType timerType; + bool start; + uint32_t time; +}; + +struct HdmiHdrInfo { + enum HdmiHdrState state; /* Make sure that switch smoothly from non-HDR10 to HDR10. */ + struct HdmiHdrTimerConfig zeroDrmIfTimer; /* Send zero DRM infoFrame when the HDR mode from HDR10 to non-HDR10. */ + struct HdmiHdrTimerConfig stateChangeTimer; /* */ +}; + +struct HdmiHdr { + struct HdmiHdrInfo info; + void *priv; +}; + +int32_t HdmiHdrAttrHandle(struct HdmiHdr *hdr, struct HdmiHdrAttr *curAttr); +int32_t HdmiHdrDrmInfoFrameStop(struct HdmiHdr *hdr); +int32_t HdmiHdrModeChangeTimeout(struct HdmiHdr *hdr); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_HPR_H */ diff --git a/support/platform/include/hdmi/hdmi_infoframe.h b/support/platform/include/hdmi/hdmi_infoframe.h new file mode 100644 index 0000000000000000000000000000000000000000..bd72fe66ce7ed8fad9f026ad2a65bdbe734f0544 --- /dev/null +++ b/support/platform/include/hdmi/hdmi_infoframe.h @@ -0,0 +1,493 @@ +/* + * Copyright (c) 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 HDMI_INFOFRAME_H +#define HDMI_INFOFRAME_H + +#include "hdmi_common.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/* + * An InfoFrame packet carries one InfoFrame. The InfoFrame provided by HDMI is limited to 30 + * bytes plus a checksum byte. HDMI Sources are required, in some cases, to use the AVI InfoFrame and Audio InfoFrame + * and recommended in other cases. Other InfoFrames specified in CEA-861 Spec are optional. + * + * TMDS is used to carry all audio and video data as well as auxiliary data, including AVI(Auxiliary Video information) + * and Audio InfoFrames that describe the active audio and video streams. + * + */ +#define HDMI_INFOFRAME_LEN 32 +#define HDMI_INFOFRAME_PACKET_HEADER_LEN 4 +#define HDMI_AVI_INFOFRAME_LEN 13 +#define HDMI_AUDIO_INFOFRAME_LEN 10 +#define HDMI_DRM_INFOFRAME_LEN 26 +#define HDMI_SPD_INFOFRAME_LEN 25 +#define HDMI_INFOFRAME_CHECKSUM 256 + +#define UINT8_ARRAY_TElEMENT_0 0 +#define UINT8_ARRAY_TElEMENT_1 1 +#define UINT8_ARRAY_TElEMENT_2 2 +#define UINT8_ARRAY_TElEMENT_3 3 +#define UINT8_ARRAY_TElEMENT_4 4 +#define UINT8_ARRAY_TElEMENT_5 5 +#define UINT8_ARRAY_TElEMENT_6 6 +#define UINT8_ARRAY_TElEMENT_7 7 +#define UINT8_ARRAY_TElEMENT_8 8 +#define UINT8_ARRAY_TElEMENT_9 9 +#define UINT8_ARRAY_TElEMENT_10 10 +#define UINT8_ARRAY_TElEMENT_11 11 +#define UINT8_ARRAY_TElEMENT_12 12 +#define UINT8_ARRAY_TElEMENT_13 13 +#define UINT8_ARRAY_TElEMENT_14 14 +#define UINT8_ARRAY_TElEMENT_15 15 +#define UINT8_ARRAY_TElEMENT_16 16 +#define UINT8_ARRAY_TElEMENT_17 17 +#define UINT8_ARRAY_TElEMENT_18 18 +#define UINT8_ARRAY_TElEMENT_19 19 +#define UINT8_ARRAY_TElEMENT_20 20 +#define UINT8_ARRAY_TElEMENT_21 21 +#define UINT8_ARRAY_TElEMENT_22 22 +#define UINT8_ARRAY_TElEMENT_23 23 +#define UINT8_ARRAY_TElEMENT_24 24 +#define UINT8_ARRAY_TElEMENT_25 25 + +enum HdmiPacketType { + HDMI_PACKET_TYPE_NULL = 0x00, /* Null Packet */ + HDMI_PACKET_TYPE_AUDIO_CLOCK_REGENERATION = 0x01, /* Audio Clock Regeneration(N/CTS) */ + HDMI_PACKET_TYPE_AUDIO_SAMPLE = 0x02, /* Audio Samlpe(L-PCM and IEC 61937 compressed formats) */ + HDMI_PACKET_TYPE_GENERAL_CONTROL = 0x03, /* General Control Packet */ + HDMI_PACKET_TYPE_ACP = 0x04, /* ACP(Audio Content Protection Packet) */ + HDMI_PACKET_TYPE_ISRC1 = 0x05, /* ISRC(International Standard Recording Code) */ + HDMI_PACKET_TYPE_ISRC2 = 0x06, + HDMI_PACKET_TYPE_ONE_BIT_AUDIO_SAMPLE = 0x07, /* One Bit Audio Sample Packet */ + HDMI_PACKET_TYPE_DST_AUDIO = 0x08, /* DST(Diret Stream Transport) Audio Packet */ + HDMI_PACKET_TYPE_HBR_AUDIO_STREAM = 0x09, /* HBR(High Bitrate) Audio Stream Packet */ + HDMI_PACKET_TYPE_GAMUT_METADATA = 0x0a, /* gamut metadata packet */ + /* infoFrame type */ + HDMI_INFOFRAME_PACKET_TYPE_VS = 0x81, /* Verdor-Specific */ + HDMI_INFOFRAME_PACKET_TYPE_AVI = 0x82, /* Auxiliary Video Information */ + HDMI_INFOFRAME_PACKET_TYPE_SPD = 0x83, /* Source Product Description */ + HDMI_INFOFRAME_PACKET_TYPE_AUDIO = 0x84, /* Audio */ + HDMI_INFOFRAME_PACKET_TYPE_MPEG = 0x85, /* MPEG Source */ + HDMI_INFOFRAME_PACKET_TYPE_GBD = 0x86, /* gamut boundary description */ + HDMI_INFOFRAME_PACKET_TYPE_DRM = 0x87, /* Dynamic Range and Mastering */ + HDMI_PACKET_TYPE_BUTT, +}; + +struct HdmiInfoFrameHeader { + enum HdmiPacketType type; + uint8_t verNum; + uint8_t len; +}; + +/* Verdor-Specific infoFrame details. */ +#define HDMI_VENDOR_1_4_MAX_3D_METADAT_LEN 20 +#define HDMI_VENDOR_USER_DATA_MAX_LEN 22 +#define HDMI_VENDOR_1_4_FORMAT_MARK 0x07 +#define HDMI_VENDOR_1_4_FORMAT_SHIFT 5 +#define HDMI_VENDOR_3D_STRUCTURE_MARK 0x0f +#define HDMI_VENDOR_3D_STRUCTURE_SHIFT 4 +#define HDMI_VENDOR_3D_EXT_DATA_MARK 0x0f +#define HDMI_VENDOR_3D_EXT_DATA_SHIFT 4 +#define HDMI_VSIF_VERSION 1 + +enum HdmiIeeeOui { + HDMI_IEEE_OUI_1_4 = 0x000c03, + HDMI_IEEE_OUI_2_0 = 0x045dd8, +}; + +enum HdmiVsVideoFormat { + HDMI_VS_VIDEO_FORMAT_NULL = 0, + HDMI_VS_VIDEO_FORMAT_4K = 1, + HDMI_VS_VIDEO_FORMAT_3D = 2, + HDMI_VS_VIDEO_FORMAT_BUTT, +}; + +enum HdmiVs3dExtData { + HDMI_3D_PICTURE_HORIZONTAL_ODD_LEFT_ODD_RIGHT = 0, + HDMI_3D_PICTURE_HORIZONTAL_ODD_LEFT_EVEN_RIGHT = 1, + HDMI_3D_PICTURE_HORIZONTAL_EVEN_LEFT_ODD_RIGHT = 2, + HDMI_3D_PICTURE_HORIZONTAL_EVEN_LEFT_EVEN_RIGHT = 3, + HDMI_3D_PICTURE_MATRIX_ODD_LEFT_ODD_RIGHT = 4, + HDMI_3D_PICTURE_MATRIX_ODD_LEFT_EVEN_RIGHT = 5, + HDMI_3D_PICTURE_MATRIX_EVEN_LEFT_ODD_RIGHT = 6, + HDMI_3D_PICTURE_MATRIX_EVEN_LEFT_EVEN_RIGHT = 7, + HDMI_3D_PICTURE_BUTT, +}; + +struct HdmiVs14VsifContent { + enum HdmiIeeeOui oui; + enum HdmiVsVideoFormat format; + enum Hdmi4kVic vic; + bool _3dMetaPresent; + enum HdmiVideo3dStructure _3dStruct; + enum HdmiVs3dExtData _3dExtData; + uint8_t _3dMetadataType; + uint8_t _3dMetadataLen; + uint8_t _3dMetadata[HDMI_VENDOR_1_4_MAX_3D_METADAT_LEN]; +}; + +struct HdmiVsUserVsifContent { + enum HdmiIeeeOui oui; + enum HdmiVsVideoFormat format; + enum Hdmi4kVic vic; + bool _3dMetaPresent; + enum HdmiVideo3dStructure _3dStruct; + uint8_t len; + uint8_t data[HDMI_VENDOR_USER_DATA_MAX_LEN]; +}; + +struct HdmiForumVsifContent { + enum HdmiIeeeOui oui; + uint8_t version; + bool _3dValid; + uint8_t _3dFStructure; + bool _3dAdditionalInfoPresent; + bool _3dDisparityDataPresent; + bool _3dMetaPresent; + uint8_t _3dFExtData; + uint8_t _3dDualView; + uint8_t _3dViewDependency; + uint8_t _3dPreferred2dView; + uint8_t _3dDisparityDataVersion; + uint8_t _3dDisparityDataLen; + uint8_t _3dDisparityData[10]; + uint8_t _3dMetadataType; + uint8_t _3dMetadataLen; + uint8_t _3dMetadata[10]; +}; + +struct HdmiVsInfoFrame { + enum HdmiPacketType type; + uint8_t verNum; + uint8_t len; + union { + struct HdmiVs14VsifContent vsif; + struct HdmiVsUserVsifContent userVsif; + struct HdmiForumVsifContent forumVsif; + } vsifContent; +}; + +/* AVI infoFrame details. */ +#define HDMI_AVI_COLOR_SPACE_MARK 0x03 +#define HDMI_AVI_SCAN_MODE_MARK 0x03 +#define HDMI_AVI_COLOR_SPACE_SHIFT 5 +#define HDMI_AVI_ACTIVE_INFORMATION_SHIFT 4 +#define HDMI_AVI_HORIZONTAL_BAR_SHIFT 3 +#define HDMI_AVI_VERTICAL_BAR_SHIFT 2 + +#define HDMI_AVI_COLORIMETRY_MARK 0x03 +#define HDMI_AVI_PICTURE_ASPECT_RATE_MARK 0x03 +#define HDMI_AVI_ACTIVE_FORMAT_ASPECT_RATE_MARK 0x0f +#define HDMI_AVI_COLORIMETRY_SHIFT 6 +#define HDMI_AVI_PICTURE_ASPECT_RATE_SHIFT 4 + +#define HDMI_AVI_EXT_COLORIMETRY_MARK 0x07 +#define HDMI_AVI_EXT_QUANTIZATION_RANGE_MARK 0x03 +#define HDMI_AVI_NUPS_RANGE_MARK 0x03 +#define HDMI_AVI_IT_CONTENT_SHIFT 7 +#define HDMI_AVI_EXT_COLORIMETRY_SHIFT 4 +#define HDMI_AVI_EXT_QUANTIZATION_RANGE_SHIFT 2 + +#define HDMI_AVI_YCC_QUANTIZATION_RANGE_MARK 0x03 +#define HDMI_AVI_IT_CONTENT_TYPE_MARK 0x03 +#define HDMI_AVI_PIXEL_REPETION_FACTOR_MARK 0x0f +#define HDMI_AVI_YCC_QUANTIZATION_RANGE_SHIFT 6 +#define HDMI_AVI_IT_CONTENT_TYPE_SHIFT 4 + +#define HDMI_AVI_BAR_MODE_MARK 0xff +#define HDMI_AVI_BAR_MODE_SHIFT 8 + +#define HDMI_AVI_VERSION2 2 +#define HDMI_AVI_VERSION3 3 +#define HDMI_AVI_VERSION4 4 +#define HDMI_AVI_Y2_MASK (0x1 << 2) + +enum HdmiScanMode { + HDMI_SCAN_MODE_NO_DATA = 0, + HDMI_SCAN_MODE_OVERSCAN = 1, + HDMI_SCAN_MODE_UNDERSCAN = 2, + HDMI_SCAN_MODE_FUTURE = 3, +}; + +enum HdmiItContentType { + HDMI_IT_CONTENT_TYPE_GRAPHICS = 0, + HDMI_IT_CONTENT_TYPE_PHOTO = 1, + HDMI_IT_CONTENT_TYPE_CINEMA = 2, + HDMI_IT_CONTENT_TYPE_GAME = 3, +}; + +struct HdmiAviInfoFrame { + enum HdmiPacketType type; + uint8_t verNum; + uint8_t len; + enum HdmiScanMode scanMode; + bool vertBarInfoPresent; + bool horizBarInfoPresent; + bool activeFormatInformationPresent; + enum HdmiColorSpace colorSpace; + enum HdmiActiveFormatAspectRatio activeAspect; + enum HdmiPictureAspectRatio pictureAspect; + enum HdmiColorimetry colorimetry; + enum HdmiNups nups; + enum HdmiQuantizationRange range; + enum HdmiExtendedColorimetry extColorimetry; + bool itc; /* IT content */ + uint8_t vic; + uint8_t pixelRepetitionFactor; + enum HdmiItContentType itcType; + enum HdmiYccQuantizationRange yccRange; + uint16_t topBar; + uint16_t bottomBar; + uint16_t leftBar; + uint16_t rightBar; +}; + +/* Audio infoFrame details. */ +#define HDMI_AUDIO_INFOFRAME_VERSION 1 +#define HDMI_AUDIO_CODING_TYPE_MARK 0x0f +#define HDMI_AUDIO_CHANNEL_COUNT_MARK 0x07 +#define HDMI_AUDIO_CODING_TYPE_SHIFT 4 + +#define HDMI_AUDIO_SAMPLE_FREQUENCY_MARK 0x07 +#define HDMI_AUDIO_SAMPLE_SIZE_MARK 0x03 +#define HDMI_AUDIO_SAMPLE_FREQUENCY_SHIFT 2 + +#define HDMI_AUDIO_CXT_MARK 0x1f + +#define HDMI_AUDIO_LEVEL_SHIFT_VALUE_MARK 0x0f +#define HDMI_AUDIO_LEF_PLAYBACK_LEVEL_MARK 0x03 +#define HDMI_AUDIO_DM_INH_SHIFT 7 +#define HDMI_AUDIO_LEVEL_SHIFT_VALUE_SHIFT 3 + +enum HdmiAudioSampleSize { + HDMI_AUDIO_SAMPLE_SIZE_STREAM = 0, + HDMI_AUDIO_SAMPLE_SIZE_16_BIT = 1, + HDMI_AUDIO_SAMPLE_SIZE_20_BIT = 2, + HDMI_AUDIO_SAMPLE_SIZE_24_BIT = 3, +}; + +enum HdmiAudioSampleFrequency { + HDMI_AUDIO_SAMPLE_FREQUENCY_STREAM = 0, + HDMI_AUDIO_SAMPLE_FREQUENCY_32K = 1, + HDMI_AUDIO_SAMPLE_FREQUENCY_44_1K = 2, + HDMI_AUDIO_SAMPLE_FREQUENCY_48K = 3, + HDMI_AUDIO_SAMPLE_FREQUENCY_88_2K = 4, + HDMI_AUDIO_SAMPLE_FREQUENCY_96K = 5, + HDMI_AUDIO_SAMPLE_FREQUENCY_176_4K = 6, + HDMI_AUDIO_SAMPLE_FREQUENCY_192K = 7, +}; + +enum HdmiAudioCodingExtType { + /* Refer to Audio Coding Type (CT) field in Data Byte 1 */ + HDMI_AUDIO_CODING_EXT_TYPET_CT = 0, + + /* + * The next three CXT values are defined in CEA-861-E only. + * They do not exist in older versions, and in CEA-861-F they are + * defined as 'Not in use'. + */ + HDMI_AUDIO_CODING_EXT_TYPET_HE_AAC = 1, + HDMI_AUDIO_CODING_EXT_TYPET_HE_AAC_V2 = 2, + HDMI_AUDIO_CODING_EXT_TYPET_MPEG_SURROUND = 3, + + HDMI_AUDIO_CODING_EXT_TYPET_MPEG4_HE_AAC = 4, + HDMI_AUDIO_CODING_EXT_TYPET_MPEG4_HE_AAC_V2 = 5, + HDMI_AUDIO_CODING_EXT_TYPET_MPEG4_AAC_LC = 6, + HDMI_AUDIO_CODING_EXT_TYPET_DRA = 7, + HDMI_AUDIO_CODING_EXT_TYPET_MPEG4_HE_AAC_SURROUND = 8, + HDMI_AUDIO_CODING_EXT_TYPET_RESERVED = 9, + HDMI_AUDIO_CODING_EXT_TYPET_MPEG4_AAC_LC_SURROUND = 10, + + HDMI_AUDIO_CODING_EXT_TYPET_MPEGH_3D_AUDIO = 11, + HDMI_AUDIO_CODING_EXT_TYPET_AC4 = 12, + HDMI_AUDIO_CODING_EXT_TYPET_LPCM_3D_AUDIO = 13, + HDMI_AUDIO_CODING_EXT_TYPET_BUTT, +}; + +/* LEF(Low Frequency Effects) playback level. */ +enum HdmiAudioLfePlaybackLevel { + HDMI_AUDIO_LFE_PLAYBACK_NULL = 0, + HDMI_AUDIO_LFE_PLAYBACK_0DB = 1, + HDMI_AUDIO_LFE_PLAYBACK_10DB = 2, + HDMI_AUDIO_LFE_PLAYBAC_BUTT, +}; + +struct HdmiAudioInfoFrame { + enum HdmiPacketType type; + uint8_t verNum; + uint8_t len; + uint8_t channelCount; + enum HdmiAudioCodingType codingType; + enum HdmiAudioSampleSize sampleSize; + enum HdmiAudioSampleFrequency sampleFreq; + enum HdmiAudioCodingExtType codingExtType; + uint8_t channelAllocation; + enum HdmiAudioLfePlaybackLevel playBackLevel; + uint8_t levelShiftValue; + bool dmInh; /* Down-mix Inhibit Flag */ +}; + +/* Source Product Description infoFrame details. */ +#define HDMI_SPD_VENDOR_NAME_LEN 8 +#define HDMI_SPD_PRODUCT_DESCRIPTION_LEN 16 +#define HDMI_SPD_VERSION 1 + +/* SDI(Source Device Information) */ +enum HdmiSpdSdi { + HDMI_SPD_SDI_NULL = 0, + HDMI_SPD_SDI_DIGITAL_STB = 1, + HDMI_SPD_SDI_DVD_PLAYER = 2, + HDMI_SPD_SDI_D_VHS = 3, + HDMI_SPD_SDI_HDD_VIDEORECORDER = 4, + HDMI_SPD_SDI_DVC = 5, + HDMI_SPD_SDI_DSC = 6, + HDMI_SPD_SDI_VIDEO_CD = 7, + HDMI_SPD_SDI_GAME = 8, + HDMI_SPD_SDI_PC_GENERAL = 9, + HDMI_SPD_SDI_BLU_RAY_DIS = 10, + HDMI_SPD_SDI_SUPER_AUDIO_CD = 11, + HDMI_SPD_SDI_HDDVD = 12, + HDMI_SPD_SDI_PMP = 13, + HDMI_SPD_SDI_BUTT, +}; + +struct HdmiSpdInfoFrame { + enum HdmiPacketType type; + uint8_t verNum; + uint8_t len; + char vendorName[HDMI_SPD_VENDOR_NAME_LEN]; + char productDescription[HDMI_SPD_PRODUCT_DESCRIPTION_LEN]; + enum HdmiSpdSdi sdi; +}; + +/* Dynamic Range and Mastering infoFrame details. */ +#define HDMI_DRM_METADATA_MARK 0xff +#define HDMI_DRM_METADATA_SHIFT 8 +#define HDMI_DRM_INFOFRAME_VERSION 1 + +struct HdmiDrmInfoFrame { + enum HdmiPacketType type; + uint8_t verNum; + uint8_t len; + enum HdmiEotfType eotfType; + enum HdmiStaticMetadataType metadataType; + union HdmiStaticMetadataDescriptor des; +}; + +/* GBD(gamut boundary description) */ +union HdmiGbdHb1 { + struct { + uint8_t affectedGamutSeqNum : 4; /* [0:3] */ + uint8_t gbdProfil : 3; /* [4:5] */ + uint8_t reseverd : 1; /* [6] */ + uint8_t noCrntGbd : 1; /* [7] */ + } bits; + uint8_t val; +}; + +union HdmiGbdHb2 { + struct { + uint8_t currentGamutSeqNum : 4; /* [0:3] */ + uint8_t packetSeq : 2; /* [4:5] */ + uint8_t nextField : 1; /* [7] */ + } bits; + uint8_t val; +}; + +union HdmiGbdRangeData0 { + struct { + uint8_t gbdColorSpace : 3; /* [0:2] */ + uint8_t gbdColorPercision : 2; /* [3:4] */ + uint8_t rsvd : 2; /* [5:6] */ + uint8_t formatFlag : 1; /* [7] */ + } bits; + uint8_t val; +}; + +struct HdmiGbdPacket { + uint8_t hb0; + union HdmiGbdHb1 hb1; + union HdmiGbdHb2 hb2; + union HdmiGbdRangeData0 data0; + uint8_t minRedDataH; + uint8_t midRedData; /* Min_Red_Data_L | Max_Red_Data_H */ + uint8_t maxRedDataL; + uint8_t minGreenDataH; + uint8_t midGreenData; /* Min_Green_Data_L | Max_Green_Data_H */ + uint8_t maxGreenDataL; + uint8_t minBlueDataH; + uint8_t midBlueData; /* Min_Blue_Data_L | Max_Blue_Data_H */ + uint8_t maxBlueDataL; +}; + +union HdmiInfoFrameInfo { + struct HdmiInfoFrameHeader header; + struct HdmiVsInfoFrame vs; + struct HdmiAviInfoFrame avi; + struct HdmiAudioInfoFrame audio; + struct HdmiSpdInfoFrame spd; + struct HdmiDrmInfoFrame drm; + struct HdmiGbdPacket gbd; +}; + +/* + * InfoFrame: A data structure defined in CEA-861-D that is designed to carry a variety of auxiliary data items + * regarding the audio or video streams or the source device and is carried from Source to Sink across HDMI. + */ +struct HdmiInfoFrame { + enum HdmiPacketType infoFrameType; + bool hdrSupport; + struct HdmiVsInfoFrame vs; + struct HdmiAviInfoFrame avi; + struct HdmiAudioInfoFrame audio; + struct HdmiSpdInfoFrame spd; + struct HdmiDrmInfoFrame drm; + struct HdmiGbdPacket gbd; + struct HdmiVsUserVsifContent userVsif; + void *priv; +}; + +struct HdmiInfoFrameStatus { + bool vsifEnable; + bool aviEnable; + bool audioEnable; + bool spdEnable; + bool drmEnable; + bool gdbEnable; + uint8_t avi[HDMI_INFOFRAME_LEN]; + uint8_t audio[HDMI_INFOFRAME_LEN]; + uint8_t vsif[HDMI_INFOFRAME_LEN]; + uint8_t spd[HDMI_INFOFRAME_LEN]; + uint8_t drm[HDMI_INFOFRAME_LEN]; + uint8_t gdb[HDMI_INFOFRAME_LEN]; +}; + +int32_t HdmiAudioInfoFrameSend(struct HdmiInfoFrame *frame, bool enable); +int32_t HdmiAviInfoFrameSend(struct HdmiInfoFrame *frame, bool enable); +int32_t HdmiDrmInfoFrameSend(struct HdmiInfoFrame *frame, bool enable); +int32_t HdmiVsInfoFrameSend(struct HdmiInfoFrame *frame, bool enable, bool dolbyEnable); +int32_t HdmiSpdInfoFrameSend(struct HdmiInfoFrame *frame, bool enable, + const char *vendorName, const char *productName, enum HdmiSpdSdi sdi); +int32_t HdmiInfoFrameGetInfo(struct HdmiInfoFrame *frame, enum HdmiPacketType type, + union HdmiInfoFrameInfo *infoFrame); +int32_t HdmiInfoFrameSetInfo(struct HdmiInfoFrame *frame, enum HdmiPacketType type, + union HdmiInfoFrameInfo *infoFrame); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_INFOFRAME_H */ diff --git a/support/platform/include/hdmi/hdmi_ncts.h b/support/platform/include/hdmi/hdmi_ncts.h new file mode 100644 index 0000000000000000000000000000000000000000..acce3330ccbf4c9ca327ea9c943cb632695bd7ad --- /dev/null +++ b/support/platform/include/hdmi/hdmi_ncts.h @@ -0,0 +1,41 @@ +/* + * Copyright (c) 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 HDMI_NCTS_H +#define HDMI_NCTS_H + +#include "hdf_base.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/* N/CTS(Cycle Time Stamp), see hdmi1.4 spec section 7.2. */ +#define HDMI_NCTS_FACTOR 128 +#define HDMI_NCTS_N_DEFAULT 6144 +#define HDMI_NCTS_TMDS_DEVIATION 20 + +struct HdmiAudioNCts { + uint32_t sampleRate; /* audio sample rate(fs) */ + uint32_t tmdsClock; + uint32_t n; + uint32_t cts; +}; + +uint32_t HdmiGetN(uint32_t sampleRate, uint32_t tmdsClock); +uint32_t HdmiGetCts(uint32_t sampleRate, uint32_t tmdsClock); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_NCTS_H */ diff --git a/support/platform/include/hdmi/hdmi_scdc.h b/support/platform/include/hdmi/hdmi_scdc.h new file mode 100644 index 0000000000000000000000000000000000000000..4f75eb638f016375e481790334815c973afab6d4 --- /dev/null +++ b/support/platform/include/hdmi/hdmi_scdc.h @@ -0,0 +1,321 @@ +/* + * Copyright (c) 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 HDMI_SCDC_H +#define HDMI_SCDC_H + +#include "hdf_base.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +/* SCDC(Status and Control Data Channel) */ +#define HDMI_SCDC_HDMI20_VERSION 1 +#define HDMI_SCDC_DEFAULT_SCRAMBLE_TIMEOUT 200 /* ms */ + +/* + * SCDCS(Status and Control Data Channel Structure). + * see hdmi2.0 spec table 10-15. + */ +enum HdmiScdcsOffset { + HDMI_SCDCS_OFFSET_SINK_VERSION = 0x01, + HDMI_SCDCS_OFFSET_SOURCE_VERSION = 0x02, + HDMI_SCDCS_OFFSET_UPDATE_0 = 0x10, + HDMI_SCDCS_OFFSET_UPDATE_1 = 0x11, + HDMI_SCDCS_OFFSET_TMDS_CONFIG = 0x20, + HDMI_SCDCS_OFFSET_SCRAMBLER_STATUS = 0x21, + HDMI_SCDCS_OFFSET_CONFIG_0 = 0x30, + HDMI_SCDCS_OFFSET_CONFIG_1 = 0x31, + HDMI_SCDCS_OFFSET_TEST_CONFIG_1 = 0x35, + HDMI_SCDCS_OFFSET_STASTUS_FLAG_0 = 0x40, + HDMI_SCDCS_OFFSET_STASTUS_FLAG_1 = 0x41, + HDMI_SCDCS_OFFSET_STASTUS_FLAG_2 = 0x42, + HDMI_SCDCS_OFFSET_ERR_DET_0_L = 0x50, + HDMI_SCDCS_OFFSET_ERR_DET_0_H = 0x51, + HDMI_SCDCS_OFFSET_ERR_DET_1_L = 0x52, + HDMI_SCDCS_OFFSET_ERR_DET_1_H = 0x53, + HDMI_SCDCS_OFFSET_ERR_DET_2_L = 0x54, + HDMI_SCDCS_OFFSET_ERR_DET_2_H = 0x55, + HDMI_SCDCS_OFFSET_ERR_DET_CHECKSUM = 0x56, + HDMI_SCDCS_OFFSET_TEST_CONFIG_0 = 0xC0, + HDMI_SCDCS_OFFSET_IEEE_OUI_3TH = 0xD0, + HDMI_SCDCS_OFFSET_IEEE_OUI_2ND = 0xD1, + HDMI_SCDCS_OFFSET_IEEE_OUI_1ST = 0xD2, + HDMI_SCDCS_OFFSET_DEVICE_ID_START = 0xD3, + HDMI_SCDCS_OFFSET_DEVICE_ID_END = 0xDD, + HDMI_SCDCS_OFFSET_SPECIFIC_START = 0xDE, + HDMI_SCDCS_OFFSET_SPECIFIC_END = 0xFF, +}; + +/* + * see HDMI2.1 section 10.4.1.3. + * All update flags are readable and writable. + * The purpose of these flags is to provide a mechanism for the sink device to efficiently inform the source device + * that additional source device action may be required. + */ +union HdmiScdcsUpdateFlag0 { + uint8_t data; + struct { + uint8_t statusUpdate : 1; /* The sink shall set this bit when value is changed in the Status Flag register. */ + uint8_t cedUpdate : 1; /* ced(character error detection) register. */ + uint8_t rrTest : 1; /* rr(Read Request) */ + uint8_t srcTestUpdate : 1; + uint8_t frlStart : 1; + uint8_t fltUpdate : 1; + uint8_t rsedUpdate : 1; + uint8_t reserved : 1; + } bits; +}; + +#define HDMI_SCDC_STATUS_UPDATE_MARK (1 << 0) +#define HDMI_SCDC_CED_UPDATE_MARK (1 << 1) +#define HDMI_SCDC_RR_TEST_MARK (1 << 2) +#define HDMI_SCDC_SRC_TEST_UPDATE_MARK (1 << 3) +#define HDMI_SCDC_FRL_START_MARK (1 << 4) +#define HDMI_SCDC_FLT_UPDATE_MARK (1 << 5) +#define HDMI_SCDC_RSED_UPDATE_MARK (1 << 6) + +/* + * see HDMI2.1 section 10.4.1.4. + * All Configuration fields are readable and writable. + */ +union HdmiScdcsTmdsConfig { + uint8_t data; + struct { + uint8_t scramblingEnable : 1; + uint8_t tmdsBitClockRatio : 1; /* + * 0: TMDS_Bit_Period/TMDS_Clock_Period is 1/10; + * 1: TMDS_Bit_Period/TMDS_Clock_Period is 1/40. + */ + uint8_t reserved : 6; + } bits; +}; + +/* + * see HDMI2.1 section 10.4.1.5. + * The Status Flags are all Read Only. + */ +union HdmiScdcsScramblerStatus { + uint8_t data; + struct { + uint8_t scramblingStatus : 1; + uint8_t reserved : 7; + } bits; +}; + +/* + * see hdmi2.0 spec table 10-21. + * All Configuration fields are readable and writable. + */ +union HdmiScdcsConfig0 { + uint8_t data; + struct { + uint8_t rrEnable : 1; /* + * The source set this bit when the source supports Read Request. + * The sink shall reset this bit when SCDC of the sink goes from the disabled to enabled. + */ + uint8_t fltNoRetrain : 1; + uint8_t reserved : 6; + } bits; +}; + +/* + * see HDMI2.1 section 10.4.1.6. + */ +union HdmiScdcsConfig1 { + uint8_t data; + struct { + uint8_t frlRate : 4; /* + * Source select the FRL rate and Lane count by writing into this register. + * This field is written by the Source during the Link Training protocol. + */ + uint8_t ffeLevels : 4; + } bits; +}; + +/* + * see HDMI2.1 section 10.4.1.6. + */ +union HdmiScdcsTestConfig1 { + uint8_t data; + struct { + uint8_t reserved0 : 1; + uint8_t preShootIOnly : 1; + uint8_t deEmphasisOnly : 1; + uint8_t noFfe : 1; + uint8_t reserved1 : 1; + uint8_t fltNoTimeout : 1; + uint8_t dscFrlMax : 1; + uint8_t frlMax : 1; + } bits; +}; + +#define HDMI_SCDC_PRE_SHOOT_ONLY_MARK (1 << 1) +#define HDMI_SCDC_DE_EMPHASIS_ONLY_MARK (1 << 2) +#define HDMI_SCDC_NO_FFE_MARK (1 << 3) +#define HDMI_SCDC_FLT_NO_TIMEOUT_MARK (1 << 5) +#define HDMI_SCDC_DSC_FRL_MAX_MARK (1 << 6) +#define HDMI_SCDC_FRL_MAX_MARK (1 << 7) + +/* + * see HDMI2.1 section 10.4.1.7. + * The Status Flags are all Read Only. + */ +union HdmiScdcsStatusFlag0 { + uint8_t data; + struct { + uint8_t clockDetected : 1; /* This bit shall be set by the sink when the sink detects a valid clock signal. */ + uint8_t ch0Locked : 1; /* + * This bit shall be set by the sink when the sink is successfully decoding + * data on HDMI Channel 0. + */ + uint8_t ch1Locked : 1; /* + * This bit shall be set by the sink when the sink is successfully decoding + * data on HDMI Channel 1. + */ + uint8_t ch2Locked : 1; /* + * This bit shall be set by the sink when the sink is successfully decoding + * data on HDMI Channel 2. + */ + uint8_t ch3Locked : 1; + uint8_t reserved : 1; + uint8_t fltReady : 1; + uint8_t dscDecodeFail : 1; + } bits; +}; + +#define HDMI_SCDC_CLOCK_DETECTED_MARK (1 << 0) +#define HDMI_SCDC_CH0_LOCKED_MARK (1 << 1) +#define HDMI_SCDC_CH1_LOCKED_MARK (1 << 2) +#define HDMI_SCDC_CH2_LOCKED_MARK (1 << 3) +#define HDMI_SCDC_CH3_LOCKED_MARK (1 << 4) +#define HDMI_SCDC_FLT_READY_MARK (1 << 6) +#define HDMI_SCDC_DSC_DECODE_FAIL_MARK (1 << 7) + +/* + * see HDMI2.1 section 10.4.1.7. + * The Status Flags are all Read Only. + */ +union HdmiScdcsStatusFlag1 { + uint8_t data; + struct { + uint8_t ln0LtpReq : 4; + uint8_t ln1LtpReq : 4; + } bits; +}; + +/* + * see HDMI2.1 section 10.4.1.7. + * The Status Flags are all Read Only. + */ +union HdmiScdcsStatusFlag2 { + uint8_t data; + struct { + uint8_t ln2LtpReq : 4; + uint8_t ln3LtpReq : 4; + } bits; +}; + +/* + * see hdmi2.0 spec table 10-23. Offeset 0x50~0x55. + * The Character Error Detection counters are not writable by the source and are cleared on read by the source. + */ +union HdmiScdcsCharacterErrorDetection { + uint16_t data; + struct { + uint16_t chErrCntLower : 8; /* Channel 0/1/2 Erroe Count bits 7->0 */ + uint16_t chErrCntUpper : 7; /* Channel 0/1/2 Erroe Count bits 14->8 */ + uint16_t chValid : 1; /* Channel 0/1/2 valid flag */ + } bits; +}; + +/* + * see hdmi2.0 spec table 10-24. + * The Test Configuration registers are privided to facilitate compliance testing. + */ +union HdmiScdcsTestConfig0 { + uint8_t data; + struct { + uint8_t testReadRequestDelay : 7; + uint8_t testReadRequest : 1; /* Read/Write */ + } bits; +}; + +struct HdmiScdcsRegStatus { + uint8_t sinkVersion; + uint8_t sourceVersion; /* R/W */ + union HdmiScdcsUpdateFlag0 upfate0; /* R/W */ + union HdmiScdcsTmdsConfig tmdsCfg; /* R/W */ + union HdmiScdcsScramblerStatus scramblerStatus; + union HdmiScdcsConfig0 cfg0; /* R/W */ + union HdmiScdcsStatusFlag0 statusFlag0; + union HdmiScdcsCharacterErrorDetection errDet0; + union HdmiScdcsCharacterErrorDetection errDet1; + union HdmiScdcsCharacterErrorDetection errDet2; + uint8_t errDetChecksum; + union HdmiScdcsTestConfig0 testCfg0; /* R/W */ + uint8_t ieeeOui[HDMI_SCDCS_OFFSET_IEEE_OUI_1ST - HDMI_SCDCS_OFFSET_IEEE_OUI_3TH + 1]; + uint8_t deviceId[HDMI_SCDCS_OFFSET_DEVICE_ID_END - HDMI_SCDCS_OFFSET_DEVICE_ID_START + 1]; +}; + +struct HdmiScdcScrambleCap { + bool sinkScramble; + bool sourceScramble; + bool tmdsBitClockRatio40; +}; + +struct HdmiScdcAttribute { + bool sinkReadRequest; + bool srcScramble; + bool sinkScramble; + bool tmdsBitClockRatio40; + uint32_t ScrambleTimeOut; + uint32_t ScrambleInterval; +}; + +struct HdmiScdc { + struct HdmiScdcsRegStatus status; + struct HdmiScdcAttribute attr; + void *priv; +}; + +/* used for frl. */ +enum HdmiScdcOptMsg { + HDMI_SCDC_OPT_SET_SOURCE_VER = 0, + HDMI_SCDC_OPT_GET_SOURCE_VER = 1, + HDMI_SCDC_OPT_GET_SINK_VER = 2, + HDMI_SCDC_OPT_SET_FLT_UPDATE = 3, + HDMI_SCDC_OPT_GET_FLT_UPDATE = 4, + HDMI_SCDC_OPT_SET_FRL_START = 5, + HDMI_SCDC_OPT_GET_FRL_START = 6, + HDMI_SCDC_OPT_SET_CONFIG1 = 7, + HDMI_SCDC_OPT_GET_CONFIG1 = 8, + HDMI_SCDC_OPT_GET_TEST_CONFIG_1 = 9, + HDMI_SCDC_OPT_GET_FLT_READY = 10, + HDMI_SCDC_OPT_GET_LTP_REQ = 11, + HDMI_SCDC_OPT_BUTT, +}; + +int32_t HdmiScdcScrambleSet(struct HdmiScdc *scdc, struct HdmiScdcScrambleCap *scramble); +int32_t HdmiScdcScrambleGet(struct HdmiScdc *scdc, struct HdmiScdcScrambleCap *scramble); +bool HdmiScdcSinkSupport(struct HdmiScdc *scdc); +void HdmiScdcReset(struct HdmiScdc *scdc); +int32_t HdmiScdcOptMsgHandle(struct HdmiScdc *scdc, enum HdmiScdcOptMsg msg, uint8_t *buffer, uint32_t len); +int32_t HdmiScdcFillScrambleCap(struct HdmiScdc *scdc, struct HdmiScdcScrambleCap *scramble, + enum HdmiTmdsModeType *tmdsMode); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HDMI_SCDC_H */ diff --git a/support/platform/include/i2c_core.h b/support/platform/include/i2c/i2c_core.h similarity index 99% rename from support/platform/include/i2c_core.h rename to support/platform/include/i2c/i2c_core.h index 0e5d513ac5868fd2522cd915fc6fc06250e232b5..d53a484a1673104adb173497f36d3322623f3871 100644 --- a/support/platform/include/i2c_core.h +++ b/support/platform/include/i2c/i2c_core.h @@ -12,6 +12,7 @@ #include "hdf_base.h" #include "i2c_if.h" #include "osal_mutex.h" +#include "platform_core.h" #ifdef __cplusplus #if __cplusplus diff --git a/support/platform/include/i2s_core.h b/support/platform/include/i2s/i2s_core.h similarity index 100% rename from support/platform/include/i2s_core.h rename to support/platform/include/i2s/i2s_core.h diff --git a/support/platform/include/i3c/i3c_ccc.h b/support/platform/include/i3c/i3c_ccc.h new file mode 100755 index 0000000000000000000000000000000000000000..3f2f3fc40637baec19c74d447b499a766e730e7d --- /dev/null +++ b/support/platform/include/i3c/i3c_ccc.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 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 I3C_CCC_H +#define I3C_CCC_H + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +struct I3cCccCmd; + +#define I3C_BROADCAST_ADDR 0x7e; + +/* Broatcast commands */ +#define I3C_CCC_ENEC_B 0x00 +#define I3C_CCC_DISEC_B 0x01 +#define I3C_CCC_ENTAS0_B 0x02 +#define I3C_CCC_ENTAS1_B 0x03 +#define I3C_CCC_ENTAS2_B 0x04 +#define I3C_CCC_ENTAS3_B 0x05 +#define I3C_CCC_RSTDAA_B 0x06 +#define I3C_CCC_ENTDAA 0x07 +#define I3C_CCC_DEFSLVS 0x08 +#define I3C_CCC_SETMWL_B 0x09 +#define I3C_CCC_SETMRL_B 0x0a +#define I3C_CCC_ENTTM 0x0b +#define I3C_CCC_ENDXFER 0X12 +#define I3C_CCC_ENTHDR0 0x20 +#define I3C_CCC_ENTHDR1 0x21 +#define I3C_CCC_ENTHDR2 0x22 +#define I3C_CCC_ENTHDR3 0x23 +#define I3C_CCC_ENTHDR4 0x24 +#define I3C_CCC_ENTHDR5 0x25 +#define I3C_CCC_ENTHDR6 0x26 +#define I3C_CCC_ENTHDR7 0x27 +#define I3C_CCC_SETXTIME_B 0x28 +#define I3C_CCC_SETAASA 0X29 +#define I3C_CCC_VENDOR_B 0x61 +/* Driect commands */ +#define I3C_CCC_ENEC_D 0x80 +#define I3C_CCC_DISEC_D 0x81 +#define I3C_CCC_ENTAS0_D 0x82 +#define I3C_CCC_ENTAS1_D 0x83 +#define I3C_CCC_ENTAS2_D 0x84 +#define I3C_CCC_ENTAS3_D 0x85 +#define I3C_CCC_RSTDAA_D 0x86 +#define I3C_CCC_SETDASA 0x87 +#define I3C_CCC_SETNEWDA 0x88 +#define I3C_CCC_SETMWL_D 0x89 +#define I3C_CCC_SETMRL_D 0x8a +#define I3C_CCC_GETMWL 0x8b +#define I3C_CCC_GETMRL 0x8c +#define I3C_CCC_GETPID 0x8d +#define I3C_CCC_GETBCR 0x8e +#define I3C_CCC_GETDCR 0x8f +#define I3C_CCC_GETSTATUS 0x90 +#define I3C_CCC_GETACCMST 0x91 +#define I3C_CCC_SETBRGTGT 0x93 +#define I3C_CCC_GETMXDS 0x94 +#define I3C_CCC_GETHDRCAP 0x95 +#define I3C_CCC_SETXTIME_D 0x98 +#define I3C_CCC_GETXTIME 0x99 +#define I3C_CCC_VENDOR_D 0xe0 + +struct I3cCccCmd { + uint8_t cmd; + uint16_t dest; +}; + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* I3C_CORE_H */ diff --git a/support/platform/include/i3c/i3c_core.h b/support/platform/include/i3c/i3c_core.h new file mode 100644 index 0000000000000000000000000000000000000000..63d49307eb026b48e421e3f1f9be0a84bd0ed9de --- /dev/null +++ b/support/platform/include/i3c/i3c_core.h @@ -0,0 +1,435 @@ +/* + * Copyright (c) 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 I3C_CORE_H +#define I3C_CORE_H + +#include "i3c_if.h" +#include "i3c_ccc.h" +#include "hdf_base.h" +#include "hdf_dlist.h" +#include "osal_spinlock.h" +#include "platform_core.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +#define I3C_CNTLR_MAX 20 +#define I3C_ADDR_MAX 127 +#define I3C_IBI_MAX 10 +#define ADDRS_STATUS_BITS 2 +#define BITS_PER_UINT16 16 +#define ADDRS_PER_UINT16 8 + +#define ADDR_STATUS_BIT0_MASK 0x1 +#define ADDR_STATUS_BIT1_MASK 0x2 +#define ADDR_STATUS_MASK 0x3 + + +#define I3C_RESERVED_ADDR_7H00 0x00 +#define I3C_RESERVED_ADDR_7H01 0x01 +#define I3C_RESERVED_ADDR_7H02 0x02 +#define I3C_RESERVED_ADDR_7H3E 0x3e +#define I3C_RESERVED_ADDR_7H5E 0x5e +#define I3C_RESERVED_ADDR_7H6E 0x6e +#define I3C_RESERVED_ADDR_7H76 0x76 +#define I3C_RESERVED_ADDR_7H78 0x78 +#define I3C_RESERVED_ADDR_7H79 0x79 +#define I3C_RESERVED_ADDR_7H7A 0x7a +#define I3C_RESERVED_ADDR_7H7B 0x7b +#define I3C_RESERVED_ADDR_7H7C 0x7c +#define I3C_RESERVED_ADDR_7H7D 0x7d +#define I3C_RESERVED_ADDR_7H7E 0x7e +#define I3C_RESERVED_ADDR_7H7F 0x7f + +#define I3C_HOT_JOIN_ADDR I3C_RESERVED_ADDR_7H02 +#define I3C_BROADCAST_ADDR I3C_RESERVED_ADDR_7H7E + +#define CHECK_RESERVED_ADDR(addr) \ + ({((addr == I3C_RESERVED_ADDR_7H00) || (addr == I3C_RESERVED_ADDR_7H01) || \ + (addr == I3C_RESERVED_ADDR_7H02) || (addr == I3C_RESERVED_ADDR_7H3E) || \ + (addr == I3C_RESERVED_ADDR_7H5E) || (addr == I3C_RESERVED_ADDR_7H6E) || \ + (addr == I3C_RESERVED_ADDR_7H76) || (addr == I3C_RESERVED_ADDR_7H78) || \ + (addr == I3C_RESERVED_ADDR_7H79) || (addr == I3C_RESERVED_ADDR_7H7A) || \ + (addr == I3C_RESERVED_ADDR_7H7B) || (addr == I3C_RESERVED_ADDR_7H7C) || \ + (addr == I3C_RESERVED_ADDR_7H7D) || (addr == I3C_RESERVED_ADDR_7H7E) || \ + (addr == I3C_RESERVED_ADDR_7H7F)) ? I3C_ADDR_RESERVED : I3C_ADDR_FREE;}) + +struct I3cCntlr; +struct I3cMethod; +struct I3cLockMethod; +struct I3cDevice; +struct I3cVendor; + +enum I3cDeviceType { + /** I2C device */ + I3C_CNTLR_I2C_DEVICE = 0, + /** legacy I2C device */ + I3C_CNTLR_I2C_LEGACY_DEVICE, + /** I3C device */ + I3C_CNTLR_I3C_DEVICE, +}; + +struct I3cCntlr { + OsalSpinlock lock; + void *owner; + int16_t busId; + struct I3cConfig config; + uint16_t addrSlot[(I3C_ADDR_MAX + 1) / ADDRS_PER_UINT16]; + struct I3cIbiInfo *ibiSlot[I3C_IBI_MAX]; + const struct I3cMethod *ops; + const struct I3cLockMethod *lockOps; + void *priv; +}; + +/* vendor information of I3C device */ +struct I3cVendor { + uint32_t vendorMipiId; + uint32_t vendorVersionId; + uint32_t vendorProductId; +}; + +/* In-bind Interrupt infomation */ +struct I3cIbiInfo { + I3cIbiFunc ibiFunc; + uint32_t payload; + uint8_t *data; +}; + +struct I3cDevice { + struct DListHead list; + struct I3cCntlr *cntlr; + uint16_t bcr; + uint16_t dcr; + uint64_t pid; + uint16_t addr; + enum I3cDeviceType type; + uint16_t dynaAddr; + uint16_t supportIbi; + struct I3cIbiInfo *ibi; + struct I3cVendor vendor; + void *devPriv; +}; + +struct I3cMethod { + /** + * @brief Send a CCC(Common Command Code), which is implemented by a specific vendor driver. + * + * @param cntlr Indicates the I3C controller device. + * @param ccc Indicates the {@link I3cCccCmd}(Common Command Code) structure. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ + int32_t (*sendCccCmd)(struct I3cCntlr *cntlr, struct I3cCccCmd *ccc); + + /** + * @brief Execute one or more I3C messages in I3C mode, which is implemented by a specific vendor driver. + * + * @param cntlr Indicates the I3C controller device. + * @param msgs Indicates the {@link I3cMsg} message array. + * @param count Indicates the length of the message array. + * + * @return Returns the number of transferred message structures on success; Returns a negative value otherwise. + * + * @see I3cMsg + * @since 1.0 + */ + int32_t (*Transfer)(struct I3cCntlr *cntlr, struct I3cMsg *msgs, int16_t count); + + /** + * @brief Execute one or more I3C messages in I2C mode, which is implemented by a specific vendor driver. + * + * @param cntlr Indicates the I3C controller device. + * @param msgs Indicates the {@link I3cMsg} message array. + * @param count Indicates the length of the message array. + * + * @return Returns the number of transferred message structures on success; Returns a negative value otherwise. + * + * @see I3cMsg + * @since 1.0 + */ + int32_t (*i2cTransfer)(struct I3cCntlr *cntlr, struct I3cMsg *msgs, int16_t count); + + /** + * @brief Set configurations of an I3C controller. + * + * @param cntlr Indicates the I3C controller to set. + * @param config Indicates the pointer of configuration structure. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ + int32_t (*setConfig)(struct I3cCntlr *cntlr, struct I3cConfig *config); + + /** + * @brief Get configurations of an I3C controller. + * + * @param cntlr Indicates the I3C controller to get configurations. + * @param config Indicates the pointer of configuration structure. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ + int32_t (*getConfig)(struct I3cCntlr *cntlr, struct I3cConfig *config); + + /** + * @brief Requeset an IBI(in-bind interrupt) for an I3C device which is supported. + * + * @param device Indicates the I3C device. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ + int32_t (*requestIbi)(struct I3cDevice *dev); + + /** + * @brief Free an IBI(in-bind interrupt). + * + * @param device Indicates the I3C device. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ + void (*freeIbi)(struct I3cDevice *dev); +}; + +struct I3cLockMethod { + /** + * @brief Get exclusive access to an I3C controller. + * + * @param cntlr Indicates the I3C controller to access. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ + int32_t (*lock)(struct I3cCntlr *cntlr); + /** + * @brief Release exclusive access to an I3C controller. + * + * @param cntlr Indicates the I3C controller to release. + * + * @since 1.0 + */ + void (*unlock)(struct I3cCntlr *cntlr); +}; + +enum I3C_ERROR_CODE { + I3C_ERROR_UNKNOWN = 0, + I3C_ERROR_M0, + I3C_ERROR_M1, + I3C_ERROR_M2, + I3C_ERROR_S0, + I3C_ERROR_S1, + I3C_ERROR_S2, + I3C_ERROR_S3, + I3C_ERROR_S4, + I3C_ERROR_S5, + I3C_ERROR_S6, +}; + +enum I3cAddrStatus { + I3C_ADDR_FREE = 0, + I3C_ADDR_RESERVED, + I3C_ADDR_I2C_DEVICE, + I3C_ADDR_I3C_DEVICE, +}; + +enum I3cDeviceSupportIbi { + I3C_DEVICE_NOT_SUPPORT_IBI = 0, + I3C_DEVICE_SUPPORT_IBI, +}; + +/** + * @brief Set the config of a I3C controller. + * + * @param cntlr Indicates the I3C controller device. + * @param config Indicates the pointer of the configuration structure. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ +int32_t I3cCntlrSetConfig(struct I3cCntlr *cntlr, struct I3cConfig *config); + +/** + * @brief Get the config of a I3C controller. + * + * @param cntlr Indicates the I3C controller device. + * @param config Indicates the pointer of the configuration structure. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ +int32_t I3cCntlrGetConfig(struct I3cCntlr *cntlr, struct I3cConfig *config); + +/** + * @brief Requeset an IBI(in-bind interrupt) for an I3C device which is supported. + * + * @param cntlr Indicates the I3C controller device. + * @param addr Indicates the address of device to requeset IBI(In-Band Interrupt). + * @param func Indicates the call back function of the IBI. + * @param payload Indicates the length of payload data, in bytes. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ +int32_t I3cCntlrRequestIbi(struct I3cCntlr *cntlr, uint16_t addr, I3cIbiFunc func, uint32_t payload); + +/** + * @brief Free the IBI(in-bind interrupt) which is Requeseted by {@link I3cCntlrRequestIbi}. + * + * @param cntlr Indicates the I3C controller device. + * @param addr Indicates the address of device to requeset IBI(In-Band Interrupt). + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ +int32_t I3cCntlrFreeIbi(struct I3cCntlr *cntlr, uint16_t addr); + +/** + * @brief Send a CCC (Common Command Code) to an I3C device which is supported. + * + * @param cntlr Indicates the I3C controller device. + * @param ccc The pointer of CCC (Common Command Code) structure to send. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ +int32_t I3cCntlrSendCccCmd(struct I3cCntlr *cntlr, struct I3cCccCmd *ccc); + +/** + * @brief Execute one or more I3C messages in I2C mode. + * + * @param cntlr Indicates the I3C controller device. + * @param msgs Indicates the {@link I3cMsg} message array. + * @param count Indicates the length of the message array. + * + * @return Returns the number of transferred message structures on success; Returns a negative value otherwise. + * + * @see I3cMsg + * @since 1.0 + */ +int32_t I3cCntlrI2cTransfer(struct I3cCntlr *cntlr, struct I3cMsg *msgs, int16_t count); + +/** + * @brief Execute one or more I3C messages in I3C mode. + * + * @param cntlr Indicates the I3C controller device. + * @param msgs Indicates the {@link I3cMsg} message array. + * @param count Indicates the length of the message array. + * + * @return Returns the number of transferred message structures on success; Returns a negative value otherwise. + * + * @see I3cMsg + * @since 1.0 + */ +int32_t I3cCntlrTransfer(struct I3cCntlr *cntlr, struct I3cMsg *msgs, int16_t count); + +/** + * @brief Add an I3C device or an I2C device to device list. + * + * @param device Indicates the I3C device or I2C device. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ +int32_t I3cDeviceAdd(struct I3cDevice *device); + +/** + * @brief Remove an I3C device or an I2C device from device list. + * + * @param device Indicates the I3C device or I2C device. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ +void I3cDeviceRemove(struct I3cDevice *device); + +/** + * @brief Find and return an I3C controller by number, with ref count. + * + * @param number Indicates the I3C controller to get. + * + * @return Returns an I3C controller object on success; Returns NULL otherwise. + * + * @since 1.0 + */ +struct I3cCntlr *I3cCntlrGet(int16_t number); + +/** + * @brief Release an I3C controller obtained by {@link I3cCntlrGet}. + * + * @param number Indicates the I3C controller to get. + * + * @since 1.0 + */ +void I3cCntlrPut(struct I3cCntlr *cntlr); + +/** + * @brief Add an I3C controller to controller list. + * + * @param cntlr Indicates the I3C controller device. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ +int32_t I3cCntlrAdd(struct I3cCntlr *cntlr); + +/** + * @brief Remove an I3C controller from controller list. + * + * @param cntlr Indicates the I3C controller device. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ +void I3cCntlrRemove(struct I3cCntlr *cntlr); + +/** + * @brief Get an I3C device by addr. + * + * @param cntlr Indicates the I3C controller device. + * @param addr Indicates the address of the device which you would like to get. + * + * @return Returns 0 on success; Returns a negative value otherwise. + * @since 1.0 + */ +struct I3cDevice *GetDeviceByAddr(struct I3cCntlr *cntlr, uint16_t addr); + +/** + * @brief IBI(In-bind Interrupt) callback function. + * + * @param device Indicates the device that generated the IBI. + * + * @return Returns an I3C device object on success; Returns NULL otherwise. + * + * @since 1.0 + */ +int32_t I3cCntlrIbiCallback(struct I3cDevice *device); + +enum I3cIoCmd { + I3C_IO_I2C_TRANSFER = 0, + I3C_IO_PRIV_TRANSFER, + I3C_IO_OPEN, + I3C_IO_CLOSE, + I3C_IO_GET_CONFIG, + I3C_IO_SET_CONFIG, + I3C_IO_REQUEST_IBI, + I3C_IO_FREE_IBI, +}; + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* I3C_CORE_H */ diff --git a/support/platform/include/mipi/mipi_csi_core.h b/support/platform/include/mipi/mipi_csi_core.h new file mode 100755 index 0000000000000000000000000000000000000000..3120f96372639d3970630513f498e128b76167d5 --- /dev/null +++ b/support/platform/include/mipi/mipi_csi_core.h @@ -0,0 +1,625 @@ +/* + * Copyright (c) 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 MIPI_CSI_CORE_H +#define MIPI_CSI_CORE_H + +#include "hdf_base.h" +#include "hdf_device.h" +#include "hdf_device_desc.h" +#include "hdf_object.h" +#include "mipi_csi_if.h" +#include "osal_mutex.h" +#include "osal_spinlock.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + + +#define MAX_CNTLR_CNT 2 +#define COMBO_DEV_MAX_NUM 2 +#define MIPI_RX_MAX_DEV_NUM 2 + +/** + * @brief Image size. + * + * @since 1.0 + */ +typedef struct { + /** Image width */ + unsigned int width; + /** Image height */ + unsigned int height; +} ImgSize; + +/** + * @brief LP, HS and escape mode switching timeout error. + * + * @since 1.0 + */ +typedef struct { + /** Clock1 Lane switching from LP to HS timeout */ + unsigned int clk1FsmTimeoutErrCnt; + /** Clock0 Lane switching from LP to HS timeout */ + unsigned int clk0FsmTimeoutErrCnt; + /** Data lane0 switching from LP to HS timeout */ + unsigned int d0FsmTimeoutErrCnt; + /** Data lane1 switching from LP to HS timeout */ + unsigned int d1FsmTimeoutErrCnt; + /** Data lane2 switching from LP to HS timeout */ + unsigned int d2FsmTimeoutErrCnt; + /** Data lane3 switching from LP to HS timeout */ + unsigned int d3FsmTimeoutErrCnt; + + /** Clock1 Lane switching to escape mode timed out */ + unsigned int clk1FsmEscapeErrCnt; + /** Clock0 Lane switching to escape mode timed out */ + unsigned int clk0FsmEscapeErrCnt; + /** Data lane0 switching to escape mode timed out */ + unsigned int d0FsmEscapeErrCnt; + /** Data lane1 switching to escape mode timeout */ + unsigned int d1FsmEscapeErrCnt; + /** Data lane2 switching to escape mode timeout */ + unsigned int d2FsmEscapeErrCnt; + /** Data lane3 switching to escape mode timeout */ + unsigned int d3FsmEscapeErrCnt; +} PhyErrIntCnt; + +/** + * @brief Errors generated during Mipi communication, including data packets, + * data frames and read-write control. + * + * @since 1.0 + */ +typedef struct { + /** Packet err. + Header has at least 2 errors and ECC cannot correct them */ + unsigned int errEccDoubleCnt; + /** CRC redundancy check error count for vc3 channel data */ + unsigned int vc3ErrCrcCnt; + /** CRC redundancy check error count for vc2 channel data */ + unsigned int vc2ErrCrcCnt; + /** CRC redundancy check error count for Vc1 channel data */ + unsigned int vc1ErrCrcCnt; + /** CRC redundancy check error count for vc0 channel data */ + unsigned int vc0ErrCrcCnt; + /** ECC corrected error count for vc3 channel header */ + unsigned int vc3ErrEccCorrectedCnt; + /** ECC corrected error count for vc2 channel header */ + unsigned int vc2ErrEccCorrectedCnt; + /** ECC corrected error count for Vc1 channel header */ + unsigned int vc1ErrEccCorrectedCnt; + /** ECC corrected error count for vc0 channel header */ + unsigned int vc0ErrEccCorrectedCnt; + /** Frame sequence error count of vc3 */ + unsigned int errIdVc3Cnt; + /** Frame sequence error count of vc2 */ + unsigned int errIdVc2Cnt; + /** Frame sequence error count of Vc1 */ + unsigned int errIdVc1Cnt; + /** Frame sequence error count or vc0 */ + unsigned int errIdVc0Cnt; + + /** Frame err. + Count of data types not supported by vc3 channel */ + unsigned int errFrameDataVc3Cnt; + /** Count of data types not supported by vc2 channel */ + unsigned int errFrameDataVc2Cnt; + /** Count of data types not supported by Vc1 channel */ + unsigned int errFrameDataVc1Cnt; + /** Count of data types not supported by vc0 channel */ + unsigned int errFrameDataVc0Cnt; + /** Frame sequence error count of vc3 */ + unsigned int errFSeqVc3Cnt; + /** Frame sequence error count of vc2 */ + unsigned int errFSeqVc2Cnt; + /** Frame sequence error count of Vc1 */ + unsigned int errFSeqVc1Cnt; + /** Frame sequence error count or vc0 */ + unsigned int errFSeqVc0Cnt; + /** Mismatch count of frame start and frame end short packets of vc3 channel */ + unsigned int errFBndryMatchVc3Cnt; + /** Mismatch count of frame start and frame end short packets of vc2 channel */ + unsigned int errFBndryMatchVc2Cnt; + /** Mismatch count of frame start and frame end short packets of Vc1 channel */ + unsigned int errFBndryMatchVc1Cnt; + /** Count of mismatch between frame start and frame end short packets of vc0 channel */ + unsigned int errFBndryMatchVc0Cnt; + + /** Ctrl err. + Mipi read data FIFO raw interrupt count */ + unsigned int dataFifoRderrCnt; + /** Mipi read command FIFO raw interrupt count */ + unsigned int cmdFifoRderrCnt; + /** Mipi write data FIFO raw interrupt count */ + unsigned int dataFifoWrerrCnt; + /** Mipi write command FIFO raw interrupt count */ + unsigned int cmdFifoWrerrCnt; +} MipiErrIntCnt; + +/** + * @brief LVDS internal read or write interrupt error. + * + * @since 1.0 + */ +typedef struct { + /** CMD_ FIFO register read error interrupt count */ + unsigned int cmdRdErrCnt; + /** CMD_ FIFO register write error interrupt count */ + unsigned int cmdWrErrCnt; + /** Read line_ BUF error interrupt count */ + unsigned int popErrCnt; + /** Synchronization error interrupt count of each lane during LVDS */ + unsigned int lvdsStateErrCnt; + /** Link0 read FIFO error interrupt count */ + unsigned int link0RdErrCnt; + /** Link0 write FIFO error interrupt count */ + unsigned int link0WrErrCnt; +} LvdsErrIntCnt; + +/** + * @brief Internal FIFO alignment error. + * + * @since 1.0 + */ +typedef struct { + /** Lane3 FIFO overflow */ + unsigned int lane3AlignErrCnt; + /** Lane2 FIFO overflow */ + unsigned int lane2AlignErrCnt; + /** Lane1 FIFO overflow */ + unsigned int lane1AlignErrCnt; + /** Lane0 FIFO overflow */ + unsigned int lane0AlignErrCnt; + /** FIFO overflow */ + unsigned int fifoFullErrCnt; +} AlignErrIntCnt; + +/** + * @brief Controller context parameter variable. + * + * @since 1.0 + */ +typedef struct { + /** Set by {@link MipiCsiSetHsMode} function */ + LaneDivideMode laneDivideMode; + bool hsModeCfged; + /** The properties of different types of devices are set through the {@link MipiCsiSetComboDevAttr} function */ + ComboDevAttr comboDevAttr[COMBO_DEV_MAX_NUM]; + bool devValid[COMBO_DEV_MAX_NUM]; + /** Whether the {@link MipiCsiSetComboDevAttr} function is called for parameter setting */ + bool devCfged[COMBO_DEV_MAX_NUM]; + unsigned int laneBitmap[COMBO_DEV_MAX_NUM]; +} MipiDevCtx; + +/** + * @brief Mipi CSI controller attribute and method definition. + * + * @since 1.0 + */ +struct MipiCsiCntlr { + /** The services provided by this controller are sent out when the driver is bound to the HDF framework */ + struct IDeviceIoService service; + /** The device side pointer is passed in when the driver binds to the HDF frame */ + struct HdfDeviceObject *device; + /** device number */ + unsigned int devNo; + /** All interfaces provided by the controller */ + struct MipiCsiCntlrMethod *ops; + /** For all interfaces debugged by the controller, null is required when the driver is not implemented */ + struct MipiCsiCntlrDebugMethod *debugs; + /** Controller context parameter variable */ + MipiDevCtx ctx; + /** Lock when accessing controller context parameter variables */ + OsalSpinlock ctxLock; + /** Lock when operating controller method */ + struct OsalMutex lock; + /** Anonymous data pointer, used to store struct mipi_csi_device */ + void *priv; +}; + +/** + * @brief All interfaces provided by the MIPI-CSI controller. + * + * Refer to the corresponding interface declaration for function pointer description. + * + * @since 1.0 + */ +struct MipiCsiCntlrMethod { + int32_t (*setComboDevAttr)(struct MipiCsiCntlr *cntlr, ComboDevAttr *pAttr); + int32_t (*setPhyCmvmode)(struct MipiCsiCntlr *cntlr, uint8_t devno, PhyCmvMode cmvMode); + int32_t (*setExtDataType)(struct MipiCsiCntlr *cntlr, ExtDataType* dataType); + int32_t (*setHsMode)(struct MipiCsiCntlr *cntlr, LaneDivideMode laneDivideMode); + int32_t (*enableClock)(struct MipiCsiCntlr *cntlr, uint8_t comboDev); + int32_t (*disableClock)(struct MipiCsiCntlr *cntlr, uint8_t comboDev); + int32_t (*resetRx)(struct MipiCsiCntlr *cntlr, uint8_t comboDev); + int32_t (*unresetRx)(struct MipiCsiCntlr *cntlr, uint8_t comboDev); + int32_t (*enableSensorClock)(struct MipiCsiCntlr *cntlr, uint8_t snsClkSource); + int32_t (*disableSensorClock)(struct MipiCsiCntlr *cntlr, uint8_t snsClkSource); + int32_t (*resetSensor)(struct MipiCsiCntlr *cntlr, uint8_t snsResetSource); + int32_t (*unresetSensor)(struct MipiCsiCntlr *cntlr, uint8_t snsResetSource); + int32_t (*setDrvData)(struct MipiCsiCntlr *cntlr, void *drvData); +}; + +/** + * @brief For all interfaces debugged by the MIPI-CSI controller, NULL is required when + * the driver is not implemented. + * + * Refer to the corresponding interface declaration for function pointer description. + * + * @since 1.0 + */ +struct MipiCsiCntlrDebugMethod { + void (*getMipiDevCtx)(struct MipiCsiCntlr *cntlr, MipiDevCtx *ctx); + void (*getPhyErrIntCnt)(struct MipiCsiCntlr *cntlr, unsigned int phyId, PhyErrIntCnt *errInfo); + void (*getMipiErrInt)(struct MipiCsiCntlr *cntlr, unsigned int phyId, MipiErrIntCnt *errInfo); + void (*getLvdsErrIntCnt)(struct MipiCsiCntlr *cntlr, unsigned int phyId, LvdsErrIntCnt *errInfo); + void (*getAlignErrIntCnt)(struct MipiCsiCntlr *cntlr, unsigned int phyId, AlignErrIntCnt *errInfo); + void (*getPhyData)(struct MipiCsiCntlr *cntlr, int phyId, int laneId, unsigned int *laneData); + void (*getPhyMipiLinkData)(struct MipiCsiCntlr *cntlr, int phyId, int laneId, unsigned int *laneData); + void (*getPhyLvdsLinkData)(struct MipiCsiCntlr *cntlr, int phyId, int laneId, unsigned int *laneData); + void (*getMipiImgsizeStatis)(struct MipiCsiCntlr *cntlr, uint8_t devno, short vc, ImgSize *pSize); + void (*getLvdsImgsizeStatis)(struct MipiCsiCntlr *cntlr, uint8_t devno, short vc, ImgSize *pSize); + void (*getLvdsLaneImgsizeStatis)(struct MipiCsiCntlr *cntlr, uint8_t devno, short lane, ImgSize *pSize); +}; + +int32_t MipiCsiRegisterCntlr(struct MipiCsiCntlr *cntlr, struct HdfDeviceObject *device); +void MipiCsiUnregisterCntlr(struct MipiCsiCntlr *cntlr); + +/** + * @brief Turn HdfDeviceObject to an MipiCsiCntlr. + * + * @param device Indicates a HdfDeviceObject. + * + * @return Retrns the pointer of the MipiCsiCntlr on success; returns NULL otherwise. + * @since 1.0 + */ +struct MipiCsiCntlr *MipiCsiCntlrFromDevice(const struct HdfDeviceObject *device); + +/** + * @brief Obtains the MIPI CSI device handle with a specified channel ID. + * + * @param id Indicates the MIPI CSI channel ID. + * + * @return Returns the MIPI CSI device if the operation is successful; returns NULL otherwise. + * + * @since 1.0 + */ +struct MipiCsiCntlr *MipiCsiCntlrGet(uint8_t id); + +/** + * @brief Releases the MIPI CSI device handle. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * + * @since 1.0 + */ +void MipiCsiCntlrPut(const struct MipiCsiCntlr *cntlr); + +/** + * @brief Set the parameters of Mipi, CMOS or LVDS camera to the controller. + * + * The parameters including working mode, image area, image depth, data rate and physical channel. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param pAttr Indicates the pointer to the attribute. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiCntlrSetComboDevAttr(struct MipiCsiCntlr *cntlr, ComboDevAttr *pAttr); + +/** + * @brief Set common mode voltage mode. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param devno There are 2 device numbers in total, pointing to 0 or 1. + * @param cmvMode Common mode voltage mode parameters. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiCntlrSetPhyCmvmode(struct MipiCsiCntlr *cntlr, uint8_t devno, PhyCmvMode cmvMode); + +/** + * @brief Reset sensor. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param snsResetSource The reset signal line number of sensor is called the reset source of sensor in software. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiCntlrResetSensor(struct MipiCsiCntlr *cntlr, uint8_t snsResetSource); + +/** + * @brief Unreset sensor. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param snsResetSource The reset signal line number of sensor is called the reset source of sensor in software. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiCntlrUnresetSensor(struct MipiCsiCntlr *cntlr, uint8_t snsResetSource); + +/** + * @brief Reset Mipi Rx. + * + * Different s32WorkingViNum have different enSnsType. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param comboDev MIPI RX or LVDS device type. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiCntlrResetRx(struct MipiCsiCntlr *cntlr, uint8_t comboDev); + +/** + * @brief Uneset MIPI RX. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param comboDev MIPI RX or LVDS device type. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiCntlrUnresetRx(struct MipiCsiCntlr *cntlr, uint8_t comboDev); + +/** + * @brief Set the lane distribution of Mipi Rx. + * + * Select the specific mode according to the form of hardware connection. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param laneDivideMode Lane division mode parameters. + * + * @since 1.0 + */ +int32_t MipiCsiCntlrSetHsMode(struct MipiCsiCntlr *cntlr, LaneDivideMode laneDivideMode); + +/** + * @brief Enable Mipi clock. + * + * Decide whether to use Mipi or LVDS according to the ensnstype parameter + * passed by the upper layer function. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param comboDev MIPI RX or LVDS device type. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiCntlrEnableClock(struct MipiCsiCntlr *cntlr, uint8_t comboDev); + +/** + * @brief Disable the clock of Mipi device. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param comboDev MIPI RX or LVDS device type. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiCntlrDisableClock(struct MipiCsiCntlr *cntlr, uint8_t comboDev); + +/** + * @brief Enable the sensor clock on Mipi. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param snsClkSource The clock signal line number of sensor, which is called the clock source of sensor in software. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiCntlrEnableSensorClock(struct MipiCsiCntlr *cntlr, uint8_t snsClkSource); + +/** + * @brief Disable the sensor clock. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param snsClkSource The clock signal line number of sensor, which is called the clock source of sensor in software. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiCntlrDisableSensorClock(struct MipiCsiCntlr *cntlr, uint8_t snsClkSource); + +/** + * @brief Set YUV and RAW data format and bit depth. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param dataType Pointer to image data format. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiCntlrSetExtDataType(struct MipiCsiCntlr *cntlr, ExtDataType* dataType); + +/** + * @brief Sets additional parameters for a MIPI CSI device. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param drvData Indicates the pointer to the additional parameters. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiCntlrSetDrvData(struct MipiCsiCntlr *cntlr, void *drvData); + +/** + * @brief Get controller context parameter variable for debugging. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param ctx Controller context parameter variable. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiDebugGetMipiDevCtx(struct MipiCsiCntlr *cntlr, MipiDevCtx *ctx); + +/** + * @brief Get mode switching timeout error for debugging. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param phyId Indicates PHY index. + * @param errInfo Indicates mode switching timeout error. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiDebugGetPhyErrIntCnt(struct MipiCsiCntlr *cntlr, unsigned int phyId, PhyErrIntCnt *errInfo); + +/** + * @brief Get errors generated during Mipi communication for debugging. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param phyId Indicates PHY index. + * @param errInfo Indicates Mipi communication error. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiDebugGetMipiErrInt(struct MipiCsiCntlr *cntlr, unsigned int phyId, MipiErrIntCnt *errInfo); + +/** + * @brief Get LVDS internal read or write interrupt error for debugging. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param phyId Indicates PHY index. + * @param errInfo Indicates LVDS read or write interrupt error. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiDebugGetLvdsErrIntCnt(struct MipiCsiCntlr *cntlr, unsigned int phyId, LvdsErrIntCnt *errInfo); + +/** + * @brief Get internal FIFO alignment error for debugging. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param phyId Indicates PHY index. + * @param errInfo Indicates FIFO alignment error. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiDebugGetAlignErrIntCnt(struct MipiCsiCntlr *cntlr, unsigned int phyId, AlignErrIntCnt *errInfo); + +/** + * @brief Get PHY data for debugging. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param phyId Indicates PHY index. + * @param laneId Indicates lane index, and the value range is 0 to COMBO_MAX_LANE_NUM-1. + * @param laneData Indicates a single PHY data. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiDebugGetPhyData(struct MipiCsiCntlr *cntlr, int phyId, int laneId, unsigned int *laneData); + +/** + * @brief Get MIPI data for debugging. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param phyId Indicates PHY index. + * @param laneId Indicates lane index, and the value range is 0 to COMBO_MAX_LANE_NUM-1. + * @param laneData Indicates a single MIPI data. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiDebugGetPhyMipiLinkData(struct MipiCsiCntlr *cntlr, int phyId, int laneId, unsigned int *laneData); + +/** + * @brief Get LVDS data for debugging. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param phyId Indicates PHY index. + * @param laneId Indicates lane index, and the value range is 0 to COMBO_MAX_LANE_NUM-1. + * @param laneData Indicates a single LVDS data. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiDebugGetPhyLvdsLinkData(struct MipiCsiCntlr *cntlr, int phyId, int laneId, unsigned int *laneData); + +/** + * @brief Get image size of MIPI for debugging. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param devno There are 2 device numbers in total, pointing to 0 or 1. + * @param vc Indicates virtual channel subscript. + * @param pSize Pointer to image size. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiDebugGetMipiImgsizeStatis(struct MipiCsiCntlr *cntlr, uint8_t devno, short vc, ImgSize *pSize); + +/** + * @brief Get image size of LVDS for debugging. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param devno There are 2 device numbers in total, pointing to 0 or 1. + * @param vc Indicates virtual channel subscript. + * @param pSize Pointer to image size. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiDebugGetLvdsImgsizeStatis(struct MipiCsiCntlr *cntlr, uint8_t devno, short vc, ImgSize *pSize); + +/** + * @brief Get image size of LVDS-Lane for debugging. + * + * @param cntlr Indicates the MIPI CSI device obtained via {@link MipiCsiOpen}. + * @param devno There are 2 device numbers in total, pointing to 0 or 1. + * @param lane Indicates lane index, and the value range is 0 to COMBO_MAX_LANE_NUM-1. + * @param pSize Pointer to image size. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiCsiDebugGetLvdsLaneImgsizeStatis(struct MipiCsiCntlr *cntlr, uint8_t devno, short lane, ImgSize *pSize); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif diff --git a/support/platform/include/mipi/mipi_csi_dev.h b/support/platform/include/mipi/mipi_csi_dev.h new file mode 100755 index 0000000000000000000000000000000000000000..c0900a522a9242d260e5f1b5f6f1e95fa8795427 --- /dev/null +++ b/support/platform/include/mipi/mipi_csi_dev.h @@ -0,0 +1,83 @@ +/* + * Copyright (c) 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 MIPI_CSI_DEV_H +#define MIPI_CSI_DEV_H + +#include "hdf_base.h" +#include "mipi_csi_if.h" + +typedef enum { + WORK_MODE_LVDS = 0x0, + WORK_MODE_MIPI = 0x1, + WORK_MODE_CMOS = 0x2, + WORK_MODE_BT1120 = 0x3, + WORK_MODE_SLVS = 0x4, + WORK_MODE_BUTT +} WorkMode; + +typedef struct { + uint8_t devno; + PhyCmvMode cmvMode; +} PhyCmv; + +#define CONFIG_HI_PROC_SHOW_SUPPORT + +#define HI_MIPI_IOC_MAGIC 'm' + +/* init data lane, input mode, data type */ +#define HI_MIPI_SET_DEV_ATTR _IOW(HI_MIPI_IOC_MAGIC, 0x01, ComboDevAttr) + +/* set phy common mode voltage mode */ +#define HI_MIPI_SET_PHY_CMVMODE _IOW(HI_MIPI_IOC_MAGIC, 0x04, PhyCmv) + +/* reset sensor */ +#define HI_MIPI_RESET_SENSOR _IOW(HI_MIPI_IOC_MAGIC, 0x05, uint8_t) + +/* unreset sensor */ +#define HI_MIPI_UNRESET_SENSOR _IOW(HI_MIPI_IOC_MAGIC, 0x06, uint8_t) + +/* reset mipi */ +#define HI_MIPI_RESET_MIPI _IOW(HI_MIPI_IOC_MAGIC, 0x07, uint8_t) + +/* unreset mipi */ +#define HI_MIPI_UNRESET_MIPI _IOW(HI_MIPI_IOC_MAGIC, 0x08, uint8_t) + +/* reset slvs */ +#define HI_MIPI_RESET_SLVS _IOW(HI_MIPI_IOC_MAGIC, 0x09, uint8_t) + +/* unreset slvs */ +#define HI_MIPI_UNRESET_SLVS _IOW(HI_MIPI_IOC_MAGIC, 0x0a, uint8_t) + +/* set mipi hs_mode */ +#define HI_MIPI_SET_HS_MODE _IOW(HI_MIPI_IOC_MAGIC, 0x0b, LaneDivideMode) + +/* enable mipi clock */ +#define HI_MIPI_ENABLE_MIPI_CLOCK _IOW(HI_MIPI_IOC_MAGIC, 0x0c, uint8_t) + +/* disable mipi clock */ +#define HI_MIPI_DISABLE_MIPI_CLOCK _IOW(HI_MIPI_IOC_MAGIC, 0x0d, uint8_t) + +/* enable slvs clock */ +#define HI_MIPI_ENABLE_SLVS_CLOCK _IOW(HI_MIPI_IOC_MAGIC, 0x0e, uint8_t) + +/* disable slvs clock */ +#define HI_MIPI_DISABLE_SLVS_CLOCK _IOW(HI_MIPI_IOC_MAGIC, 0x0f, uint8_t) + +/* enable sensor clock */ +#define HI_MIPI_ENABLE_SENSOR_CLOCK _IOW(HI_MIPI_IOC_MAGIC, 0x10, uint8_t) + +/* disable sensor clock */ +#define HI_MIPI_DISABLE_SENSOR_CLOCK _IOW(HI_MIPI_IOC_MAGIC, 0x11, uint8_t) + +#define HI_MIPI_SET_EXT_DATA_TYPE _IOW(HI_MIPI_IOC_MAGIC, 0x12, ExtDataType) + +int MipiCsiDevModuleInit(uint8_t id); +void MipiCsiDevModuleExit(uint8_t id); + +#endif /* MIPI_CSI_DEV_H */ diff --git a/support/platform/include/mipi_dsi_core.h b/support/platform/include/mipi/mipi_dsi_core.h similarity index 91% rename from support/platform/include/mipi_dsi_core.h rename to support/platform/include/mipi/mipi_dsi_core.h index 58fa709c06ba7f29e57548c84d4332abf7b74729..429c3310e31abedda34d2155da4603604bd2d41f 100644 --- a/support/platform/include/mipi_dsi_core.h +++ b/support/platform/include/mipi/mipi_dsi_core.h @@ -45,6 +45,7 @@ struct MipiDsiCntlrMethod { void (*exitUlps)(struct MipiDsiCntlr *cntlr); int32_t (*powerControl)(struct MipiDsiCntlr *cntlr, uint8_t enable); int32_t (*attach)(struct MipiDsiCntlr *cntlr, uint8_t *name); + int32_t (*setDrvData)(struct MipiDsiCntlr *cntlr, void *panelData); }; int32_t MipiDsiRegisterCntlr(struct MipiDsiCntlr *cntlr, struct HdfDeviceObject *device); @@ -160,6 +161,18 @@ int32_t MipiDsiCntlrRx(struct MipiDsiCntlr *cntlr, struct DsiCmdDesc *cmd, int32 */ int32_t MipiDsiCntlrAttach(struct MipiDsiCntlr *cntlr, uint8_t *name); +/** + * @brief Sets additional parameters for a MIPI DSI device. + * + * @param cntlr Indicates the MIPI DSI device obtained via {@link MipiDsiOpen}. + * @param panelData Indicates the pointer to the additional parameters. + * + * @return Returns 0 if the operation is successful; returns a negative value otherwise. + * + * @since 1.0 + */ +int32_t MipiDsiCntlrSetDrvData(struct MipiDsiCntlr *cntlr, void *panelData); + #ifdef __cplusplus #if __cplusplus } diff --git a/support/platform/include/pin/pin_core.h b/support/platform/include/pin/pin_core.h new file mode 100644 index 0000000000000000000000000000000000000000..5bb187ae5ebeb863082af622769c1739caa41758 --- /dev/null +++ b/support/platform/include/pin/pin_core.h @@ -0,0 +1,84 @@ +/* + * Copyright (c) 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 PIN_CORE_H +#define PIN_CORE_H + +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "hdf_dlist.h" +#include "pin_if.h" +#include "osal_spinlock.h" +#include "osal_atomic.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +struct PinCntlr; +struct PinCntlrMethod; +struct PinDesc; + +struct PinDesc { + const char *pinName; + void *priv; +}; + +struct PinCntlr { + struct IDeviceIoService service; + struct HdfDeviceObject *device; + struct PinCntlrMethod *method; + struct DListHead node; + OsalSpinlock spin; + uint16_t number; + uint16_t pinCount; + struct PinDesc *pins; + void *priv; +}; + +struct PinCntlrMethod { + int32_t (*SetPinPull)(struct PinCntlr *cntlr, uint32_t index, enum PinPullType pullType); + int32_t (*GetPinPull)(struct PinCntlr *cntlr, uint32_t index, enum PinPullType *pullType); + int32_t (*SetPinStrength)(struct PinCntlr *cntlr, uint32_t index, uint32_t strength); + int32_t (*GetPinStrength)(struct PinCntlr *cntlr, uint32_t index, uint32_t *strength); + int32_t (*SetPinFunc)(struct PinCntlr *cntlr, uint32_t index, const char *funcName); + int32_t (*GetPinFunc)(struct PinCntlr *cntlr, uint32_t index, const char **funcName); +}; + +int32_t PinCntlrAdd(struct PinCntlr *cntlr); + +void PinCntlrRemove(struct PinCntlr *cntlr); + +struct PinDesc *PinCntlrGetPinDescByName(const char *pinName); + +struct PinCntlr *PinCntlrGetByNumber(uint16_t number); + +struct PinCntlr *PinCntlrGetByPin(struct PinDesc *desc); + +void PinCntlrPutPin(struct PinDesc *desc); + +int32_t PinCntlrSetPinPull(struct PinCntlr *cntlr, struct PinDesc *desc, enum PinPullType pullType); + +int32_t PinCntlrGetPinPull(struct PinCntlr *cntlr, struct PinDesc *desc, enum PinPullType *pullType); + +int32_t PinCntlrSetPinStrength(struct PinCntlr *cntlr, struct PinDesc *desc, uint32_t strength); + +int32_t PinCntlrGetPinStrength(struct PinCntlr *cntlr, struct PinDesc *desc, uint32_t *strength); + +int32_t PinCntlrSetPinFunc(struct PinCntlr *cntlr, struct PinDesc *desc, const char *funcName); + +int32_t PinCntlrGetPinFunc(struct PinCntlr *cntlr, struct PinDesc *desc, const char **funcName); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* PIN_CORE_H */ diff --git a/support/platform/include/pwm_core.h b/support/platform/include/pwm/pwm_core.h similarity index 88% rename from support/platform/include/pwm_core.h rename to support/platform/include/pwm/pwm_core.h index 7da216c9a1ccd4fc580608f9146282deb83f8678..744cc72d692f91399c9c0e4a5ed710695707bd3c 100644 --- a/support/platform/include/pwm_core.h +++ b/support/platform/include/pwm/pwm_core.h @@ -9,10 +9,10 @@ #ifndef PWM_CORE_H #define PWM_CORE_H +#include "pwm_if.h" #include "hdf_base.h" #include "hdf_device_desc.h" #include "osal_spinlock.h" -#include "pwm_if.h" #ifdef __cplusplus #if __cplusplus @@ -40,6 +40,9 @@ struct PwmDev { void *priv; }; +int32_t PwmDeviceGet(struct PwmDev *pwm); +void PwmDevicePut(struct PwmDev *pwm); +int32_t PwmDeviceSetConfig(struct PwmDev *pwm, struct PwmConfig *config); void *PwmGetPriv(struct PwmDev *pwm); int32_t PwmSetPriv(struct PwmDev *pwm, void *priv); int32_t PwmDeviceAdd(struct HdfDeviceObject *obj, struct PwmDev *pwm); diff --git a/support/platform/include/regulator/regulator_core.h b/support/platform/include/regulator/regulator_core.h new file mode 100755 index 0000000000000000000000000000000000000000..163526e81e8f7bdc5189d526ae26f6822555dfb2 --- /dev/null +++ b/support/platform/include/regulator/regulator_core.h @@ -0,0 +1,204 @@ +/* + * Copyright (c) 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 REGULATOR_CORE_H +#define REGULATOR_CORE_H + +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "osal_mutex.h" +#include "regulator_if.h" + + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +#ifdef REGULATOR_PRINTK_OPEN +#define REGULATOR_PRINT_LOG_DBG(fmt, arg...) \ +dprintf("[HDF]-[REGULATOR]:[%s][%d]---" fmt "\r\n", __func__, __LINE__, ##arg) +#define REGULATOR_PRINT_LOG_INF(fmt, arg...) \ +dprintf("[HDF]-[REGULATOR]:[%s][%d]---" fmt "\r\n", __func__, __LINE__, ##arg) +#define REGULATOR_PRINT_LOG_ERR(fmt, arg...) \ +dprintf("[HDF]-[REGULATOR]:[%s][%d]---" fmt "\r\n", __func__, __LINE__, ##arg) +#else +#define REGULATOR_PRINT_LOG_DBG(fmt, arg...) HDF_LOGD_WRAPPER("[HDF]-[REGULATOR]:" fmt "\r\n", ##arg) +#define REGULATOR_PRINT_LOG_INF(fmt, arg...) HDF_LOGI_WRAPPER("[HDF]-[REGULATOR]:" fmt "\r\n", ##arg) +#define REGULATOR_PRINT_LOG_ERR(fmt, arg...) HDF_LOGE_WRAPPER("[HDF]-[REGULATOR]:" fmt "\r\n", ##arg) +#endif + +#define CHECK_NULL_PTR_RETURN_VALUE(ptr, ret) do { \ + if ((ptr) == NULL) { \ + REGULATOR_PRINT_LOG_ERR("%s:line %d pointer is null and return ret", __func__, __LINE__); \ + return (ret); \ + } \ +} while (0) + +#define CHECK_NULL_PTR_RETURN(ptr) do { \ + if ((ptr) == NULL) { \ + REGULATOR_PRINT_LOG_ERR("%s:line %d pointer is null and return", __func__, __LINE__); \ + return; \ + } \ +} while (0) + +#define CHECK_PARSER_RESULT_RETURN_VALUE(ret, str) do { \ + if (ret != HDF_SUCCESS) { \ + REGULATOR_PRINT_LOG_ERR("%s:line %d %s fail, ret = %d!", __func__, __LINE__, str, ret); \ + return HDF_FAILURE; \ + } \ +} while (0) + +struct RegulatorStatusChangeInfo { + const char *name; + uint32_t status; +}; +/** + * @brief Defines a callback that will be invoked when a regulator's status change. + * + */ +typedef int32_t (*RegulatorStatusChangecb)(struct RegulatorStatusChangeInfo *); + +struct RegulatorConstraints { + uint8_t alwaysOn; /* the regulator is alwaysOn */ + uint8_t mode; /* mode: voltage or current */ + uint32_t minUv; /* min voltage that can be set by the regulator */ + uint32_t maxUv; /* max voltage that can be set by the regulator */ + uint32_t minUa; /* min current that can be set by the regulator */ + uint32_t maxUa; /* max current that can be set by the regulator */ +}; + +struct RegulatorDesc { + const char *name; /* regulator name */ + const char *parentName; /* regulator parent name */ + struct RegulatorConstraints constraints; /* the regulator constraint info */ + uint32_t minUv; /* min voltage */ + uint32_t maxUv; /* min voltage */ + uint32_t minUa; /* min current */ + uint32_t maxUa; /* max current */ + uint32_t status; /* the regulator's status, on or off */ + int useCount; + int consumerRegNums; /* the regulator's consumer nums */ + RegulatorStatusChangecb cb; /* when regulator status change, can notify by call cb */ +}; + +struct RegulatorNode { + struct RegulatorDesc regulatorInfo; + struct DListHead node; + struct RegulatorMethod *ops; + void *priv; + struct OsalMutex lock; +}; + +struct RegulatorMethod { + int32_t (*open)(struct RegulatorNode *node); + int32_t (*close)(struct RegulatorNode *node); + int32_t (*release)(struct RegulatorNode *node); + int32_t (*enable)(struct RegulatorNode *node); + int32_t (*disable)(struct RegulatorNode *node); + int32_t (*forceDisable)(struct RegulatorNode *node); + int32_t (*setVoltage)(struct RegulatorNode *node, uint32_t minUv, uint32_t maxUv); + int32_t (*getVoltage)(struct RegulatorNode *node, uint32_t *voltage); + int32_t (*setCurrent)(struct RegulatorNode *node, uint32_t minUa, uint32_t maxUa); + int32_t (*getCurrent)(struct RegulatorNode *node, uint32_t *regCurrent); + int32_t (*getStatus)(struct RegulatorNode *node, uint32_t *status); +}; + +/** + * @brief Find and return a regulator controller by regulator info + * @param info Indicates regulator info. + * @return a regulator controller + */ +struct RegulatorNode *RegulatorNodeOpen(const char *name); +int32_t RegulatorNodeClose(struct RegulatorNode *node); +/** + * @brief add a regulator controller to manager list + * @param node Indicates a regulator controller. + * @constraints: first add parent, then add child + * @return success or fail + */ +int32_t RegulatorNodeAdd(struct RegulatorNode *node); +int32_t RegulatorNodeRemove(const char *name); +/** + * @brief remove all regulator controllers + * @param + * @return success or fail + */ +int32_t RegulatorNodeRemoveAll(void); +/** + * @brief enable a regulator + * @param node Indicates a regulator controller. + * @return success or fail + */ +int32_t RegulatorNodeEnable(struct RegulatorNode *node); +/** + * @brief disable a regulator if it's downstream node all close, if alwayson is true,forbid disable + * @param node Indicates a regulator controller. + * @return success or fail + */ +int32_t RegulatorNodeDisable(struct RegulatorNode *node); +/** + * @brief disable a regulator regardless of whether there is an downstream node + * @param node Indicates a regulator controller. + * @return success or fail + */ +int32_t RegulatorNodeForceDisable(struct RegulatorNode *node); +/** + * @brief set regulator voltage + * @param node Indicates a regulator controller. + * @param minUv min voltage + * @param maxUv max voltage + * @return success or fail + */ +int32_t RegulatorNodeSetVoltage(struct RegulatorNode *node, uint32_t minUv, uint32_t maxUv); +/** + * @brief get regulator voltage + * @param node Indicates a regulator controller. + * @param voltage regulator voltage + * @return success or fail + */ +int32_t RegulatorNodeGetVoltage(struct RegulatorNode *node, uint32_t *voltage); +/** + * @brief set regulator current + * @param node Indicates a regulator controller. + * @param minUa min current + * @param maxUa max current + * @return success or fail + */ +int32_t RegulatorNodeSetCurrent(struct RegulatorNode *node, uint32_t minUA, uint32_t maxUA); +/** + * @brief get regulator current + * @param node Indicates a regulator controller. + * @param current regulator current + * @return success or fail + */ +int32_t RegulatorNodeGetCurrent(struct RegulatorNode *node, uint32_t *regCurrent); +/** + * @brief get regulator status + * @param node Indicates a regulator controller. + * @param status regulator status,enable or disable + * @return success or fail + */ +int32_t RegulatorNodeGetStatus(struct RegulatorNode *node, uint32_t *status); +/** + * @brief register regulator's callback when it's status change + * @param node Indicates a regulator controller. + * @param cb callback function + * @return success or fail + */ +int32_t RegulatorNodeRegisterStatusChangeCb(struct RegulatorNode *node, RegulatorStatusChangecb cb); +int32_t RegulatorNodeStatusCb(struct RegulatorNode *node); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* REGULATOR_CORE_H */ diff --git a/support/platform/include/regulator/regulator_tree_mgr.h b/support/platform/include/regulator/regulator_tree_mgr.h new file mode 100755 index 0000000000000000000000000000000000000000..eecd4b2f2a40b1086fb239adcf2ecad28ca50534 --- /dev/null +++ b/support/platform/include/regulator/regulator_tree_mgr.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 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 REGULATOR_TREE_MGR_H +#define REGULATOR_TREE_MGR_H + +#include "regulator_core.h" +#include "hdf_log.h" +#include "hdf_base.h" +#include "osal_mutex.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif /* __cplusplus */ +#endif /* __cplusplus */ + +struct RegulatorChildNode { + struct RegulatorNode *child; + struct DListHead node; +}; + +struct RegulatorTreeInfo { + const char *name; /* regulator name */ + struct RegulatorNode *parent; /* regulator parent info */ + struct DListHead node; + struct DListHead childHead; /* next level child regulator list */ +}; + +struct RegulatorTreeManager { + struct DListHead treeMgrHead; + struct OsalMutex lock; +}; + +int RegulatorTreeManagerInit(void); +int RegulatorTreeManagerDestory(void); +int RegulatorTreeNodeRemoveAll(void); +int RegulatorTreeSet(const char *name, struct RegulatorNode *child, struct RegulatorNode *parent); +void RegulatorTreePrint(void); +struct RegulatorNode *RegulatorTreeGetParent(const char *name); +int32_t RegulatorTreeChildForceDisable(struct RegulatorNode *node); +bool RegulatorTreeIsAllChildDisable(const char *name); +bool RegulatorTreeIsChildAlwayson(const char *name); +bool RegulatorTreeIsChildStatusOn(const char *name); +bool RegulatorTreeIsUpNodeComplete(const char *name); + +#ifdef __cplusplus +#if __cplusplus +} +#endif /* __cplusplus */ +#endif /* __cplusplus */ + +#endif /* REGULATOR_TREE_MGR_H */ diff --git a/support/platform/include/rtc_base.h b/support/platform/include/rtc/rtc_base.h similarity index 100% rename from support/platform/include/rtc_base.h rename to support/platform/include/rtc/rtc_base.h diff --git a/support/platform/include/rtc_core.h b/support/platform/include/rtc/rtc_core.h similarity index 100% rename from support/platform/include/rtc_core.h rename to support/platform/include/rtc/rtc_core.h diff --git a/support/platform/include/spi_core.h b/support/platform/include/spi/spi_core.h similarity index 100% rename from support/platform/include/spi_core.h rename to support/platform/include/spi/spi_core.h diff --git a/support/platform/include/uart_core.h b/support/platform/include/uart/uart_core.h similarity index 100% rename from support/platform/include/uart_core.h rename to support/platform/include/uart/uart_core.h diff --git a/support/platform/include/watchdog_core.h b/support/platform/include/watchdog/watchdog_core.h similarity index 98% rename from support/platform/include/watchdog_core.h rename to support/platform/include/watchdog/watchdog_core.h index 8462047354638bf5c4c3c880511b700e1d5bcf43..7af3ce29f7d8cf16674cef1ea2bc5605e02efae2 100644 --- a/support/platform/include/watchdog_core.h +++ b/support/platform/include/watchdog/watchdog_core.h @@ -100,7 +100,7 @@ int32_t WatchdogCntlrGetTimeout(struct WatchdogCntlr *cntlr, uint32_t *seconds); int32_t WatchdogCntlrFeed(struct WatchdogCntlr *cntlr); -void WatchdogGetPrivData(struct WatchdogCntlr *cntlr); +int32_t WatchdogGetPrivData(struct WatchdogCntlr *cntlr); void WatchdogReleasePriv(struct WatchdogCntlr *cntlr); diff --git a/support/platform/src/adc_core.c b/support/platform/src/adc/adc_core.c similarity index 99% rename from support/platform/src/adc_core.c rename to support/platform/src/adc/adc_core.c index 5392d960a7a2425f71c1d49beaffacb9033b0b72..f53fecae644224499a12c62eb30aefddee801fb3 100644 --- a/support/platform/src/adc_core.c +++ b/support/platform/src/adc/adc_core.c @@ -13,7 +13,6 @@ #include "osal_spinlock.h" #include "osal_time.h" #include "platform_core.h" -#include "plat_log.h" #define HDF_LOG_TAG adc_core_c #define LOCK_WAIT_SECONDS_M 1 diff --git a/support/platform/src/adc_if.c b/support/platform/src/adc/adc_if.c similarity index 100% rename from support/platform/src/adc_if.c rename to support/platform/src/adc/adc_if.c diff --git a/support/platform/src/dac/dac_core.c b/support/platform/src/dac/dac_core.c new file mode 100644 index 0000000000000000000000000000000000000000..2454ae6f5f6fe9f9ace69f97942c4f3fbcb19f52 --- /dev/null +++ b/support/platform/src/dac/dac_core.c @@ -0,0 +1,398 @@ +/* + * Copyright (c) 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 "dac_core.h" +#include "hdf_device_desc.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "osal_spinlock.h" +#include "osal_time.h" +#include "platform_core.h" + +#define HDF_LOG_TAG dac_core_c + +struct DacManager { + struct IDeviceIoService service; + struct HdfDeviceObject *device; + struct DacDevice *devices[DAC_DEVICES_MAX]; + OsalSpinlock spin; +}; + +static struct DacManager *g_dacManager = NULL; + +static int32_t DacDeviceLockDefault(struct DacDevice *device) +{ + if (device == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + return OsalSpinLock(&device->spin); +} + +static void DacDeviceUnlockDefault(struct DacDevice *device) +{ + if (device == NULL) { + return; + } + (void)OsalSpinUnlock(&device->spin); +} + +static const struct DacLockMethod g_dacLockOpsDefault = { + .lock = DacDeviceLockDefault, + .unlock = DacDeviceUnlockDefault, +}; + +static int32_t DacManagerAddDevice(struct DacDevice *device) +{ + int32_t ret; + struct DacManager *manager = g_dacManager; + + if (device->devNum >= DAC_DEVICES_MAX) { + HDF_LOGE("%s: devNum:%u exceed", __func__, device->devNum); + return HDF_ERR_INVALID_OBJECT; + } + + if (manager == NULL) { + HDF_LOGE("%s: get dac manager fail", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (OsalSpinLockIrq(&manager->spin) != HDF_SUCCESS) { + HDF_LOGE("%s: lock dac manager fail", __func__); + return HDF_ERR_DEVICE_BUSY; + } + + if (manager->devices[device->devNum] != NULL) { + HDF_LOGE("%s: dac device num:%u alwritey exits", __func__, device->devNum); + ret = HDF_FAILURE; + } else { + manager->devices[device->devNum] = device; + HDF_LOGE("%s: device:%p", __func__, manager->devices[0]); + ret = HDF_SUCCESS; + } + + (void)OsalSpinUnlockIrq(&manager->spin); + return ret; +} + +static void DacManagerRemoveDevice(struct DacDevice *device) +{ + struct DacManager *manager = g_dacManager; + + if (device->devNum < 0 || device->devNum >= DAC_DEVICES_MAX) { + HDF_LOGE("%s: invalid devNum:%u", __func__, device->devNum); + return; + } + + if (manager == NULL) { + HDF_LOGE("%s: get dac manager fail", __func__); + return; + } + + if (OsalSpinLockIrq(&manager->spin) != HDF_SUCCESS) { + HDF_LOGE("%s: lock dac manager fail", __func__); + return; + } + + if (manager->devices[device->devNum] != device) { + HDF_LOGE("%s: dac device(%u) not in manager", __func__, device->devNum); + } else { + manager->devices[device->devNum] = NULL; + } + + (void)OsalSpinUnlockIrq(&manager->spin); +} + +static struct DacDevice *DacManagerFindDevice(uint32_t number) +{ + struct DacDevice *device = NULL; + struct DacManager *manager = g_dacManager; + + if (number < 0 || number >= DAC_DEVICES_MAX) { + HDF_LOGE("%s: invalid devNum:%u", __func__, number); + return NULL; + } + + if (manager == NULL) { + HDF_LOGE("%s: get dac manager fail", __func__); + return NULL; + } + + if (OsalSpinLockIrq(&manager->spin) != HDF_SUCCESS) { + HDF_LOGE("%s: lock dac manager fail", __func__); + return NULL; + } + + device = manager->devices[number]; + (void)OsalSpinUnlockIrq(&manager->spin); + + return device; +} + +int32_t DacDeviceAdd(struct DacDevice *device) +{ + int32_t ret; + + if (device == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + if (device->ops == NULL) { + HDF_LOGE("%s: no ops supplied", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (device->lockOps == NULL) { + HDF_LOGI("%s: use default lockOps!", __func__); + device->lockOps = &g_dacLockOpsDefault; + } + + if (OsalSpinInit(&device->spin) != HDF_SUCCESS) { + HDF_LOGE("%s: init lock failed", __func__); + return HDF_FAILURE; + } + + ret = DacManagerAddDevice(device); + if (ret != HDF_SUCCESS) { + (void)OsalSpinDestroy(&device->spin); + } + return ret; +} + +void DacDeviceRemove(struct DacDevice *device) +{ + if (device == NULL) { + return; + } + DacManagerRemoveDevice(device); + (void)OsalSpinDestroy(&device->spin); +} + +struct DacDevice *DacDeviceGet(uint32_t number) +{ + return DacManagerFindDevice(number); +} + +void DacDevicePut(struct DacDevice *device) +{ + (void)device; +} + +static inline int32_t DacDeviceLock(struct DacDevice *device) +{ + if (device->lockOps == NULL || device->lockOps->lock == NULL) { + return HDF_ERR_NOT_SUPPORT; + } + return device->lockOps->lock(device); +} + +static inline void DacDeviceUnlock(struct DacDevice *device) +{ + if (device->lockOps != NULL && device->lockOps->unlock != NULL) { + device->lockOps->unlock(device); + } +} + +int32_t DacDeviceWrite(struct DacDevice *device, uint32_t channel, uint32_t val) +{ + int32_t ret; + + if (device == NULL) { + HDF_LOGE("%s: device is null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (device->ops == NULL || device->ops->write == NULL) { + HDF_LOGE("%s: ops or write is null", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (DacDeviceLock(device) != HDF_SUCCESS) { + HDF_LOGE("%s: lock add device failed", __func__); + return HDF_ERR_DEVICE_BUSY; + } + + ret = device->ops->write(device, channel, val); + DacDeviceUnlock(device); + return ret; +} + +int32_t DacDeviceStart(struct DacDevice *device) +{ + int32_t ret; + + if (device == NULL) { + HDF_LOGE("%s: device is null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (device->ops == NULL || device->ops->start == NULL) { + HDF_LOGE("%s: ops or start is null", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (DacDeviceLock(device) != HDF_SUCCESS) { + HDF_LOGE("%s: lock add device failed", __func__); + return HDF_ERR_DEVICE_BUSY; + } + + ret = device->ops->start(device); + DacDeviceUnlock(device); + return ret; +} + +int32_t DacDeviceStop(struct DacDevice *device) +{ + int32_t ret; + + if (device == NULL) { + HDF_LOGE("%s: device is null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (device->ops == NULL || device->ops->stop == NULL) { + HDF_LOGE("%s: ops or stop is null", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (DacDeviceLock(device) != HDF_SUCCESS) { + HDF_LOGE("%s: lock add device failed", __func__); + return HDF_ERR_DEVICE_BUSY; + } + + ret = device->ops->stop(device); + DacDeviceUnlock(device); + return ret; +} + +static int32_t DacManagerIoOpen(struct HdfSBuf *data, struct HdfSBuf *reply) +{ + uint32_t number; + + if (data == NULL || reply == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (!HdfSbufReadUint32(data, &number)) { + return HDF_ERR_IO; + } + + if (number < 0 || number >= DAC_DEVICES_MAX || reply == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (DacDeviceGet(number) == NULL) { + return HDF_ERR_NOT_SUPPORT; + } + + if (!HdfSbufWriteUint32(reply, number)) { + return HDF_ERR_IO; + } + return HDF_SUCCESS; +} + +static int32_t DacManagerIoClose(struct HdfSBuf *data, struct HdfSBuf *reply) +{ + uint32_t number; + + if (data == NULL || reply == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (!HdfSbufReadUint32(data, &number)) { + return HDF_ERR_IO; + } + + if (number < 0 || number >= DAC_DEVICES_MAX) { + return HDF_ERR_INVALID_PARAM; + } + DacDevicePut(DacManagerFindDevice(number)); + return HDF_SUCCESS; +} + +static int32_t DacManagerIoRead(struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)data; + (void)reply; + return HDF_SUCCESS; +} + +static int32_t DacManagerDispatch(struct HdfDeviceIoClient *client, int cmd, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + int32_t ret; + + switch (cmd) { + case DAC_IO_OPEN: + return DacManagerIoOpen(data, reply); + case DAC_IO_CLOSE: + return DacManagerIoClose(data, reply); + case DAC_IO_READ: + return DacManagerIoRead(data, reply); + default: + ret = HDF_ERR_NOT_SUPPORT; + break; + } + return ret; +} + +static int32_t DacManagerInit(struct HdfDeviceObject *device) +{ + int32_t ret; + struct DacManager *manager = NULL; + + if (device == NULL) { + HDF_LOGE("%s: device is null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + manager = (struct DacManager *)OsalMemCalloc(sizeof(*manager)); + if (manager == NULL) { + HDF_LOGE("%s: alloc manager failed", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + ret = OsalSpinInit(&manager->spin); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: spinlock init failed", __func__); + OsalMemFree(manager); + return HDF_FAILURE; + } + + manager->device = device; + g_dacManager = manager; + device->service = &manager->service; + device->service->Dispatch = DacManagerDispatch; + return HDF_SUCCESS; +} + +static void DacManagerRelease(struct HdfDeviceObject *device) +{ + struct DacManager *manager = NULL; + + if (device == NULL) { + HDF_LOGE("%s: device is null", __func__); + return; + } + + manager = (struct DacManager *)device->service; + if (manager == NULL) { + HDF_LOGI("%s: no service bind", __func__); + return; + } + + g_dacManager = NULL; + OsalMemFree(manager); +} + +struct HdfDriverEntry g_dacManagerEntry = { + .moduleVersion = 1, + .Init = DacManagerInit, + .Release = DacManagerRelease, + .moduleName = "HDF_PLATFORM_DAC_MANAGER", +}; +HDF_INIT(g_dacManagerEntry); diff --git a/support/platform/src/dac/dac_if.c b/support/platform/src/dac/dac_if.c new file mode 100644 index 0000000000000000000000000000000000000000..4d188d944c1d9ad77cf124368e9230f5e496efaa --- /dev/null +++ b/support/platform/src/dac/dac_if.c @@ -0,0 +1,56 @@ +/* + * Copyright (c) 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 "dac_if.h" +#include "dac_core.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "securec.h" +#define HDF_LOG_TAG dac_if_c +#define DAC_SERVICE_NAME "HDF_PLATFORM_DAC_MANAGER" + +DevHandle DacOpen(uint32_t number) +{ + int32_t ret; + struct DacDevice *device = NULL; + + device = DacDeviceGet(number); + if (device == NULL) { + HDF_LOGE("%s: Get device failed!", __func__); + return NULL; + } + + ret = DacDeviceStart(device); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: start device failed!", __func__); + return NULL; + } + + return (DevHandle)device; +} + +void DacClose(DevHandle handle) +{ + struct DacDevice *device = (struct DacDevice *)handle; + + if (device == NULL) { + return; + } + + (void)DacDeviceStop(device); + DacDevicePut(device); +} + +int32_t DacWrite(DevHandle handle, uint32_t channel, uint32_t val) +{ + if (handle == NULL) { + HDF_LOGE("%s: invalid handle!", __func__); + return HDF_ERR_INVALID_PARAM; + } + return DacDeviceWrite((struct DacDevice *)handle, channel, val); +} diff --git a/support/platform/src/dmac_core.c b/support/platform/src/dma/dmac_core.c similarity index 99% rename from support/platform/src/dmac_core.c rename to support/platform/src/dma/dmac_core.c index c5d529f0bd4317fb1b935ea7e446f85ef4626d3f..d0e51490aefba22fcf0016257553a1e72e0b96a0 100644 --- a/support/platform/src/dmac_core.c +++ b/support/platform/src/dma/dmac_core.c @@ -229,6 +229,7 @@ static void DmacFreeChannel(struct DmaCntlr *cntlr, uint16_t channel) } OsalSpinLockIrqSave(&cntlr->lock, &flags); + DmacFreeLli(&cntlr->channelList[channel]); cntlr->channelList[channel].useStatus = DMAC_CHN_VACANCY; OsalSpinUnlockIrqRestore(&cntlr->lock, &flags); } @@ -279,7 +280,7 @@ static inline size_t DmacAlignedTransMax(size_t maxSize, uint8_t srcWidth, uint8 size_t ret; uint8_t maxWidth = (srcWidth >= destWidth) ? srcWidth : destWidth; - ret = (maxWidth == 0) ? maxSize : maxSize - (maxSize % maxWidth); + ret = ((maxWidth == 0) ? maxSize : (maxSize - (maxSize % maxWidth))); #ifdef DMA_CORE_DEBUG HDF_LOGD("%s: max:%zu, srcwidth:%u, dstwidth:%u, alignedmax:%zu", __func__, maxSize, srcWidth, destWidth, ret); #endif diff --git a/support/platform/src/common/platform_common.c b/support/platform/src/fwk/platform_common.c similarity index 96% rename from support/platform/src/common/platform_common.c rename to support/platform/src/fwk/platform_common.c index 462331a55c8702a4aa3b1c2941970e789047b9ef..774a84bc9a6fccabd47ee4daaf5158b2b90538fd 100644 --- a/support/platform/src/common/platform_common.c +++ b/support/platform/src/fwk/platform_common.c @@ -53,6 +53,12 @@ static struct PlatformModuleInfo g_platformModules[] = { .moduleName = "PLATFORM_MODULE_MIPI_DSI", }, #endif +#if defined(LOSCFG_DRIVERS_HDF_PLATFORM_MIPI_CSI) || defined(CONFIG_DRIVERS_HDF_PLATFORM_MIPI_CSI) + { + .moduleType = PLATFORM_MODULE_MIPI_CSI, + .moduleName = "PLATFORM_MODULE_MIPI_CSI", + }, +#endif #if defined(LOSCFG_DRIVERS_HDF_PLATFORM_UART) || defined(CONFIG_DRIVERS_HDF_PLATFORM_UART) { .moduleType = PLATFORM_MODULE_UART, diff --git a/support/platform/src/common/platform_device.c b/support/platform/src/fwk/platform_device.c similarity index 72% rename from support/platform/src/common/platform_device.c rename to support/platform/src/fwk/platform_device.c index 882e5213b3f8a91dd69ea969669fee181a0e10ed..cc162fe86b9893bd90a147b4679ee30cd9de32f6 100755 --- a/support/platform/src/common/platform_device.c +++ b/support/platform/src/fwk/platform_device.c @@ -22,8 +22,7 @@ static void PlatformDeviceOnFirstGet(struct HdfSRef *sref) static void PlatformDeviceOnLastPut(struct HdfSRef *sref) { struct PlatformDevice *device = NULL; - struct PlatformNotifierNode *pos = NULL; - struct PlatformNotifierNode *tmp = NULL; + int32_t ret; if (sref == NULL) { return; @@ -34,16 +33,13 @@ static void PlatformDeviceOnLastPut(struct HdfSRef *sref) HDF_LOGE("PlatformDeviceOnLastPut: get device is NULL!"); return; } - (void)OsalSpinLock(&device->spin); device->ready = false; - DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &device->notifiers, struct PlatformNotifierNode, node) { - if (pos->notifier != NULL && pos->notifier->handle != NULL) { - pos->notifier->handle(device, PLAT_EVENT_DEAD, pos->notifier->data); - } + ret = PlatformDeviceNotify(device, PLAT_EVENT_DEAD); + if (ret != HDF_SUCCESS) { + HDF_LOGE("PlatformDeviceOnLastPut: PlatformDeviceNotify failed!, ret = %d", ret); + return; } - - (void)OsalSpinUnlock(&device->spin); } struct IHdfSRefListener g_platObjListener = { @@ -184,6 +180,23 @@ void PlatformDeviceClearNotifier(struct PlatformDevice *device) PlatformDeviceRemoveNotifier(device, NULL); } +int32_t PlatformDeviceNotify(struct PlatformDevice *device, int32_t event) +{ + struct PlatformNotifierNode *pos = NULL; + struct PlatformNotifierNode *tmp = NULL; + + (void)OsalSpinLock(&device->spin); + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &device->notifiers, struct PlatformNotifierNode, node) { + if (pos->notifier != NULL && pos->notifier->handle != NULL) { + pos->notifier->handle(device, event, pos->notifier->data); + } + } + + (void)OsalSpinUnlock(&device->spin); + return HDF_SUCCESS; +} + int32_t PlatformDeviceAdd(struct PlatformDevice *device) { struct PlatformManager *manager = NULL; @@ -215,3 +228,72 @@ void PlatformDeviceDel(struct PlatformDevice *device) PlatformManagerDelDevice(manager, device); PlatformDeviceUninit(device); } + +int32_t PlatformDeviceCreateService(struct PlatformDevice *device, + int32_t (*dispatch)(struct HdfDeviceIoClient *client, int cmd, struct HdfSBuf *data, struct HdfSBuf *reply)) +{ + if (device == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + if (device->service != NULL) { + HDF_LOGE("%s: service already creatted!", __func__); + return HDF_FAILURE; + } + + device->service = (struct IDeviceIoService *)OsalMemCalloc(sizeof(*(device->service))); + if (device->service == NULL) { + HDF_LOGE("%s: alloc service failed!", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + device->service->Dispatch = dispatch; + return HDF_SUCCESS; +} + +int32_t PlatformDeviceDestroyService(struct PlatformDevice *device) +{ + if (device == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + if (device->service != NULL) { + HDF_LOGE("%s: service not creatted!", __func__); + return HDF_FAILURE; + } + + OsalMemFree(device->service); + device->service = NULL; + return HDF_SUCCESS; +} + +int32_t PlatformDeviceBind(struct PlatformDevice *device, struct HdfDeviceObject *hdfDevice) +{ + if (device == NULL || hdfDevice == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + if (device->hdfDev != NULL) { + HDF_LOGE("%s: already bind a hdf device!", __func__); + return HDF_FAILURE; + } + + device->hdfDev = hdfDevice; + hdfDevice->service = device->service; + return HDF_SUCCESS; +} + +int32_t PlatformDeviceUnbind(struct PlatformDevice *device) +{ + if (device == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + if (device->hdfDev == NULL) { + HDF_LOGE("%s: no hdf device binded!", __func__); + return HDF_FAILURE; + } + + device->hdfDev->service = NULL; + device->hdfDev = NULL; + return HDF_SUCCESS; +} diff --git a/support/platform/src/common/platform_manager.c b/support/platform/src/fwk/platform_manager.c similarity index 75% rename from support/platform/src/common/platform_manager.c rename to support/platform/src/fwk/platform_manager.c index 4b1ff4803bd406514b4c668ee50e0a9989fc78aa..631aa9544b65e2aea1b69fba2ac0397a40596f26 100644 --- a/support/platform/src/common/platform_manager.c +++ b/support/platform/src/fwk/platform_manager.c @@ -23,6 +23,10 @@ static void PlatformManagerInit(struct PlatformManager *manager) OsalSpinInit(&manager->spin); DListHeadInit(&manager->devices); + PlatformDeviceInit(&manager->device); + PlatformDeviceGet(&manager->device); + manager->add = NULL; + manager->del = NULL; } struct PlatformManager *PlatformManagerCreate(const char *name) @@ -62,37 +66,58 @@ struct PlatformManager *PlatformManagerGet(enum PlatformModuleType module) return manager; } -int32_t PlatformManagerAddDevice(struct PlatformManager *manager, struct PlatformDevice *device) +static int32_t PlatformManagerAddDeviceDefault(struct PlatformManager *manager, struct PlatformDevice *device) { struct PlatformDevice *tmp = NULL; bool repeatId = false; - if (manager == NULL || device == NULL) { - return HDF_ERR_INVALID_OBJECT; - } - device->manager = manager; - if (PlatformDeviceGet(device) == NULL) { // keep a reference by manager return HDF_PLT_ERR_DEV_GET; } - (void)OsalSpinLock(&manager->spin); DLIST_FOR_EACH_ENTRY(tmp, &manager->devices, struct PlatformDevice, node) { - if (tmp != NULL && tmp->magic == device->magic) { + if (tmp != NULL && tmp->number == device->number) { repeatId = true; - HDF_LOGE("PlatformManagerAddDevice: repeated magic:%u!", device->magic); + HDF_LOGE("PlatformManagerAddDevice: repeated number:%u!", device->number); break; } } if (!repeatId) { DListInsertTail(&device->node, &manager->devices); + device->manager = manager; + } else { + PlatformDevicePut(device); + } + + return repeatId ? HDF_PLT_ERR_ID_REPEAT : HDF_SUCCESS; +} + +int32_t PlatformManagerAddDevice(struct PlatformManager *manager, struct PlatformDevice *device) +{ + int32_t ret; + + if (manager == NULL || device == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + (void)OsalSpinLock(&manager->spin); + if (manager->add != NULL) { + ret = manager->add(manager, device); + } else { + ret = PlatformManagerAddDeviceDefault(manager, device); } (void)OsalSpinUnlock(&manager->spin); - if (repeatId) { - PlatformDevicePut(device); + return ret; +} + +static int32_t PlatformManagerDelDeviceDefault(struct PlatformManager *manager, struct PlatformDevice *device) +{ + if (!DListIsEmpty(&device->node)) { + DListRemove(&device->node); } - return repeatId ? HDF_PLT_ERR_ID_REPEAT : HDF_SUCCESS; + PlatformDevicePut(device); // put the reference hold by manager + return HDF_SUCCESS; } void PlatformManagerDelDevice(struct PlatformManager *manager, struct PlatformDevice *device) @@ -107,11 +132,12 @@ void PlatformManagerDelDevice(struct PlatformManager *manager, struct PlatformDe } (void)OsalSpinLock(&manager->spin); - if (!DListIsEmpty(&device->node)) { - DListRemove(&device->node); + if (manager->del != NULL) { + (void)manager->del(manager, device); + } else { + (void)PlatformManagerDelDeviceDefault(manager, device); } (void)OsalSpinUnlock(&manager->spin); - PlatformDevicePut(device); // put the reference hold by manager } struct PlatformDevice *PlatformManagerFindDevice(struct PlatformManager *manager, void *data, @@ -139,17 +165,17 @@ struct PlatformDevice *PlatformManagerFindDevice(struct PlatformManager *manager return pdevice; } -static bool PlatformDeviceMatchByMagic(struct PlatformDevice *device, void *data) +static bool PlatformDeviceMatchByNumber(struct PlatformDevice *device, void *data) { - uint32_t magic = (uint32_t)(uintptr_t)data; + uint32_t number = (uint32_t)(uintptr_t)data; - return (device != NULL && device->magic == magic); + return (device != NULL && device->number == number); } -struct PlatformDevice *PlatformManagerGetDeviceByMagic(struct PlatformManager *manager, uint32_t magic) +struct PlatformDevice *PlatformManagerGetDeviceByNumber(struct PlatformManager *manager, uint32_t number) { if (manager == NULL) { return NULL; } - return PlatformManagerFindDevice(manager, (void *)(uintptr_t)magic, PlatformDeviceMatchByMagic); + return PlatformManagerFindDevice(manager, (void *)(uintptr_t)number, PlatformDeviceMatchByNumber); } diff --git a/support/platform/src/common/platform_queue.c b/support/platform/src/fwk/platform_queue.c similarity index 100% rename from support/platform/src/common/platform_queue.c rename to support/platform/src/fwk/platform_queue.c diff --git a/support/platform/src/gpio_core.c b/support/platform/src/gpio/gpio_core.c similarity index 62% rename from support/platform/src/gpio_core.c rename to support/platform/src/gpio/gpio_core.c index f387a3475e63c4ad9f8aa93817f5474ff648b224..912a0e9bc406159fe6480a55d368f936c2a94827 100644 --- a/support/platform/src/gpio_core.c +++ b/support/platform/src/gpio/gpio_core.c @@ -6,17 +6,13 @@ * See the LICENSE file in the root of this repository for complete details. */ -#include "gpio_core.h" -#include "hdf_log.h" +#include "gpio/gpio_core.h" #include "osal_mem.h" -#include "osal_sem.h" -#include "osal_thread.h" -#include "plat_log.h" +#include "platform_core.h" #include "securec.h" #define HDF_LOG_TAG gpio_core -#define MAX_CNT_PER_CNTLR 1024 #define GPIO_IRQ_STACK_SIZE 10000 #define GPIO_IRQ_THREAD_NAME_LEN 32 @@ -32,158 +28,6 @@ struct GpioIrqBridge { bool stop; }; -static struct DListHead g_cntlrList; -static OsalSpinlock g_listLock; -static uint32_t g_irqFlags; - -static struct DListHead *GpioCntlrListGet(void) -{ - static struct DListHead *list = NULL; - uint32_t flags; - - if (list == NULL) { - list = &g_cntlrList; - DListHeadInit(list); - OsalSpinInit(&g_listLock); - } - while (OsalSpinLockIrqSave(&g_listLock, &flags) != HDF_SUCCESS); - g_irqFlags = flags; - return list; -} - -static void GpioCntlrListPut(void) -{ - (void)OsalSpinUnlockIrqRestore(&g_listLock, &g_irqFlags); -} - -static uint16_t GpioCntlrQueryStart(struct GpioCntlr *cntlr, struct DListHead *list) -{ - uint16_t freeStart; - uint16_t freeCount; - struct GpioCntlr *iterLast = NULL; - struct GpioCntlr *iterCur = NULL; - struct GpioCntlr *tmp = NULL; - - DLIST_FOR_EACH_ENTRY_SAFE(iterCur, tmp, list, struct GpioCntlr, list) { - if (iterLast == NULL) { - freeStart = 0; - freeCount = iterCur->start; - } else { - freeStart = iterLast->start + iterLast->count; - freeCount = iterCur->start - freeStart; - } - - if (cntlr->start < freeStart) { - HDF_LOGE("GpioCntlrQueryStart: start:%u not available(freeStart:%u, freeCount:%u)", - cntlr->start, freeStart, freeCount); - return GPIO_NUM_MAX; - } - - if ((cntlr->start + cntlr->count) <= (freeStart + freeCount)) { - return freeStart; - } - - iterLast = iterCur; - } - if (iterLast == NULL) { // empty list - return cntlr->start; - } - if (cntlr->start >= (iterLast->start + iterLast->count)) { - return iterLast->start + iterLast->count; - } - HDF_LOGE("GpioCntlrQueryStart: start:%u not available(lastStart:%u, lastCount:%u)", - cntlr->start, iterLast->start, iterLast->count); - return GPIO_NUM_MAX; -} - -int32_t GpioCntlrAdd(struct GpioCntlr *cntlr) -{ - uint16_t start; - struct DListHead *list = NULL; - - if (cntlr == NULL) { - return HDF_ERR_INVALID_OBJECT; - } - - if (cntlr->device == NULL) { - HDF_LOGE("GpioCntlrAdd: no device associated!"); - return HDF_ERR_INVALID_OBJECT; - } - - if (cntlr->ops == NULL) { - HDF_LOGE("GpioCntlrAdd: no ops supplied!"); - return HDF_ERR_INVALID_OBJECT; - } - - if (cntlr->count >= MAX_CNT_PER_CNTLR) { - HDF_LOGE("GpioCntlrAdd: invalid gpio count:%u", cntlr->count); - return HDF_ERR_INVALID_PARAM; - } - - if (cntlr->ginfos == NULL) { - cntlr->ginfos = OsalMemCalloc(sizeof(*cntlr->ginfos) * cntlr->count); - if (cntlr->ginfos == NULL) { - return HDF_ERR_MALLOC_FAIL; - } - } - - OsalSpinInit(&cntlr->spin); - - list = GpioCntlrListGet(); - if ((start = GpioCntlrQueryStart(cntlr, list)) >= GPIO_NUM_MAX) { - HDF_LOGE("GpioCntlrAdd: query range for start:%d fail:%d", cntlr->start, start); - GpioCntlrListPut(); - return HDF_ERR_INVALID_PARAM; - } - cntlr->start = start; - DListHeadInit(&cntlr->list); - DListInsertTail(&cntlr->list, list); - GpioCntlrListPut(); - HDF_LOGI("GpioCntlrAdd: start:%u count:%u", cntlr->start, cntlr->count); - - return HDF_SUCCESS; -} - -void GpioCntlrRemove(struct GpioCntlr *cntlr) -{ - if (cntlr == NULL) { - return; - } - - if (cntlr->device == NULL) { - HDF_LOGE("GpioCntlrRemove: no device associated!"); - return; - } - - cntlr->device->service = NULL; - (void)GpioCntlrListGet(); - DListRemove(&cntlr->list); - GpioCntlrListPut(); - if (cntlr->ginfos != NULL) { - OsalMemFree(cntlr->ginfos); - cntlr->ginfos = NULL; - } - (void)OsalSpinDestroy(&cntlr->spin); -} - -struct GpioCntlr *GpioGetCntlr(uint16_t gpio) -{ - struct DListHead *list = NULL; - struct GpioCntlr *cntlr = NULL; - struct GpioCntlr *tmp = NULL; - - list = GpioCntlrListGet(); - DLIST_FOR_EACH_ENTRY_SAFE(cntlr, tmp, list, struct GpioCntlr, list) { - if (gpio >= cntlr->start && gpio < (cntlr->start + cntlr->count)) { - GpioCntlrListPut(); - return cntlr; - } - } - GpioCntlrListPut(); - HDF_LOGE("GpioGetCntlr: gpio %u not in any controllers!", gpio); - return NULL; -} - int32_t GpioCntlrWrite(struct GpioCntlr *cntlr, uint16_t local, uint16_t val) { if (cntlr == NULL) { @@ -279,7 +123,7 @@ static int GpioIrqThreadWorker(void *data) (void)OsalSemDestroy(&bridge->sem); (void)OsalSpinDestroy(&bridge->spin); OsalMemFree(bridge); - HDF_LOGI("GpioIrqThreadWorker: normal exit!"); + PLAT_LOGI("GpioIrqThreadWorker: normal exit!"); return HDF_SUCCESS; } @@ -303,23 +147,23 @@ static struct GpioIrqBridge *GpioIrqBridgeCreate(struct GpioCntlr *cntlr, if (snprintf_s(bridge->name, GPIO_IRQ_THREAD_NAME_LEN, GPIO_IRQ_THREAD_NAME_LEN - 1, "GPIO_IRQ_TSK_%d_%d", bridge->cntlr->start, bridge->local) < 0) { - HDF_LOGE("GpioIrqBridgeCreate: format thread name fail!"); + PLAT_LOGE("GpioIrqBridgeCreate: format thread name fail!"); goto __ERR_FORMAT_NAME; } if (OsalSpinInit(&bridge->spin) != HDF_SUCCESS) { - HDF_LOGE("GpioIrqBridgeCreate: init spin fail!"); + PLAT_LOGE("GpioIrqBridgeCreate: init spin fail!"); goto __ERR_INIT_SPIN; } if (OsalSemInit(&bridge->sem, 0) != HDF_SUCCESS) { - HDF_LOGE("GpioIrqBridgeCreate: init sem fail!"); + PLAT_LOGE("GpioIrqBridgeCreate: init sem fail!"); goto __ERR_INIT_SEM; } ret = OsalThreadCreate(&bridge->thread, (OsalThreadEntry)GpioIrqThreadWorker, (void *)bridge); if (ret != HDF_SUCCESS) { - HDF_LOGE("GpioIrqBridgeCreate: create irq fail!"); + PLAT_LOGE("GpioIrqBridgeCreate: create irq fail!"); goto __ERR_CREATE_THREAD; } @@ -327,7 +171,7 @@ static struct GpioIrqBridge *GpioIrqBridgeCreate(struct GpioCntlr *cntlr, cfg.priority = OSAL_THREAD_PRI_HIGH; cfg.stackSize = GPIO_IRQ_STACK_SIZE; if (OsalThreadStart(&bridge->thread, &cfg) != HDF_SUCCESS) { - HDF_LOGE("GpioIrqBridgeCreate: start irq thread fail:%d", ret); + PLAT_LOGE("GpioIrqBridgeCreate: start irq thread fail:%d", ret); goto __ERR_START_THREAD; } return bridge; @@ -363,10 +207,10 @@ void GpioCntlrIrqCallback(struct GpioCntlr *cntlr, uint16_t local) if (ginfo != NULL && ginfo->irqFunc != NULL) { (void)ginfo->irqFunc(local, ginfo->irqData); } else { - HDF_LOGW("GpioCntlrIrqCallback: ginfo or irqFunc is NULL!"); + PLAT_LOGW("GpioCntlrIrqCallback: ginfo or irqFunc is NULL!"); } } else { - HDF_LOGW("GpioCntlrIrqCallback: invalid cntlr(ginfos) or loal num:%u!", local); + PLAT_LOGW("GpioCntlrIrqCallback: invalid cntlr(ginfos) or loal num:%u!", local); } } @@ -401,7 +245,7 @@ int32_t GpioCntlrSetIrq(struct GpioCntlr *cntlr, uint16_t local, uint16_t mode, } } - (void)OsalSpinLockIrqSave(&cntlr->spin, &flags); + (void)OsalSpinLockIrqSave(&cntlr->device.spin, &flags); oldFunc = cntlr->ginfos[local].irqFunc; oldData = cntlr->ginfos[local].irqData; cntlr->ginfos[local].irqFunc = theFunc; @@ -419,7 +263,7 @@ int32_t GpioCntlrSetIrq(struct GpioCntlr *cntlr, uint16_t local, uint16_t mode, bridge = NULL; } } - (void)OsalSpinUnlockIrqRestore(&cntlr->spin, &flags); + (void)OsalSpinUnlockIrqRestore(&cntlr->device.spin, &flags); return ret; } @@ -439,7 +283,7 @@ int32_t GpioCntlrUnsetIrq(struct GpioCntlr *cntlr, uint16_t local) return HDF_ERR_NOT_SUPPORT; } - (void)OsalSpinLockIrqSave(&cntlr->spin, &flags); + (void)OsalSpinLockIrqSave(&cntlr->device.spin, &flags); ret = cntlr->ops->unsetIrq(cntlr, local); if (ret == HDF_SUCCESS) { if (cntlr->ginfos[local].irqFunc == GpioIrqBridgeFunc) { @@ -449,7 +293,7 @@ int32_t GpioCntlrUnsetIrq(struct GpioCntlr *cntlr, uint16_t local) cntlr->ginfos[local].irqFunc = NULL; cntlr->ginfos[local].irqData = NULL; } - (void)OsalSpinUnlockIrqRestore(&cntlr->spin, &flags); + (void)OsalSpinUnlockIrqRestore(&cntlr->device.spin, &flags); return ret; } diff --git a/support/platform/src/gpio/gpio_if.c b/support/platform/src/gpio/gpio_if.c new file mode 100644 index 0000000000000000000000000000000000000000..4a0ee4d2922c1c103f619124c2e553033e5d8adb --- /dev/null +++ b/support/platform/src/gpio/gpio_if.c @@ -0,0 +1,285 @@ +/* + * 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 "gpio_if.h" + +#ifdef __USER__ +#include "gpio/gpio_service.h" +#include "hdf_io_service_if.h" +#include "platform_core.h" +#else +#include "devsvc_manager_clnt.h" +#include "gpio/gpio_core.h" +#endif + +#include "hdf_base.h" + +#define PLAT_LOG_TAG gpio_if + +#ifdef __USER__ + +static void *GpioManagerServiceGet(void) +{ + static void *manager = NULL; + + if (manager != NULL) { + return manager; + } + manager = (void *)HdfIoServiceBind("HDF_PLATFORM_GPIO_MANAGER"); + if (manager == NULL) { + PLAT_LOGE("%s: failed to get gpio manager service!", __func__); + } + return manager; +} + +int32_t GpioRead(uint16_t gpio, uint16_t *val) +{ + int32_t ret; + struct HdfIoService *service = NULL; + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + + service = (struct HdfIoService *)GpioManagerServiceGet(); + if (service == NULL) { + return HDF_PLT_ERR_DEV_GET; + } + + data = HdfSBufObtainDefaultSize(); + if (data == NULL) { + return HDF_ERR_MALLOC_FAIL; + } + + reply = HdfSBufObtainDefaultSize(); + if (reply == NULL) { + HdfSBufRecycle(data); + return HDF_ERR_MALLOC_FAIL; + } + + if (!HdfSbufWriteUint16(data, (uint16_t)gpio)) { + PLAT_LOGE("%s: write gpio number failed!", __func__); + HdfSBufRecycle(data); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + + ret = service->dispatcher->Dispatch(&service->object, GPIO_IO_READ, data, reply); + if (ret != HDF_SUCCESS) { + PLAT_LOGE("%s: service call failed:%d", __func__, ret); + HdfSBufRecycle(data); + HdfSBufRecycle(reply); + return ret; + } + + if (!HdfSbufReadUint16(reply, val)) { + PLAT_LOGE("%s: read sbuf failed", __func__); + HdfSBufRecycle(data); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + + HdfSBufRecycle(data); + HdfSBufRecycle(reply); + return HDF_SUCCESS; +} + +int32_t GpioWrite(uint16_t gpio, uint16_t val) +{ + int32_t ret; + struct HdfIoService *service = NULL; + struct HdfSBuf *data = NULL; + + service = (struct HdfIoService *)GpioManagerServiceGet(); + if (service == NULL) { + return HDF_PLT_ERR_DEV_GET; + } + + data = HdfSBufObtainDefaultSize(); + if (data == NULL) { + return HDF_ERR_MALLOC_FAIL; + } + + if (!HdfSbufWriteUint16(data, (uint16_t)gpio)) { + PLAT_LOGE("%s: write gpio number failed!", __func__); + HdfSBufRecycle(data); + return HDF_ERR_IO; + } + + if (!HdfSbufWriteUint16(data, (uint16_t)val)) { + PLAT_LOGE("%s: write gpio value failed!", __func__); + HdfSBufRecycle(data); + return HDF_ERR_IO; + } + + ret = service->dispatcher->Dispatch(&service->object, GPIO_IO_WRITE, data, NULL); + if (ret != HDF_SUCCESS) { + PLAT_LOGE("%s: service call failed:%d", __func__, ret); + HdfSBufRecycle(data); + return ret; + } + + HdfSBufRecycle(data); + return HDF_SUCCESS; +} + +int32_t GpioGetDir(uint16_t gpio, uint16_t *dir) +{ + int32_t ret; + struct HdfIoService *service = NULL; + struct HdfSBuf *data = NULL; + struct HdfSBuf *reply = NULL; + + service = (struct HdfIoService *)GpioManagerServiceGet(); + if (service == NULL) { + return HDF_PLT_ERR_DEV_GET; + } + + data = HdfSBufObtainDefaultSize(); + if (data == NULL) { + return HDF_ERR_MALLOC_FAIL; + } + + reply = HdfSBufObtainDefaultSize(); + if (reply == NULL) { + HdfSBufRecycle(data); + return HDF_ERR_MALLOC_FAIL; + } + + if (!HdfSbufWriteUint16(data, (uint16_t)gpio)) { + PLAT_LOGE("%s: write gpio number failed!", __func__); + HdfSBufRecycle(data); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + + ret = service->dispatcher->Dispatch(&service->object, GPIO_IO_GETDIR, data, reply); + if (ret != HDF_SUCCESS) { + PLAT_LOGE("%s: service call failed:%d", __func__, ret); + HdfSBufRecycle(data); + HdfSBufRecycle(reply); + return ret; + } + + if (!HdfSbufReadUint16(reply, dir)) { + PLAT_LOGE("%s: read sbuf failed", __func__); + HdfSBufRecycle(data); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + + HdfSBufRecycle(data); + HdfSBufRecycle(reply); + return HDF_SUCCESS; +} + +int32_t GpioSetDir(uint16_t gpio, uint16_t dir) +{ + int32_t ret; + struct HdfIoService *service = NULL; + struct HdfSBuf *data = NULL; + + service = (struct HdfIoService *)GpioManagerServiceGet(); + if (service == NULL) { + return HDF_PLT_ERR_DEV_GET; + } + + data = HdfSBufObtainDefaultSize(); + if (data == NULL) { + return HDF_ERR_MALLOC_FAIL; + } + + if (!HdfSbufWriteUint16(data, (uint16_t)gpio)) { + PLAT_LOGE("%s: write gpio number failed!", __func__); + HdfSBufRecycle(data); + return HDF_ERR_IO; + } + + if (!HdfSbufWriteUint16(data, (uint16_t)dir)) { + PLAT_LOGE("%s: write gpio value failed!", __func__); + HdfSBufRecycle(data); + return HDF_ERR_IO; + } + + ret = service->dispatcher->Dispatch(&service->object, GPIO_IO_SETDIR, data, NULL); + if (ret != HDF_SUCCESS) { + PLAT_LOGE("%s: service call failed:%d", __func__, ret); + HdfSBufRecycle(data); + return ret; + } + + HdfSBufRecycle(data); + return HDF_SUCCESS; +} + +int32_t GpioSetIrq(uint16_t gpio, uint16_t mode, GpioIrqFunc func, void *arg) +{ + (void)gpio; + (void)mode; + (void)func; + (void)arg; + return HDF_SUCCESS; +} + +int32_t GpioUnSetIrq(uint16_t gpio) +{ + (void)gpio; + return HDF_SUCCESS; +} + +int32_t GpioEnableIrq(uint16_t gpio) +{ + (void)gpio; + return HDF_SUCCESS; +} + +int32_t GpioDisableIrq(uint16_t gpio) +{ + (void)gpio; + return HDF_SUCCESS; +} + +#else +int32_t GpioRead(uint16_t gpio, uint16_t *val) +{ + return GpioCntlrRead(GpioGetCntlr(gpio), GpioToLocal(gpio), val); +} + +int32_t GpioWrite(uint16_t gpio, uint16_t val) +{ + return GpioCntlrWrite(GpioGetCntlr(gpio), GpioToLocal(gpio), val); +} + +int32_t GpioSetDir(uint16_t gpio, uint16_t dir) +{ + return GpioCntlrSetDir(GpioGetCntlr(gpio), GpioToLocal(gpio), dir); +} + +int32_t GpioGetDir(uint16_t gpio, uint16_t *dir) +{ + return GpioCntlrGetDir(GpioGetCntlr(gpio), GpioToLocal(gpio), dir); +} + +int32_t GpioSetIrq(uint16_t gpio, uint16_t mode, GpioIrqFunc func, void *arg) +{ + return GpioCntlrSetIrq(GpioGetCntlr(gpio), GpioToLocal(gpio), mode, func, arg); +} + +int32_t GpioUnSetIrq(uint16_t gpio) +{ + return GpioCntlrUnsetIrq(GpioGetCntlr(gpio), GpioToLocal(gpio)); +} + +int32_t GpioEnableIrq(uint16_t gpio) +{ + return GpioCntlrEnableIrq(GpioGetCntlr(gpio), GpioToLocal(gpio)); +} + +int32_t GpioDisableIrq(uint16_t gpio) +{ + return GpioCntlrDisableIrq(GpioGetCntlr(gpio), GpioToLocal(gpio)); +} +#endif diff --git a/support/platform/src/gpio/gpio_manager.c b/support/platform/src/gpio/gpio_manager.c new file mode 100644 index 0000000000000000000000000000000000000000..5b47c8701f4dbf2478639697f11ed87e56d7c6f8 --- /dev/null +++ b/support/platform/src/gpio/gpio_manager.c @@ -0,0 +1,174 @@ +/* + * 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 "gpio/gpio_core.h" +#include "osal_mem.h" +#include "platform_core.h" + +#define HDF_LOG_TAG gpio_manager + +#define MAX_CNT_PER_CNTLR 1024 + +static uint16_t GpioCntlrQueryStart(struct GpioCntlr *cntlr, struct DListHead *list) +{ + uint16_t freeStart; + uint16_t freeCount; + struct PlatformDevice *iterLast = NULL; + struct PlatformDevice *iterCur = NULL; + struct PlatformDevice *tmp = NULL; + struct GpioCntlr *cntlrCur = NULL; + struct GpioCntlr *cntlrLast = NULL; + + DLIST_FOR_EACH_ENTRY_SAFE(iterCur, tmp, list, struct PlatformDevice, node) { + cntlrCur = CONTAINER_OF(iterCur, struct GpioCntlr, device); + cntlrLast = CONTAINER_OF(iterLast, struct GpioCntlr, device); + if (cntlrLast == NULL) { + freeStart = 0; + freeCount = cntlrCur->start; + } else { + freeStart = cntlrLast->start + cntlrLast->count; + freeCount = cntlrCur->start - freeStart; + } + + if (cntlr->start < freeStart) { + PLAT_LOGE("GpioCntlrQueryStart: start:%u not available(freeStart:%u, freeCount:%u)", + cntlr->start, freeStart, freeCount); + return GPIO_NUM_MAX; + } + + if ((cntlr->start + cntlr->count) <= (freeStart + freeCount)) { + return freeStart; + } + cntlrLast = cntlrCur; + } + if (cntlrLast == NULL) { // empty list + return cntlr->start; + } + if (cntlr->start >= (cntlrLast->start + cntlrLast->count)) { + return cntlrLast->start + cntlrLast->count; + } + PLAT_LOGE("GpioCntlrQueryStart: start:%u not available(lastStart:%u, lastCount:%u)", + cntlr->start, cntlrLast->start, cntlrLast->count); + return GPIO_NUM_MAX; +} + +static int32_t GpioManagerAdd(struct PlatformManager *manager, struct PlatformDevice *device) +{ + uint16_t start; + struct GpioCntlr *cntlr = CONTAINER_OF(device, struct GpioCntlr, device); + + if ((start = GpioCntlrQueryStart(cntlr, &manager->devices)) >= GPIO_NUM_MAX) { + PLAT_LOGE("GpioCntlrAdd: query range for start:%d fail:%d", cntlr->start, start); + return HDF_ERR_INVALID_PARAM; + } + + cntlr->start = start; + DListInsertTail(&device->node, &manager->devices); + PLAT_LOGI("%s: start:%u count:%u", __func__, cntlr->start, cntlr->count); + return HDF_SUCCESS; +} + +static int32_t GpioManagerDel(struct PlatformManager *manager, struct PlatformDevice *device) +{ + if (!DListIsEmpty(&device->node)) { + DListRemove(&device->node); + } + return HDF_SUCCESS; +} + +struct PlatformManager *GpioManagerGet(void) +{ + static struct PlatformManager *manager = NULL; + + if (manager == NULL) { + manager = PlatformManagerGet(PLATFORM_MODULE_GPIO); + if (manager != NULL) { + manager->add = GpioManagerAdd; + manager->del = GpioManagerDel; + } + } + return manager; +} + +int32_t GpioCntlrAdd(struct GpioCntlr *cntlr) +{ + int32_t ret; + + if (cntlr == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->ops == NULL) { + PLAT_LOGE("GpioCntlrAdd: no ops supplied!"); + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->count >= MAX_CNT_PER_CNTLR) { + PLAT_LOGE("GpioCntlrAdd: invalid gpio count:%u", cntlr->count); + return HDF_ERR_INVALID_PARAM; + } + + if (cntlr->ginfos == NULL) { + cntlr->ginfos = OsalMemCalloc(sizeof(*cntlr->ginfos) * cntlr->count); + if (cntlr->ginfos == NULL) { + return HDF_ERR_MALLOC_FAIL; + } + } + + cntlr->device.manager = GpioManagerGet(); + if ((ret = PlatformDeviceAdd(&cntlr->device)) != HDF_SUCCESS) { + OsalMemFree(cntlr->ginfos); + return ret; + } + + return HDF_SUCCESS; +} + +void GpioCntlrRemove(struct GpioCntlr *cntlr) +{ + if (cntlr == NULL) { + return; + } + + PlatformDeviceDel(&cntlr->device); + + if (cntlr->ginfos != NULL) { + OsalMemFree(cntlr->ginfos); + cntlr->ginfos = NULL; + } +} + +static bool GpioCntlrFindMatch(struct PlatformDevice *device, void *data) +{ + uint16_t gpio = (uint16_t)(uintptr_t)data; + struct GpioCntlr *cntlr = CONTAINER_OF(device, struct GpioCntlr, device); + + if (gpio >= cntlr->start && gpio < (cntlr->start + cntlr->count)) { + return true; + } + return false; +} + +struct GpioCntlr *GpioGetCntlr(uint16_t gpio) +{ + struct PlatformManager *gpioMgr = NULL; + struct PlatformDevice *device = NULL; + + gpioMgr = GpioManagerGet(); + if (gpioMgr == NULL) { + PLAT_LOGE("GpioCntlrRemove: get gpio manager failed"); + return NULL; + } + + device = PlatformManagerFindDevice(gpioMgr, (void *)(uintptr_t)gpio, GpioCntlrFindMatch); + if (device == NULL) { + PLAT_LOGE("%s: gpio %u not in any controllers!", __func__, gpio); + return NULL; + } + return CONTAINER_OF(device, struct GpioCntlr, device); +} diff --git a/support/platform/src/gpio/gpio_service.c b/support/platform/src/gpio/gpio_service.c new file mode 100644 index 0000000000000000000000000000000000000000..d73b84987e6bcf2f7e2183caf820b860560e191c --- /dev/null +++ b/support/platform/src/gpio/gpio_service.c @@ -0,0 +1,222 @@ +/* + * 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 "gpio_if.h" +#include "gpio/gpio_core.h" +#include "gpio/gpio_service.h" +#include "hdf_device_desc.h" +#include "platform_core.h" + +#define HDF_LOG_TAG gpio_service + +static int32_t GpioServiceIoRead(struct HdfSBuf *data, struct HdfSBuf *reply) +{ + int32_t ret; + uint16_t gpio; + uint16_t value; + + if (data == NULL || reply == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (!HdfSbufReadUint16(data, &gpio)) { + PLAT_LOGE("%s: read gpio number failed", __func__); + return HDF_ERR_IO; + } + + ret = GpioRead(gpio, &value); + if (ret != HDF_SUCCESS) { + PLAT_LOGE("%s: read gpio failed:%d", __func__, ret); + return ret; + } + + if (!HdfSbufWriteUint16(reply, value)) { + PLAT_LOGE("%s: write subf failed:%d", __func__, ret); + return ret; + } + + return ret; +} + +static int32_t GpioServiceIoWrite(struct HdfSBuf *data, struct HdfSBuf *reply) +{ + int32_t ret; + uint16_t gpio; + uint16_t value; + + if (data == NULL || reply == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (!HdfSbufReadUint16(data, &gpio)) { + PLAT_LOGE("%s: read gpio number failed", __func__); + return HDF_ERR_IO; + } + + if (!HdfSbufReadUint16(data, &value)) { + PLAT_LOGE("%s: read gpio value failed", __func__); + return HDF_ERR_IO; + } + + ret = GpioWrite(gpio, value); + if (ret != HDF_SUCCESS) { + PLAT_LOGE("%s: write gpio failed:%d", __func__, ret); + return ret; + } + + return ret; +} + +static int32_t GpioServiceIoGetDir(struct HdfSBuf *data, struct HdfSBuf *reply) +{ + int32_t ret; + uint16_t gpio; + uint16_t dir; + + if (data == NULL || reply == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (!HdfSbufReadUint16(data, &gpio)) { + PLAT_LOGE("%s: read gpio number failed", __func__); + return HDF_ERR_IO; + } + + ret = GpioGetDir(gpio, &dir); + if (ret != HDF_SUCCESS) { + PLAT_LOGE("%s: get gpio dir failed:%d", __func__, ret); + return ret; + } + + if (!HdfSbufWriteUint16(reply, dir)) { + PLAT_LOGE("%s: write subf failed:%d", __func__, ret); + return ret; + } + + return ret; +} + +static int32_t GpioServiceIoSetDir(struct HdfSBuf *data, struct HdfSBuf *reply) +{ + int32_t ret; + uint16_t gpio; + uint16_t dir; + + if (data == NULL || reply == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (!HdfSbufReadUint16(data, &gpio)) { + PLAT_LOGE("%s: read gpio number failed", __func__); + return HDF_ERR_IO; + } + + if (!HdfSbufReadUint16(data, &dir)) { + PLAT_LOGE("%s: read gpio dir failed", __func__); + return HDF_ERR_IO; + } + + ret = GpioSetDir(gpio, dir); + if (ret != HDF_SUCCESS) { + PLAT_LOGE("%s: set gpio dir failed:%d", __func__, ret); + return ret; + } + + return ret; +} + +static int32_t GpioServiceDispatch(struct HdfDeviceIoClient *client, int cmd, + struct HdfSBuf *data, struct HdfSBuf *reply) +{ + int32_t ret; + + switch (cmd) { + case GPIO_IO_READ: + return GpioServiceIoRead(data, reply); + case GPIO_IO_WRITE: + return GpioServiceIoWrite(data, reply); + case GPIO_IO_GETDIR: + return GpioServiceIoGetDir(data, reply); + case GPIO_IO_SETDIR: + return GpioServiceIoSetDir(data, reply); + default: + ret = HDF_ERR_NOT_SUPPORT; + break; + } + return ret; +} + +static int32_t GpioServiceBind(struct HdfDeviceObject *device) +{ + int32_t ret; + struct PlatformManager *gpioMgr = NULL; + + PLAT_LOGI("GpioServiceBind: enter"); + if (device == NULL) { + PLAT_LOGE("GpioServiceBind: device is NULL"); + return HDF_ERR_INVALID_OBJECT; + } + + gpioMgr = GpioManagerGet(); + if (gpioMgr == NULL) { + PLAT_LOGE("GpioServiceBind: get gpio manager failed"); + return HDF_PLT_ERR_DEV_GET; + } + + ret = PlatformDeviceCreateService(&gpioMgr->device, GpioServiceDispatch); + if (ret != HDF_SUCCESS) { + PLAT_LOGE("GpioServiceBind: create gpio service failed:%d", ret); + return ret; + } + + ret = PlatformDeviceBind(&gpioMgr->device, device); + if (ret != HDF_SUCCESS) { + PLAT_LOGE("GpioServiceBind: bind gpio device failed:%d", ret); + (void)PlatformDeviceDestroyService(&gpioMgr->device); + return ret; + } + + PLAT_LOGI("GpioServiceBind: success"); + return HDF_SUCCESS; +} + +static int32_t GpioServiceInit(struct HdfDeviceObject *device) +{ + (void)device; + return HDF_SUCCESS; +} + +static void GpioServiceRelease(struct HdfDeviceObject *device) +{ + struct PlatformManager *gpioMgr = NULL; + + PLAT_LOGI("GpioServiceRelease: enter"); + if (device == NULL) { + PLAT_LOGI("GpioServiceRelease: device is null"); + return; + } + + gpioMgr = GpioManagerGet(); + if (gpioMgr == NULL) { + PLAT_LOGE("GpioServiceBind: get gpio manager failed"); + return; + } + + (void)PlatformDeviceDestroyService(&gpioMgr->device); + (void)PlatformDeviceUnbind(&gpioMgr->device); + PLAT_LOGI("GpioServiceRelease: done"); +} + +struct HdfDriverEntry g_gpioServiceEntry = { + .moduleVersion = 1, + .Bind = GpioServiceBind, + .Init = GpioServiceInit, + .Release = GpioServiceRelease, + .moduleName = "HDF_PLATFORM_GPIO_MANAGER", +}; +HDF_INIT(g_gpioServiceEntry); diff --git a/support/platform/src/gpio_if.c b/support/platform/src/gpio_if.c deleted file mode 100644 index eca819fc00b4947991e0fc4249ba6cdf28b8d931..0000000000000000000000000000000000000000 --- a/support/platform/src/gpio_if.c +++ /dev/null @@ -1,55 +0,0 @@ -/* - * 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 "gpio_if.h" -#include "devsvc_manager_clnt.h" -#include "gpio_core.h" -#include "hdf_base.h" -#include "hdf_log.h" - -#define HDF_LOG_TAG gpio_if - -int32_t GpioRead(uint16_t gpio, uint16_t *val) -{ - return GpioCntlrRead(GpioGetCntlr(gpio), GpioToLocal(gpio), val); -} - -int32_t GpioWrite(uint16_t gpio, uint16_t val) -{ - return GpioCntlrWrite(GpioGetCntlr(gpio), GpioToLocal(gpio), val); -} - -int32_t GpioSetDir(uint16_t gpio, uint16_t dir) -{ - return GpioCntlrSetDir(GpioGetCntlr(gpio), GpioToLocal(gpio), dir); -} - -int32_t GpioGetDir(uint16_t gpio, uint16_t *dir) -{ - return GpioCntlrGetDir(GpioGetCntlr(gpio), GpioToLocal(gpio), dir); -} - -int32_t GpioSetIrq(uint16_t gpio, uint16_t mode, GpioIrqFunc func, void *arg) -{ - return GpioCntlrSetIrq(GpioGetCntlr(gpio), GpioToLocal(gpio), mode, func, arg); -} - -int32_t GpioUnSetIrq(uint16_t gpio) -{ - return GpioCntlrUnsetIrq(GpioGetCntlr(gpio), GpioToLocal(gpio)); -} - -int32_t GpioEnableIrq(uint16_t gpio) -{ - return GpioCntlrEnableIrq(GpioGetCntlr(gpio), GpioToLocal(gpio)); -} - -int32_t GpioDisableIrq(uint16_t gpio) -{ - return GpioCntlrDisableIrq(GpioGetCntlr(gpio), GpioToLocal(gpio)); -} diff --git a/support/platform/src/hdmi/hdmi_cec.c b/support/platform/src/hdmi/hdmi_cec.c new file mode 100644 index 0000000000000000000000000000000000000000..2d8a08304349dd510ab55abd54a0c1758ab31160 --- /dev/null +++ b/support/platform/src/hdmi/hdmi_cec.c @@ -0,0 +1,1708 @@ +/* + * 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_log.h" +#include "hdmi_core.h" +#include "securec.h" + +#define HDF_LOG_TAG hdmi_cec_c + +#define HDMI_CEC_PHY_ADDR_PHASE(addr) \ + ((addr) >> 12), ((addr) >> 8) & 0xf, ((addr) >> 4) & 0xf, (addr) & 0xf + +typedef void (*HdmiCecHandleMsgFunc)(struct HdmiCntlr *cntlr, struct HdmiCecMsg *oldMsg, struct HdmiCecMsg *newMsg); + +struct HdmiCecHandleMsgFuncMap { + uint8_t opcode; + HdmiCecHandleMsgFunc func; +}; + +struct HdmiCecMsgLenInfo g_cecMsg[] = { + { HDMI_CEC_OPCODE_ACTIVE_SOURCE, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_ACTIVE_SOURCE_MSG_PARAM_LEN), + HDMI_CEC_MSG_BROADCAST }, + { HDMI_CEC_OPCODE_IMAGE_VIEW_ON, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_TEXT_VIEW_ON, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_INACTIVE_SOURCE, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_INACTIVE_SOURCE_MSG_PARAM_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_REQUEST_ACTIVE_SOURCE, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_BROADCAST }, + { HDMI_CEC_OPCODE_ROUTING_CHANGE, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_ROUTING_CHANGE_MSG_PARAM_LEN), + HDMI_CEC_MSG_BROADCAST }, + { HDMI_CEC_OPCODE_ROUTING_INFORMATION, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_ROUTING_INFORMATIO_MSG_PARAM_LEN), + HDMI_CEC_MSG_BROADCAST }, + { HDMI_CEC_OPCODE_SET_STREAM_PATH, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SET_STREAM_PATH_MSG_PARAM_LEN), + HDMI_CEC_MSG_BROADCAST }, + { HDMI_CEC_OPCODE_STANDBY, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_RECORD_OFF, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_RECORD_ON, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_RECORD_SOURCE_TYPE_LEN), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_RECORD_STATUS, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_RECORD_STATUS_MSG_PARAM_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_RECORD_TV_SCREEN, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_CLEAR_ANALOGUE_TIMER, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_ANALOGUE_TIMER_INFO_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_CLEAR_DIGITAL_TIMER, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_DIGITAL_TIMER_INFO_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_CLEAR_EXTERNAL_TIMER, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_EXTERNAL_TIMER_INFO_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_SET_ANALOGUE_TIMER, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_ANALOGUE_TIMER_INFO_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_SET_DIGITAL_TIMER, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_DIGITAL_TIMER_INFO_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_SET_EXTERNAL_TIMER, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_EXTERNAL_TIMER_INFO_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_SET_TIMER_PROGRAM_TITLE, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_TIMER_CLEARED_STATUS, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_TIMER_CLEARED_STATUS_MSG_PARAM_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_TIMER_STATUS, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_TIMER_STATUS_DATA_MIN_LEN), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_CEC_VERSION, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_CEC_VERSION_MSG_PARAM_LEN), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_GET_CEC_VERSION, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_GIVE_PHYSICAL_ADDRESS, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_GET_MENU_LANGUAGE, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_REPORT_PHYSICAL_ADDRESS, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_REPORT_PHYSICAL_ADDRESS_MSG_PARAM_LEN), + HDMI_CEC_MSG_BROADCAST }, + { HDMI_CEC_OPCODE_SET_MENU_LANGUAGE, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SET_MENU_LANGUAGE_MSG_PARAM_LEN), + HDMI_CEC_MSG_BROADCAST }, + { HDMI_CEC_OPCODE_REPORT_FEATURES, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_REPORT_FEATURES_MSG_PARAM_MIN_LEN), + HDMI_CEC_MSG_BROADCAST }, + { HDMI_CEC_OPCODE_GIVE_FEATURES, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_DECK_CONTROL, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_DECK_CONTROL_MSG_PARAM_LEN), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_DECK_STATUS, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_DECK_STATUS_MSG_PARAM_LEN), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_GIVE_DECK_STATUS, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_GIVE_DECK_STATUS_MSG_PARAM_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_PLAY, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_PLAY_MSG_PARAM_LEN), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_GIVE_TUNER_DEVICE_STATU_MSG_PARAM_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_SELECT_ANALOGUE_SERVICE, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SELECT_ANALOGUE_SERVICE_MSG_PARAM_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_SELECT_DIGITAL_SERVICE, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SELECT_DIGITAL_SERVICE_MSG_PARAM_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_TUNER_DEVICE_STATUS, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_TUNER_DEVICE_STATUS_MSG_ANA_PARAM_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_TUNER_STEP_DECREMENT, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_TUNER_STEP_INCREMENT, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_DEVICE_VENDOR_ID, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_DEVICE_VENDOR_ID_MSG_PARAM_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_GIVE_DEVICE_VENDOR_ID, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_VENDOR_COMMAND, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_VENDOR_COMMAND_WITH_ID, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_VENDOR_ID_LEN), HDMI_CEC_MSG_ALL }, + { HDMI_CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_ALL }, + { HDMI_CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_ALL }, + { HDMI_CEC_OPCODE_SET_OSD_STRING, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_DISPLAY_CONTROL_LEN), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_GIVE_OSD_NAME, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_SET_OSD_NAME, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_MENU_REQUEST, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_MENU_REQUEST_MSG_PARAM_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_MENU_STATUS, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_MENU_STATUS_MSG_PARAM_LEN), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_USER_CONTROL_PRESSED, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_UI_COMMAND_LEN), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_USER_CONTROL_RELEASED, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_GIVE_DEVICE_POWER_STATUS, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_REPORT_POWER_STATUS, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_REPORT_POWER_STATUS_MSG_PARA_LEN), + HDMI_CEC_MSG_DIRECTED_OR_BROADCAST_2_0 }, + { HDMI_CEC_OPCODE_FEATURE_ABORT, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_FEATURE_ABORT_MSG_PARA_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_ABORT, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_GIVE_AUDIO_STATUS, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_REPORT_AUDIO_STATUS, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_REPORT_AUDIO_STATUSMSG_PARAM_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_REPORT_SHORT_AUDIO_DESCRIPTOR, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_REQUEST_SHORT_AUDIO_DESCRIPTOR, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_SET_SYSTEM_AUDIO_MODE, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SYSTEM_AUDIO_STATUS_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SYSTEM_AUDIO_MODE_REQUEST_PARAM_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SYSTEM_AUDIO_STATUS_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_SET_AUDIO_RATE, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SET_AUDIO_RATE_PARAM_LEN), + HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_INITIATE_ARC, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_REPORT_ARC_INITIATED, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_REPORT_ARC_TERMINATION, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_REQUEST_ARC_INITIATION, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_REQUEST_ARC_TERMINATION, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_TERMINATE_ARC, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_DIRECTED }, + { HDMI_CEC_OPCODE_CDC_MESSAGE, HDMI_CEC_GET_MSG_LEN(0), HDMI_CEC_MSG_BROADCAST }, + { HDMI_CEC_OPCODE_REQUEST_CURRENT_LATENCY, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_REQUEST_CURRENT_LATENCY_MSG_LEN), + HDMI_CEC_MSG_BROADCAST }, + { HDMI_CEC_OPCODE_REPORT_CURRENT_LATENCY, HDMI_CEC_GET_MSG_LEN(HDMI_CEC_REPORT_CURRENT_LATENCY_MSG_PARAM_MIN_LEN), + HDMI_CEC_MSG_BROADCAST } +}; + +static struct HdmiCecMsgLenInfo *HdmiCecGetMsgLenInfo(uint8_t opcode) +{ + uint32_t i, len; + + len = sizeof(g_cecMsg) / sizeof(g_cecMsg[0]); + for (i = 0; i < len; i++) { + if (opcode == g_cecMsg[i].opcode) { + return (&g_cecMsg[i]); + } + } + return NULL; +} + +static bool HdmiCecCheckTimerStatusMsgLen(struct HdmiCecMsg *msg) +{ + /* Progremmed Info or Not Progremmed Error Info. */ + uint8_t info = (msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] & 0xf); + + /* Progremmed Indicator Check. */ + if ((msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] & 0x10) > 0) { + if (((info == HDMI_CEC_PROGRAMMED_INFO_NOT_ENOUGH_SPAC) || + (info == HDMI_CEC_PROGRAMMED_INFO_MIGHT_NOT_BE_ENOUGH_SPACE)) && + (msg->len < HDMI_CEC_GET_MSG_LEN(HDMI_CEC_TIMER_STATUS_DATA_MAX_LEN))) { + HDF_LOGD("check Timer_Status(Indicator) Msg fail."); + return false; + } + } else if (info == HDMI_CEC_NOT_PROG_ERR_DUPLICATE) { + if (msg->len < HDMI_CEC_GET_MSG_LEN(HDMI_CEC_TIMER_STATUS_DATA_MAX_LEN)) { + HDF_LOGD("check Timer_Status Msg fail."); + return false; + } + } + return true; +} + +static bool HdmiCecCheckRecordOnMsgLen(struct HdmiCecMsg *msg) +{ + switch (msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT]) { + case HDMI_CEC_RECORD_SRC_OWN: + break; + case HDMI_CEC_RECORD_SRC_DIGITAL: + if (msg->len < HDMI_CEC_GET_MSG_LEN(HDMI_CEC_RECORD_ON_DIGITAL_MSG_PARAM_LEN)) { + HDF_LOGD("check Record_On(DIGITAL) Msg fail."); + return false; + } + break; + case HDMI_CEC_RECORD_SRC_ANALOG: + if (msg->len < HDMI_CEC_GET_MSG_LEN(HDMI_CEC_RECORD_ON_ANALOG_MSG_PARAM_LEN)) { + HDF_LOGD("check Record_On(ANALOG) Msg fail."); + return false; + } + break; + case HDMI_CEC_RECORD_SRC_EXT_PLUG: + if (msg->len < HDMI_CEC_GET_MSG_LEN(HDMI_CEC_RECORD_ON_EXT_PLUG_MSG_PARAM_LEN)) { + HDF_LOGD("check Record_On(EXT_PLUG) Msg fail."); + return false; + } + break; + case HDMI_CEC_RECORD_SRC_EXT_PHY_ADDR: + if (msg->len < HDMI_CEC_GET_MSG_LEN(HDMI_CEC_RECORD_ON_EXT_PHY_ADDR_MSG_PARAM_LEN)) { + HDF_LOGD("check Record_On(EXT_PHY_ADDR) Msg fail."); + return false; + } + break; + default: + break; + } + return true; +} + +static bool HdmiCecCheckSomeSpecialfMsgLen(struct HdmiCecMsg *msg, uint8_t opcode) +{ + bool ret = true; + + switch (opcode) { + case HDMI_CEC_OPCODE_TIMER_STATUS: + ret = HdmiCecCheckTimerStatusMsgLen(msg); + break; + case HDMI_CEC_OPCODE_RECORD_ON: + ret = HdmiCecCheckRecordOnMsgLen(msg); + break; + default: + break; + } + return ret; +} + +static bool HdmiCecCheckMsgLen(struct HdmiCec *cec, struct HdmiCecMsg *msg, uint8_t opcode) +{ + struct HdmiCecMsgLenInfo *info = NULL; + + info = HdmiCecGetMsgLenInfo(opcode); + if (info == NULL) { + HDF_LOGD("have no this cec msg"); + return false; + } + + if (msg->len < info->minLen) { + HDF_LOGD("this cec msg is invalid, opcode = 0x%x, len = %d.", opcode, msg->len); + return false; + } + if (HdmiCecIsBroadcastMsg(msg) == true && + (info->type & HDMI_CEC_MSG_BROADCAST) == 0) { + HDF_LOGD("this cec msg,check broadcast msg fail."); + return false; + } + if (HdmiCecIsBroadcastMsg(msg) == false && + (info->type & HDMI_CEC_MSG_BROADCAST) > 0) { + HDF_LOGD("this cec msg,check directed msg fail."); + return false; + } + if (HdmiCecIsBroadcastMsg(msg) == true && + (info->type & HDMI_CEC_MSG_BROADCAST_1_4) > 0 && + cec->info.cecVersion < HDMI_CEC_VERSION_2_0) { + HDF_LOGD("this cec msg,check broadcast msg version fail."); + return false; + } + return HdmiCecCheckSomeSpecialfMsgLen(msg, opcode); +} + +/* message encoding/decoding functions. */ +void HdmiCecEncodingActiveSourceMsg(struct HdmiCecMsg *msg, uint16_t phyAddr) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_ACTIVE_SOURCE_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_ACTIVE_SOURCE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (phyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (phyAddr & HDMI_ONE_BYTE_MARK); +} + +void HdmiCecEncodingImageViewOnMsg(struct HdmiCecMsg *msg) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_IMAGE_VIEW_ON; +} + +void HdmiCecEncodingTextViewOnMsg(struct HdmiCecMsg *msg) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_TEXT_VIEW_ON; +} + +void HdmiCecEncodingInactiveSourceMsg(struct HdmiCecMsg *msg, uint16_t phyAddr) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_INACTIVE_SOURCE_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_INACTIVE_SOURCE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (phyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (phyAddr & HDMI_ONE_BYTE_MARK); +} + +void HdmiCecEncodingRequestActiveSourceMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_REQUEST_ACTIVE_SOURCE; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_ACTIVE_SOURCE; + } +} + +void HdmiCecEncodingRoutingChangeMsg(struct HdmiCecMsg *msg, uint16_t orgAddr, uint16_t newAddr, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_ROUTING_CHANGE_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_ROUTING_CHANGE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (orgAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (orgAddr & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = (newAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_FIFTH_ELEMENT] = (newAddr & HDMI_ONE_BYTE_MARK); + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_ROUTING_INFORMATION; + } +} + +void HdmiCecEncodingRoutingInfomationMsg(struct HdmiCecMsg *msg, uint16_t phyAddr) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_ROUTING_INFORMATIO_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_ROUTING_INFORMATION; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (phyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (phyAddr & HDMI_ONE_BYTE_MARK); +} + +void HdmiCecEncodingSetStreamPathMsg(struct HdmiCecMsg *msg, uint16_t phyAddr) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SET_STREAM_PATH_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_SET_STREAM_PATH; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (phyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (phyAddr & HDMI_ONE_BYTE_MARK); +} + +void HdmiCecEncodingStandbyMsg(struct HdmiCecMsg *msg) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_STANDBY; +} + +void HdmiCecEncodingRecordOffMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_RECORD_OFF; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_RECORD_STATUS; + } +} + +static void HdmiCecEncodingRecordOnOwn(struct HdmiCecMsg *msg) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_RECORD_SOURCE_TYPE_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_RECORD_ON; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = HDMI_CEC_RECORD_SRC_OWN; +} + +static void HdmiCecEncodingDigitalServiceId(uint8_t *data, uint8_t len, struct HdmiCecDigitalServiceId *digital) +{ + if (len < HDMI_CEC_DIGITAL_SERVICE_ID_LEN) { + return; + } + + data[DATA_ZEROTH_OFFSET_ELEMENT] = (digital->method << HDMI_CEC_DIGITAL_SERVICE_ID_METHOD_SHIFT) | + (digital->system); + if (digital->method == HDMI_CEC_SERVICE_ID_METHOD_BY_CHANNEL) { + data[DATA_FIRST_OFFSET_ELEMENT] = + (digital->systemData.channel.format << HDMI_CEC_CHANNEL_NUMBER_FORMAT_SHIFT) | + (digital->systemData.channel.major >> HDMI_ONE_BYTE_SHIFT); + data[DATA_SECOND_OFFSET_ELEMENT] = digital->systemData.channel.major & HDMI_ONE_BYTE_MARK; + data[DATA_THIRD_OFFSET_ELEMENT] = digital->systemData.channel.minor >> HDMI_ONE_BYTE_SHIFT; + data[DATA_FORTH_OFFSET_ELEMENT] = digital->systemData.channel.minor & HDMI_ONE_BYTE_MARK; + return; + } + switch (digital->system) { + case HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ARIB_GEN: + case HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ARIB_BS: + case HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ARIB_CS: + case HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ARIB_T: + data[DATA_FIRST_OFFSET_ELEMENT] = digital->systemData.arib.transportId >> HDMI_ONE_BYTE_SHIFT; + data[DATA_SECOND_OFFSET_ELEMENT] = digital->systemData.arib.transportId & HDMI_ONE_BYTE_MARK; + data[DATA_THIRD_OFFSET_ELEMENT] = digital->systemData.arib.serviceId >> HDMI_ONE_BYTE_SHIFT; + data[DATA_FORTH_OFFSET_ELEMENT] = digital->systemData.arib.serviceId & HDMI_ONE_BYTE_MARK; + data[DATA_FIFTH_OFFSET_ELEMENT] = digital->systemData.arib.orgNetworkId >> HDMI_ONE_BYTE_SHIFT; + data[DATA_SIXTH_OFFSET_ELEMENT] = digital->systemData.arib.orgNetworkId & HDMI_ONE_BYTE_MARK; + break; + case HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ATSC_GEN: + case HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ATSC_CABLE: + case HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ATSC_SATELLITE: + case HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_ATSC_TERRESTRIAL: + data[DATA_FIRST_OFFSET_ELEMENT] = digital->systemData.atsc.transportId >> HDMI_ONE_BYTE_SHIFT; + data[DATA_SECOND_OFFSET_ELEMENT] = digital->systemData.atsc.transportId & HDMI_ONE_BYTE_MARK; + data[DATA_THIRD_OFFSET_ELEMENT] = digital->systemData.atsc.programNumber >> HDMI_ONE_BYTE_SHIFT; + data[DATA_FORTH_OFFSET_ELEMENT] = digital->systemData.atsc.programNumber & HDMI_ONE_BYTE_MARK; + break; + case HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_DVB_GEN: + case HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_DVB_C: + case HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_DVB_S: + case HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_DVB_S2: + case HDMI_CEC_DIG_SERVICE_BCAST_SYSTEM_DVB_T: + data[DATA_FIRST_OFFSET_ELEMENT] = digital->systemData.dvb.transportId >> HDMI_ONE_BYTE_SHIFT; + data[DATA_SECOND_OFFSET_ELEMENT] = digital->systemData.dvb.transportId & HDMI_ONE_BYTE_MARK; + data[DATA_THIRD_OFFSET_ELEMENT] = digital->systemData.dvb.serviceId >> HDMI_ONE_BYTE_SHIFT; + data[DATA_FORTH_OFFSET_ELEMENT] = digital->systemData.dvb.serviceId & HDMI_ONE_BYTE_MARK; + data[DATA_FIFTH_OFFSET_ELEMENT] = digital->systemData.dvb.orgNetworkId >> HDMI_ONE_BYTE_SHIFT; + data[DATA_SIXTH_OFFSET_ELEMENT] = digital->systemData.dvb.orgNetworkId & HDMI_ONE_BYTE_MARK; + break; + default: + HDF_LOGE("digital system 0x%x is invalid", digital->system); + } +} + +static void HdmiCecEncodingRecordOnDigital(struct HdmiCecMsg *msg, struct HdmiCecDigitalServiceId *digital) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_RECORD_ON_DIGITAL_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_RECORD_ON; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = HDMI_CEC_RECORD_SRC_DIGITAL; + HdmiCecEncodingDigitalServiceId(&(msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT]), + HDMI_CEC_DIGITAL_SERVICE_ID_LEN, + digital); +} + +static void HdmiCecEncodingRecordOnAnalog(struct HdmiCecMsg *msg, + uint8_t anaBcastType, uint16_t anaFreq, uint8_t bcstSystem) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_RECORD_ON_ANALOG_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_RECORD_ON; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = HDMI_CEC_RECORD_SRC_ANALOG; + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = anaBcastType; + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = (anaFreq >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_FIFTH_ELEMENT] = (anaFreq & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_SIXTH_ELEMENT] = bcstSystem; +} + +static void HdmiCecEncodingRecordOnExtPlug(struct HdmiCecMsg *msg, uint8_t extPlug) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_RECORD_ON_EXT_PLUG_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_RECORD_ON; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = HDMI_CEC_RECORD_SRC_EXT_PLUG; + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = extPlug; +} + +static void HdmiCecEncodingRecordOnExtPhyAddr(struct HdmiCecMsg *msg, uint16_t extPhyAddr) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_RECORD_ON_EXT_PHY_ADDR_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_RECORD_ON; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = HDMI_CEC_RECORD_SRC_EXT_PHY_ADDR; + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (extPhyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = (extPhyAddr & HDMI_ONE_BYTE_MARK); +} + +void HdmiCecEncodingRecordOnMsg(struct HdmiCecMsg *msg, struct HdmiCecRecordSource *src, bool response) +{ + switch (src->type) { + case HDMI_CEC_RECORD_SRC_OWN: + HdmiCecEncodingRecordOnOwn(msg); + break; + case HDMI_CEC_RECORD_SRC_DIGITAL: + HdmiCecEncodingRecordOnDigital(msg, &(src->data.id)); + break; + case HDMI_CEC_RECORD_SRC_ANALOG: + HdmiCecEncodingRecordOnAnalog(msg, src->data.analog.anaBcastType, + src->data.analog.anaFreq, src->data.analog.bcstSystem); + break; + case HDMI_CEC_RECORD_SRC_EXT_PLUG: + HdmiCecEncodingRecordOnExtPlug(msg, src->data.extPlug); + break; + case HDMI_CEC_RECORD_SRC_EXT_PHY_ADDR: + HdmiCecEncodingRecordOnExtPhyAddr(msg, src->data.extPhyAddr); + break; + default: + HDF_LOGE("cec record on: type %d unknow", src->type); + } + + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_RECORD_STATUS; + } +} + +void HdmiCecEncodingRecordStatusMsg(struct HdmiCecMsg *msg, uint8_t recordStatusInfo) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_RECORD_STATUS_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_RECORD_STATUS; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = recordStatusInfo; +} + +void HdmiCecEncodingRecordTvScreenMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_RECORD_TV_SCREEN; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_RECORD_ON; + } +} + +static void HdmiCecEncodingCommTimerInfo(uint8_t *data, uint8_t len, struct HdmiCecCommTimerInfo *info) +{ + if (len < HDMI_CEC_COMM_TIMER_INFO_LEN) { + return; + } + data[DATA_ZEROTH_OFFSET_ELEMENT] = info->data; + data[DATA_FIRST_OFFSET_ELEMENT] = info->month; + data[DATA_SECOND_OFFSET_ELEMENT] = HDMI_CEC_BCD_FORMAT_TIME(info->startHour); + data[DATA_THIRD_OFFSET_ELEMENT] = HDMI_CEC_BCD_FORMAT_TIME(info->startMinute); + data[DATA_FORTH_OFFSET_ELEMENT] = HDMI_CEC_BCD_FORMAT_TIME(info->durationHour); + data[DATA_FIFTH_OFFSET_ELEMENT] = HDMI_CEC_BCD_FORMAT_TIME(info->durationMinute); + data[DATA_SIXTH_OFFSET_ELEMENT] = info->recordingSeq; +} + +static void HdmiCecEncodingAnalogueTimerInfo(uint8_t *data, uint8_t len, struct HdmiCecAnalogueTimerInfo *info) +{ + if (len < HDMI_CEC_ANALOGUE_TIMER_INFO_LEN) { + return; + } + HdmiCecEncodingCommTimerInfo(data, HDMI_CEC_COMM_TIMER_INFO_LEN, &(info->commInfo)); + data[DATA_SEVENTH_OFFSET_ELEMENT] = info->anaBcastType; + data[DATA_EIGHTH_OFFSET_ELEMENT] = (info->anaFreq >> HDMI_ONE_BYTE_SHIFT); + data[DATA_NINTH_OFFSET_ELEMENT] = (info->anaFreq & HDMI_ONE_BYTE_MARK); + data[DATA_TENTH_OFFSET_ELEMENT] = info->bcstSystem; +} + +void HdmiCecEncodingClearAnalogueTimerMsg(struct HdmiCecMsg *msg, struct HdmiCecAnalogueTimerInfo *info, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_ANALOGUE_TIMER_INFO_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_CLEAR_ANALOGUE_TIMER; + HdmiCecEncodingAnalogueTimerInfo(&(msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT]), + HDMI_CEC_ANALOGUE_TIMER_INFO_LEN, + info); + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_TIMER_CLEARED_STATUS; + } +} + +static void HdmiCecEncodingDigitalTimerInfo(uint8_t *data, uint8_t len, struct HdmiCecDigitalTimerInfo *info) +{ + if (len < HDMI_CEC_DIGITAL_TIMER_INFO_LEN) { + return; + } + HdmiCecEncodingCommTimerInfo(data, HDMI_CEC_COMM_TIMER_INFO_LEN, &(info->commInfo)); + HdmiCecEncodingDigitalServiceId(&data[DATA_SEVENTH_OFFSET_ELEMENT], + len - HDMI_CEC_COMM_TIMER_INFO_LEN, + &(info->id)); +} + +void HdmiCecEncodingClearDigitalTimerMsg(struct HdmiCecMsg *msg, struct HdmiCecDigitalTimerInfo *info, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_DIGITAL_TIMER_INFO_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_CLEAR_DIGITAL_TIMER; + HdmiCecEncodingDigitalTimerInfo(&(msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT]), + HDMI_CEC_DIGITAL_TIMER_INFO_LEN, + info); + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_TIMER_CLEARED_STATUS; + } +} + +static void HdmiCecEncodingExternalTimerInfo(uint8_t *data, uint8_t len, struct HdmiCecExternalTimerInfo *info) +{ + if (len < HDMI_CEC_EXTERNAL_TIMER_INFO_LEN) { + return; + } + HdmiCecEncodingCommTimerInfo(data, HDMI_CEC_COMM_TIMER_INFO_LEN, &(info->commInfo)); + data[DATA_SEVENTH_OFFSET_ELEMENT] = info->extSrcSpec; + data[DATA_EIGHTH_OFFSET_ELEMENT] = info->extPlug; + data[DATA_NINTH_OFFSET_ELEMENT] = (info->extPhyAddr >> HDMI_ONE_BYTE_SHIFT); + data[DATA_TENTH_OFFSET_ELEMENT] = (info->extPhyAddr & HDMI_ONE_BYTE_MARK); +} + +void HdmiCecEncodingClearExternalTimerMsg(struct HdmiCecMsg *msg, struct HdmiCecExternalTimerInfo *info, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_EXTERNAL_TIMER_INFO_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_CLEAR_EXTERNAL_TIMER; + HdmiCecEncodingExternalTimerInfo(&(msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT]), + HDMI_CEC_EXTERNAL_TIMER_INFO_LEN, + info); + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_TIMER_CLEARED_STATUS; + } +} + +void HdmiCecEncodingSetAnalogueTimerMsg(struct HdmiCecMsg *msg, struct HdmiCecAnalogueTimerInfo *info, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_ANALOGUE_TIMER_INFO_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_SET_ANALOGUE_TIMER; + HdmiCecEncodingAnalogueTimerInfo(&(msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT]), + HDMI_CEC_ANALOGUE_TIMER_INFO_LEN, + info); + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_TIMER_STATUS; + } +} + +void HdmiCecEncodingSetDigitalTimerMsg(struct HdmiCecMsg *msg, struct HdmiCecDigitalTimerInfo *info, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_DIGITAL_TIMER_INFO_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_SET_DIGITAL_TIMER; + HdmiCecEncodingDigitalTimerInfo(&(msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT]), + HDMI_CEC_DIGITAL_TIMER_INFO_LEN, + info); + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_TIMER_STATUS; + } +} + +void HdmiCecEncodingSetExternalTimerMsg(struct HdmiCecMsg *msg, struct HdmiCecExternalTimerInfo *info, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_EXTERNAL_TIMER_INFO_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_SET_EXTERNAL_TIMER; + HdmiCecEncodingExternalTimerInfo(&(msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT]), + HDMI_CEC_EXTERNAL_TIMER_INFO_LEN, + info); + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_TIMER_STATUS; + } +} + +void HdmiCecEncodingSetTimerProgramTitleMsg(struct HdmiCecMsg *msg, uint8_t *title, uint32_t len) +{ + uint32_t length; + + if (title == NULL || len < HDMI_CEC_PROGRAM_TITLE_STR_MIN_LEN) { + HDF_LOGE("encoding set timer program title, input param invalid."); + return; + } + length = ((len <= HDMI_CEC_PROGRAM_TITLE_STR_MAX_LEN) ? len : HDMI_CEC_PROGRAM_TITLE_STR_MAX_LEN); + msg->len = HDMI_CEC_GET_MSG_LEN(length); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_SET_TIMER_PROGRAM_TITLE; + if (memcpy_s(&(msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT]), (msg->len - 2), title, length) != EOK) { + HDF_LOGE("encoding set timer program title, memcpy_s fail."); + } +} + +void HdmiCecEncodingTimerClearedStatusMsg(struct HdmiCecMsg *msg, uint8_t status) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_TIMER_CLEARED_STATUS_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_TIMER_CLEARED_STATUS; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = status; +} + +void HdmiCecEncodingTimerStatusMsg(struct HdmiCecMsg *msg, struct HdmiCecTimerStatusData *status) +{ + bool duration = false; + + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_TIMER_STATUS_DATA_MIN_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_TIMER_STATUS; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] |= (status->timerOverlap << 7); + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] |= (status->mediaInfo << 5); + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] |= (status->progInfo.indicator << 4); + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] |= (status->progInfo.info); + if (status->progInfo.indicator > 0) { + /* Progremmed Info */ + if (status->progInfo.info == HDMI_CEC_PROGRAMMED_INFO_NOT_ENOUGH_SPAC || + status->progInfo.info == HDMI_CEC_PROGRAMMED_INFO_MIGHT_NOT_BE_ENOUGH_SPACE) { + duration = true; + } + } else { + /* Not Progremmed Error Info */ + if (status->progInfo.info == HDMI_CEC_NOT_PROG_ERR_DUPLICATE) { + duration = true; + } + } + if (duration == true) { + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_TIMER_STATUS_DATA_MAX_LEN); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = HDMI_CEC_BCD_FORMAT_TIME(status->progInfo.durationHour); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = HDMI_CEC_BCD_FORMAT_TIME(status->progInfo.durationMinute); + } +} + +void HdmiCecEncodingCecVersionMsg(struct HdmiCecMsg *msg, uint8_t version) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_CEC_VERSION_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_CEC_VERSION; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = version; +} + +void HdmiCecEncodingGetCecVersionMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_GET_CEC_VERSION; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_CEC_VERSION; + } +} + +void HdmiCecEncodingGetPhyAddressMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_GIVE_PHYSICAL_ADDRESS; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_REPORT_PHYSICAL_ADDRESS; + } +} + +void HdmiCecEncodingGetMenuLanguageMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_GET_MENU_LANGUAGE; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_SET_MENU_LANGUAGE; + } +} + +void HdmiCecEncodingReportPhyAddressMsg(struct HdmiCecMsg *msg, uint16_t phyAddr, uint8_t deviceType) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_REPORT_PHYSICAL_ADDRESS_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_REPORT_PHYSICAL_ADDRESS; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (phyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (phyAddr & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = deviceType; +} + +void HdmiCecEncodingSetMenuLanguageMsg(struct HdmiCecMsg *msg, uint8_t *language, uint32_t len) +{ + if (language == NULL || len != HDMI_CEC_SET_MENU_LANGUAGE_MSG_PARAM_LEN) { + HDF_LOGE("encoding set menu language, input param invalid."); + return; + } + + msg->len = HDMI_CEC_GET_MSG_LEN(len); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_SET_MENU_LANGUAGE; + if (memcpy_s(&(msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT]), (msg->len - 2), language, len) != EOK) { + HDF_LOGE("encoding set menu language, memcpy_s fail."); + } +} + +void HdmiCecEncodingReportFeaturesMsg(struct HdmiCecMsg *msg, struct HdmiCecInfo *info) +{ + uint32_t i; + + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_REPORT_FEATURES; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = info->cecVersion; + msg->len++; + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = info->allDeviceType; + msg->len++; + /* fill RC Profile. */ + for (i = 0; i < HDMI_CEC_RC_PROFILE_MAX_NUM; i++) { + msg->data[msg->len] = info->rcProfile[i]; + msg->len++; + if ((info->rcProfile[i] & HDMI_CEC_RC_PROFILE_EXTERNSION_MARK) == 0) { + break; + } + } + /* fill Device Features. */ + for (i = 0; i < HDMI_CEC_DEVICE_FEATURES_MAX_NUM; i++) { + msg->data[msg->len] = info->devFeatures[i]; + msg->len++; + if ((info->devFeatures[i] & HDMI_CEC_DEVICE_FEATURES_EXTERNSION_MARK) == 0) { + break; + } + } +} + +void HdmiCecEncodingGiveFeaturesMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_GIVE_FEATURES; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_SET_MENU_LANGUAGE; + } +} + + +void HdmiCecEncodingDeckControlMsg(struct HdmiCecMsg *msg, uint8_t mode) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_DECK_CONTROL_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_DECK_CONTROL; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = mode; +} + +void HdmiCecEncodingDeckStatusMsg(struct HdmiCecMsg *msg, uint8_t info) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_DECK_STATUS_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_DECK_STATUS; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = info; +} + +void HdmiCecEncodingGiveDeckStatusMsg(struct HdmiCecMsg *msg, uint8_t statusReq, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_GIVE_DECK_STATUS_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_GIVE_DECK_STATUS; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = statusReq; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_DECK_STATUS; + } +} + +void HdmiCecEncodingPlayMsg(struct HdmiCecMsg *msg, uint8_t playMode) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_PLAY_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_PLAY; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = playMode; +} + +void HdmiCecEncodingGiveTunerDeviceStatusMsg(struct HdmiCecMsg *msg, uint8_t statusReq, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_GIVE_TUNER_DEVICE_STATU_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_GIVE_TUNER_DEVICE_STATUS; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = statusReq; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_TUNER_DEVICE_STATUS; + } +} + +void HdmiCecEncodingSelectAnalogueServiceMsg(struct HdmiCecMsg *msg, + uint8_t anaBcastType, uint16_t anaFreq, uint8_t bcstSystem) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SELECT_ANALOGUE_SERVICE_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_SELECT_ANALOGUE_SERVICE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = anaBcastType; + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (anaFreq >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = (anaFreq & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_FIFTH_ELEMENT] = bcstSystem; +} + +void HdmiCecEncodingSelectDigitalServiceMsg(struct HdmiCecMsg *msg, struct HdmiCecDigitalServiceId *digital) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SELECT_DIGITAL_SERVICE_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_SELECT_DIGITAL_SERVICE; + HdmiCecEncodingDigitalServiceId(&(msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT]), + HDMI_CEC_SELECT_DIGITAL_SERVICE_MSG_PARAM_LEN, + digital); +} + +void HdmiCecEncodingTunerDeviceStatusMsg(struct HdmiCecMsg *msg, struct HdmiCecTunerDeviceInfo *info) +{ + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_TUNER_DEVICE_STATUS; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (info->recordingFlag << 7) | (info->dispInfo); + if (info->isAnalogService == true) { + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_TUNER_DEVICE_STATUS_MSG_ANA_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = info->data.analog.anaBcastType; + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = (info->data.analog.anaFreq >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_FIFTH_ELEMENT] = (info->data.analog.anaFreq & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_SIXTH_ELEMENT] = info->data.analog.bcstSystem; + } else { + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_TUNER_DEVICE_STATUS_MSG_DIG_PARAM_LEN); + HdmiCecEncodingDigitalServiceId(&(msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT]), + HDMI_CEC_SELECT_DIGITAL_SERVICE_MSG_PARAM_LEN, + &(info->data.digital)); + } +} + +void HdmiCecEncodingTunerStepDecrementMsg(struct HdmiCecMsg *msg) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_TUNER_STEP_DECREMENT; +} + +void HdmiCecEncodingTunerStepIncrementMsg(struct HdmiCecMsg *msg) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_TUNER_STEP_INCREMENT; +} + +void HdmiCecEncodingDeviceVendorIdMsg(struct HdmiCecMsg *msg, uint32_t devVendorId) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_DEVICE_VENDOR_ID_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_DEVICE_VENDOR_ID; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (devVendorId >> HDMI_TWO_BYTES_SHIFT) & HDMI_ONE_BYTE_MARK; + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (devVendorId >> HDMI_ONE_BYTE_SHIFT) & HDMI_ONE_BYTE_MARK; + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = (devVendorId & HDMI_ONE_BYTE_MARK); +} + +void HdmiCecEncodingGiveDeviceVendorIdMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_GIVE_DEVICE_VENDOR_ID; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_DEVICE_VENDOR_ID; + } +} + +void HdmiCecEncodingVendorCommandMsg(struct HdmiCecMsg *msg, uint8_t *data, uint32_t len) +{ + uint32_t length; + + if (data == NULL || len == 0) { + HDF_LOGE("encoding vendor cmd, input param invalid."); + return; + } + length = (len > HDMI_CEC_VENDOR_SPECIFIC_DATA_MAX_LEN) ? HDMI_CEC_VENDOR_SPECIFIC_DATA_MAX_LEN : len; + msg->len = HDMI_CEC_GET_MSG_LEN(length); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_VENDOR_COMMAND; + if (memcpy_s(&(msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT]), (msg->len - 2), data, length) != EOK) { + HDF_LOGE("encoding vendor cmd, memcpy_s fail."); + } +} + +void HdmiCecEncodingVendorCommandWithIdMsg(struct HdmiCecMsg *msg, uint32_t vendorId, uint8_t *data, uint32_t len) +{ + uint32_t length; + + if (data == NULL || len == 0) { + HDF_LOGE("encoding vendor cmd with id, input param invalid."); + return; + } + length = (len > HDMI_CEC_VENDOR_SPECIFIC_DATA_WITH_ID_MAX_LEN) ? + HDMI_CEC_VENDOR_SPECIFIC_DATA_WITH_ID_MAX_LEN : len; + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_VENDOR_ID_LEN + length); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_VENDOR_COMMAND_WITH_ID; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (vendorId >> HDMI_TWO_BYTES_SHIFT) & HDMI_ONE_BYTE_MARK; + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (vendorId >> HDMI_ONE_BYTE_SHIFT) & HDMI_ONE_BYTE_MARK; + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = (vendorId & HDMI_ONE_BYTE_MARK); + if (memcpy_s(&(msg->data[HDMI_CEC_MSG_DATA_FIFTH_ELEMENT]), (msg->len - 5), data, length) != EOK) { + HDF_LOGE("encoding vendor cmd with id, memcpy_s fail."); + } +} + +void HdmiCecEncodingVendorRemoteButtonDownMsg(struct HdmiCecMsg *msg, uint8_t *rcCode, uint32_t len) +{ + uint32_t length; + + if (rcCode == NULL || len == 0) { + HDF_LOGE("encoding vendor remote button down, input param invalid."); + return; + } + length = (len > HDMI_CEC_VENDOR_SPECIFIC_RC_CODE_MAX_LEN) ? HDMI_CEC_VENDOR_SPECIFIC_RC_CODE_MAX_LEN : len; + msg->len = HDMI_CEC_GET_MSG_LEN(length); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_VENDOR_REMOTE_BUTTON_DOWN; + if (memcpy_s(&(msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT]), (msg->len - 2), rcCode, length) != EOK) { + HDF_LOGE("encoding vendor remote button down, memcpy_s fail."); + } +} + +void HdmiCecEncodingVendorRemoteButtonUpMsg(struct HdmiCecMsg *msg) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_VENDOR_REMOTE_BUTTON_UP; +} + +void HdmiCecEncodingSetOsdStringMsg(struct HdmiCecMsg *msg, uint8_t dispControl, uint8_t *str, uint32_t len) +{ + uint32_t length; + + if (str == NULL || len == 0) { + HDF_LOGE("encoding set OSD string, input param invalid."); + return; + } + length = (len > HDMI_CEC_OSD_STRING_MAX_LEN) ? HDMI_CEC_OSD_STRING_MAX_LEN : len; + msg->len = HDMI_CEC_GET_MSG_LEN(length + HDMI_CEC_DISPLAY_CONTROL_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_SET_OSD_STRING; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = dispControl; + if (memcpy_s(&(msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT]), (msg->len - 3), str, length) != EOK) { + HDF_LOGE("encoding set OSD string, memcpy_s fail."); + } +} + +void HdmiCecEncodingGiveOsdNameMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_GIVE_OSD_NAME; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_SET_OSD_NAME; + } +} + +void HdmiCecEncodingSetOsdNameMsg(struct HdmiCecMsg *msg, uint8_t *name, uint32_t len) +{ + uint32_t length; + + if (name == NULL || len == 0) { + HDF_LOGE("encoding set OSD name, input param invalid."); + return; + } + length = (len > HDMI_CEC_OSD_NAME_MAX_LEN) ? HDMI_CEC_OSD_NAME_MAX_LEN : len; + msg->len = HDMI_CEC_GET_MSG_LEN(length); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_SET_OSD_NAME; + if (memcpy_s(&(msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT]), (msg->len - 2), name, length) != EOK) { + HDF_LOGE("encoding set OSD name, memcpy_s fail."); + } +} + +void HdmiCecEncodingMenuRequestMsg(struct HdmiCecMsg *msg, uint8_t menuReq, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_MENU_REQUEST_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_MENU_REQUEST; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = menuReq; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_MENU_STATUS; + } +} + +void HdmiCecEncodingMenuStatusMsg(struct HdmiCecMsg *msg, uint8_t menuStatus) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_MENU_STATUS_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_MENU_STATUS; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = menuStatus; +} + +void HdmiCecEncodingUserControlPrtessedMsg(struct HdmiCecMsg *msg, struct HdmiCecUiCmd *cmd) +{ + if (cmd == NULL) { + return; + } + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_UI_COMMAND_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_USER_CONTROL_PRESSED; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = cmd->cmdType; + if (cmd->hasAddOp == false) { + return; + } + switch (cmd->cmdType) { + case HDMI_CEC_UI_CMD_SELECT_BROADCAST_TYPE: + case HDMI_CEC_UI_CMD_SELECT_SOUND_PRESENTATION: + case HDMI_CEC_UI_CMD_PLAY_FUNCTION: + case HDMI_CEC_UI_CMD_SELECT_MEDIA_FUNCTION: + case HDMI_CEC_UI_CMD_SELECT_AV_INPUT_FUNCTION: + case HDMI_CEC_UI_CMD_SELECT_AUDIO_INPUT_FUNCTION: + (msg->len)++; + /* The additional operand is one byte for all these UI commands */ + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = cmd->addOperands.uiBroadcastType; + break; + case HDMI_CEC_UI_CMD_TUNE_FUNCTION: + msg->len += HDMI_CEC_CHANNEL_IDENTIFIER_LEN; + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (cmd->addOperands.channel.format << + HDMI_CEC_CHANNEL_NUMBER_FORMAT_SHIFT) | + (cmd->addOperands.channel.major >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = (cmd->addOperands.channel.major & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_FIFTH_ELEMENT] = (cmd->addOperands.channel.minor >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_SIXTH_ELEMENT] = (cmd->addOperands.channel.minor & HDMI_ONE_BYTE_MARK); + break; + default: + HDF_LOGI("UI type %d have no additional operands.", cmd->cmdType); + break; + } +} + +void HdmiCecEncodingUserControlReleasedMsg(struct HdmiCecMsg *msg) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_USER_CONTROL_RELEASED; +} + +void HdmiCecEncodingGiveDevicePowerStatusMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_GIVE_DEVICE_POWER_STATUS; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_REPORT_POWER_STATUS; + } +} + +void HdmiCecEncodingReportDevicePowerStatusMsg(struct HdmiCecMsg *msg, uint8_t powerStatus) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_REPORT_POWER_STATUS_MSG_PARA_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_REPORT_POWER_STATUS; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = powerStatus; +} + +void HdmiCecEncodingFeatureAbortMsg(struct HdmiCecMsg *msg, uint8_t opcode, uint8_t reason) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_FEATURE_ABORT_MSG_PARA_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_FEATURE_ABORT; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = opcode; + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = reason; +} + +void HdmiCecEncodingAbortMsg(struct HdmiCecMsg *msg) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_ABORT; +} + +void HdmiCecEncodingGiveAudioStatusMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_GIVE_AUDIO_STATUS; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_REPORT_AUDIO_STATUS; + } +} + +void HdmiCecEncodingGiveSystemAudioModeMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_GIVE_SYSTEM_AUDIO_MODE_STATUS; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS; + } +} + +void HdmiCecEncodingReportAudioStatusMsg(struct HdmiCecMsg *msg, uint8_t audioMuteStatus, uint8_t audioVolumeStatus) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_REPORT_AUDIO_STATUSMSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_REPORT_AUDIO_STATUS; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (audioMuteStatus << HDMI_CEC_AUDIO_MUTE_STATUS_SHIFT) | + (audioVolumeStatus & HDMI_CEC_AUDIO_VOLUME_STATUS_MARK); +} + +void HdmiCecEncodingRequestShortAudioDescriptorMsg(struct HdmiCecMsg *msg, + uint8_t *id, uint8_t *code, uint32_t len, bool response) +{ + uint32_t num, i; + + if (id == NULL || code == NULL || len == 0) { + HDF_LOGE("encoding request short audio descriptor, input param invalid."); + return; + } + num = (len > HDMI_CEC_MAX_AUDIO_FORMAT_NUM) ? HDMI_CEC_MAX_AUDIO_FORMAT_NUM : len; + msg->len = HDMI_CEC_GET_MSG_LEN(num * HDMI_CEC_AUDIO_FORMAT_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_REQUEST_SHORT_AUDIO_DESCRIPTOR; + for (i = 0; i < num; i++) { + msg->data[2 + i] = (id[i] << HDMI_CEC_AUDIO_FORMAT_ID_SHIFT) | (code[i] & HDMI_CEC_AUDIO_FORMAT_CODE_MARK); + } + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_REPORT_SHORT_AUDIO_DESCRIPTOR; + } +} + +void HdmiCecEncodingReportShortAudioDescriptorMsg(struct HdmiCecMsg *msg, uint32_t *descriptor, uint32_t len) +{ + uint32_t num, i; + + if (descriptor == NULL || len == 0) { + HDF_LOGE("encoding report short audio descriptor, input param invalid."); + return; + } + num = (len > HDMI_CEC_MAX_SHORT_AUDIO_DESCRIPTOR_NUM) ? HDMI_CEC_MAX_SHORT_AUDIO_DESCRIPTOR_NUM : len; + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SHORT_AUDIO_DESCRIPTOR_LEN * num); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_REPORT_SHORT_AUDIO_DESCRIPTOR; + for (i = 0; i < num; i++) { + msg->data[2 + i * HDMI_CEC_SHORT_AUDIO_DESCRIPTOR_LEN] = + (descriptor[i] >> HDMI_TWO_BYTES_SHIFT) & HDMI_ONE_BYTE_MARK; + msg->data[3 + i * HDMI_CEC_SHORT_AUDIO_DESCRIPTOR_LEN] = + (descriptor[i] >> HDMI_ONE_BYTE_SHIFT) & HDMI_ONE_BYTE_MARK; + msg->data[4 + i * HDMI_CEC_SHORT_AUDIO_DESCRIPTOR_LEN] = descriptor[i] & HDMI_ONE_BYTE_MARK; + } +} + +void HdmiCecEncodingSetSystemAudioModeMsg(struct HdmiCecMsg *msg, uint8_t status) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SYSTEM_AUDIO_STATUS_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_SET_SYSTEM_AUDIO_MODE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = status; +} + +void HdmiCecEncodingSystemAudioModeRequestMsg(struct HdmiCecMsg *msg, uint16_t phyAddr, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SYSTEM_AUDIO_MODE_REQUEST_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_SYSTEM_AUDIO_MODE_REQUEST; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (phyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (phyAddr & HDMI_ONE_BYTE_MARK); + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_SET_SYSTEM_AUDIO_MODE; + } +} + +void HdmiCecEncodingSystemAudioModeStatusMsg(struct HdmiCecMsg *msg, uint8_t status) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SYSTEM_AUDIO_STATUS_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_SYSTEM_AUDIO_MODE_STATUS; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = status; +} + +void HdmiCecEncodingSetAudioRateMsg(struct HdmiCecMsg *msg, uint8_t rate) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_SET_AUDIO_RATE_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_SET_AUDIO_RATE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = rate; +} + +void HdmiCecEncodingInitiateArcMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_INITIATE_ARC; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_REPORT_ARC_INITIATED; + } +} + +void HdmiCecEncodingReportArcInitiatedMsg(struct HdmiCecMsg *msg) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_REPORT_ARC_INITIATED; +} + +void HdmiCecEncodingReportArcTerminationMsg(struct HdmiCecMsg *msg) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_REPORT_ARC_TERMINATION; +} + +void HdmiCecEncodingRequestArcInitiationMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_REQUEST_ARC_INITIATION; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_INITIATE_ARC; + } +} + +void HdmiCecEncodingRequestArcTerminationMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_REQUEST_ARC_TERMINATION; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_TERMINATE_ARC; + } +} + +void HdmiCecEncodingTerminateArcMsg(struct HdmiCecMsg *msg, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_TERMINATE_ARC; + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_REPORT_ARC_TERMINATION; + } +} + +void HdmiCecEncodingRequestCurrentLatencyMsg(struct HdmiCecMsg *msg, uint16_t phyAddr, bool response) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_REQUEST_CURRENT_LATENCY_MSG_LEN); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_REQUEST_CURRENT_LATENCY; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (phyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (phyAddr & HDMI_ONE_BYTE_MARK); + if (response == true) { + msg->rspMsg = HDMI_CEC_OPCODE_REPORT_CURRENT_LATENCY; + } +} + +void HdmiCecEncodingReportCurrentLatencyMsg(struct HdmiCecMsg *msg, + uint16_t phyAddr, struct HdmiCecLatencyInfo *info) +{ + msg->len = HDMI_CEC_GET_MSG_LEN(HDMI_CEC_REPORT_CURRENT_LATENCY_MSG_PARAM_MIN_LEN); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_REPORT_CURRENT_LATENCY; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (phyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (phyAddr & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = info->videoLatency; + msg->data[HDMI_CEC_MSG_DATA_FIFTH_ELEMENT] = (info->lowLatencyMode << HDMI_CEC_LOW_LATENCY_MODE_SHIFT) | + (info->audioOutputCompensated); + /* Operand[Audio Output Delay] is only present when [Audio Output Compensated] is 3. */ + if (info->audioOutputCompensated == HDMI_CEC_AUDIO_OUTPUT_COMPENSATED_PARTIAL_DELAY) { + msg->len++; + msg->data[HDMI_CEC_MSG_DATA_SIXTH_ELEMENT] = info->audioOutputDelay; + } +} + +/* CDC Message Encoding. */ +void HdmiCdcEncodingHecInquireStateMsg(struct HdmiCecMsg *msg, uint16_t initiatorPhyAddr, + uint16_t phyAddr1, uint16_t phyAddr2, bool response) +{ + msg->len = HDMI_CDC_GET_MSG_LEN(HDMI_CDC_HEC_INQUIRE_STATE_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_CDC_MESSAGE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (initiatorPhyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (initiatorPhyAddr & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = HDMI_CDC_HEC_INQUIRE_STATE; + msg->data[HDMI_CEC_MSG_DATA_FIFTH_ELEMENT] = (phyAddr1 >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_SIXTH_ELEMENT] = (phyAddr1 & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_SEVENTH_ELEMENT] = (phyAddr2 >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_EIGHTH_ELEMENT] = (phyAddr2 & HDMI_ONE_BYTE_MARK); + if (response == true) { + msg->rspMsg = HDMI_CDC_HEC_REPORT_STATE; + } +} + +void HdmiCdcEncodingHecReportStateMsg(struct HdmiCecMsg *msg, uint16_t initiatorPhyAddr, + uint16_t phyAddr, struct HdmiCdcHecState *state) +{ + msg->len = HDMI_CDC_GET_MSG_LEN(HDMI_CDC_HEC_REPORT_STATE_MSG_PARAM_MIN_LEN); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_CDC_MESSAGE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (initiatorPhyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (initiatorPhyAddr & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = HDMI_CDC_HEC_REPORT_STATE; + msg->data[HDMI_CEC_MSG_DATA_FIFTH_ELEMENT] = (phyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_SIXTH_ELEMENT] = (phyAddr & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_SEVENTH_ELEMENT] = (state->hecFuncState << HDMI_CDC_HEC_FUNC_STATE_SHIFT) | + (state->hostFuncState << HDMI_CDC_HOST_FUNC_STATE_SHIFT) | + (state->encFuncState << HDMI_CDC_ENC_FUNC_STATE_SHIFT) | + (state->cdcErrCode); + if (state->haveHecField == true) { + msg->len = HDMI_CDC_GET_MSG_LEN(HDMI_CDC_HEC_REPORT_STATE_MSG_PARAM_MAX_LEN); + msg->data[HDMI_CEC_MSG_DATA_EIGHTH_ELEMENT] = (state->hecField >> HDMI_ONE_BYTE_SHIFT); + msg->data[DATA_NINTH_OFFSET_ELEMENT] = (state->hecField & HDMI_ONE_BYTE_MARK); + } +} + +void HdmiCdcEncodingHecSetStateAdjacentMsg(struct HdmiCecMsg *msg, uint16_t initiatorPhyAddr, + uint16_t phyAddr, uint8_t hecSetState, bool response) +{ + msg->len = HDMI_CDC_GET_MSG_LEN(HDMI_CDC_HEC_SET_STATE_ADJACENT_MSG_PARAM_LEN); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_CDC_MESSAGE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (initiatorPhyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (initiatorPhyAddr & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = HDMI_CDC_HEC_SET_STATE_ADJACENT; + msg->data[HDMI_CEC_MSG_DATA_FIFTH_ELEMENT] = (phyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_SIXTH_ELEMENT] = (phyAddr & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_SEVENTH_ELEMENT] = hecSetState; + if (response == true) { + msg->rspMsg = HDMI_CDC_HEC_REPORT_STATE; + } +} + +void HdmiCdcEncodingHecSetStateMsg(struct HdmiCecMsg *msg, uint16_t initiatorPhyAddr, + struct HemiCdcHecStateInfo *info, bool response) +{ + uint32_t i; + + msg->len = HDMI_CDC_GET_MSG_LEN(HDMI_CDC_HEC_SET_STATE_MSG_MIN_LEN); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_CDC_MESSAGE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (initiatorPhyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (initiatorPhyAddr & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = HDMI_CDC_HEC_SET_STATE; + msg->data[HDMI_CEC_MSG_DATA_FIFTH_ELEMENT] = (info->phyAddr1 >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_SIXTH_ELEMENT] = (info->phyAddr1 & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_SEVENTH_ELEMENT] = (info->phyAddr2 >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_EIGHTH_ELEMENT] = (info->phyAddr2 & HDMI_ONE_BYTE_MARK); + msg->data[DATA_NINTH_OFFSET_ELEMENT] = info->hecSetState; + for (i = 0; (i < info->phyAddrLen) && (i < HDMI_CDC_HEC_SET_STATE_MSG_OPTIONAL_PA_MAX_NUM); i++) { + if (info->phyAddr[i] == HDMI_CEC_INVALID_PHY_ADDR) { + break; + } + msg->data[msg->len] = (info->phyAddr[i] >> HDMI_ONE_BYTE_SHIFT); + (msg->len)++; + msg->data[msg->len] = (info->phyAddr[i] & HDMI_ONE_BYTE_MARK); + (msg->len)++; + } + if (response == true) { + msg->rspMsg = HDMI_CDC_HEC_REPORT_STATE; + } +} + +void HdmiCdcEncodingHecRequestDeactivationMsg(struct HdmiCecMsg *msg, uint16_t initiatorPhyAddr, + uint16_t *phyAddr, uint32_t len, bool response) +{ + uint32_t i; + + if (phyAddr == NULL || len != HDMI_CDC_HEC_REQUEST_DEACTIVATION_MSG_PHY_ADDR_NUM) { + return; + } + msg->len = HDMI_CDC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_CDC_MESSAGE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (initiatorPhyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (initiatorPhyAddr & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = HDMI_CDC_HEC_REQUEST_DEACTIVATION; + for (i = 0; i < len; i++) { + msg->data[msg->len] = (phyAddr[i] >> HDMI_ONE_BYTE_SHIFT); + (msg->len)++; + msg->data[msg->len] = (phyAddr[i] & HDMI_ONE_BYTE_MARK); + (msg->len)++; + } + if (response == true) { + msg->rspMsg = HDMI_CDC_HEC_REPORT_STATE; + } +} + +void HdmiCdcEncodingHecNotifyAliveMsg(struct HdmiCecMsg *msg, uint16_t initiatorPhyAddr) +{ + msg->len = HDMI_CDC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_CDC_MESSAGE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (initiatorPhyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (initiatorPhyAddr & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = HDMI_CDC_HEC_NOTIFY_ALIVE; +} + +void HdmiCdcEncodingHecDiscoverMsg(struct HdmiCecMsg *msg, uint16_t initiatorPhyAddr, bool response) +{ + msg->len = HDMI_CDC_GET_MSG_LEN(0); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_CDC_MESSAGE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (initiatorPhyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (initiatorPhyAddr & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = HDMI_CDC_HEC_DISCOVER; + if (response == true) { + msg->rspMsg = HDMI_CDC_HEC_REPORT_STATE; + } +} + +void HdmiCdcEncodingHpdSetStateMsg(struct HdmiCecMsg *msg, uint16_t initiatorPhyAddr, + uint8_t portNum, uint8_t hpdState, bool response) +{ + msg->len = HDMI_CDC_GET_MSG_LEN(HDMI_CDC_HPD_SET_STATE_MSG_LEN); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_CDC_MESSAGE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (initiatorPhyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (initiatorPhyAddr & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = HDMI_CDC_HPD_SET_STATE; + msg->data[HDMI_CEC_MSG_DATA_FIFTH_ELEMENT] = (portNum << HDMI_CDC_INPUT_PORT_NUMBER_SHIFT) | hpdState; + if (response == true) { + msg->rspMsg = CEC_MSG_CDC_HPD_REPORT_STATE; + } +} + +void HdmiCdcEncodingHpdReportStateMsg(struct HdmiCecMsg *msg, uint16_t initiatorPhyAddr, + uint8_t hpdState, uint8_t errCode) +{ + msg->len = HDMI_CDC_GET_MSG_LEN(HDMI_CDC_HPD_REPORT_STATE_MSG_LEN); + msg->data[HDMI_CEC_MSG_DATA_ZEROTH_ELEMENT] |= HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST; + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT] = HDMI_CEC_OPCODE_CDC_MESSAGE; + msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] = (initiatorPhyAddr >> HDMI_ONE_BYTE_SHIFT); + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT] = (initiatorPhyAddr & HDMI_ONE_BYTE_MARK); + msg->data[HDMI_CEC_MSG_DATA_FORTH_ELEMENT] = CEC_MSG_CDC_HPD_REPORT_STATE; + msg->data[HDMI_CEC_MSG_DATA_FIFTH_ELEMENT] = (hpdState << HDMI_CDC_INPUT_PORT_NUMBER_SHIFT) | errCode; +} + +static int32_t HdmiCecSendMsg(struct HdmiCntlr *cntlr, struct HdmiCecMsg *msg) +{ + int32_t ret; + + if (cntlr->ops == NULL || cntlr->ops->cecMsgSend == NULL) { + return HDF_ERR_NOT_SUPPORT; + } + + if (msg->response == true) { + msg->timeout = HDMI_CEC_WAIT_RESPONSE_MSG_MAX_TIME; + } + + HdmiCntlrLock(cntlr); + ret = cntlr->ops->cecMsgSend(cntlr, msg); + HdmiCntlrUnlock(cntlr); + return ret; +} + +static bool HdmiCecMsgIgnore(uint8_t opcode, bool unregistered, bool broadcast) +{ + switch (opcode) { + case HDMI_CEC_OPCODE_GET_CEC_VERSION: + case HDMI_CEC_OPCODE_ABORT: + case HDMI_CEC_OPCODE_GIVE_DEVICE_POWER_STATUS: + case HDMI_CEC_OPCODE_GIVE_OSD_NAME: + /* Ignore if initiator is Unregistered, because these messages should reply with a directed message. */ + if (unregistered == true) { + return true; + } + /* fallthrough */ + case HDMI_CEC_OPCODE_GIVE_DEVICE_VENDOR_ID: + case HDMI_CEC_OPCODE_GIVE_FEATURES: + case HDMI_CEC_OPCODE_GIVE_PHYSICAL_ADDRESS: + /* Ignore if addressing is wrong */ + if (broadcast == true) { + return true; + } + break; + case HDMI_CEC_OPCODE_USER_CONTROL_PRESSED: + case HDMI_CEC_OPCODE_USER_CONTROL_RELEASED: + if (unregistered == true || broadcast == true) { + return true; + } + break; + case HDMI_CEC_OPCODE_REPORT_PHYSICAL_ADDRESS: + if (broadcast == false) { + return true; + } + break; + default: + break; + } + return false; +} + +static void HdmiCecHandleReportPhyAddressMsg(struct HdmiCntlr *cntlr, + struct HdmiCecMsg *msg, struct HdmiCecMsg *txMsg) +{ + uint16_t phyAddr; + + phyAddr = ((msg->data[HDMI_CEC_MSG_DATA_SECOND_ELEMENT] << HDMI_ONE_BYTE_SHIFT) | + msg->data[HDMI_CEC_MSG_DATA_THIRD_ELEMENT]); + (void)cntlr; + (void)txMsg; + + HDF_LOGD("reported phy address is %x.%x.%x.%x, logical address is %d", + HDMI_CEC_PHY_ADDR_PHASE(phyAddr), HdmiCecGetMsgInitiator(msg)); +} + +static void HdmiCecHandleUserControlPrtessedMsg(struct HdmiCntlr *cntlr, + struct HdmiCecMsg *msg, struct HdmiCecMsg *txMsg) +{ + (void)msg; + (void)txMsg; + + /* Not support CEC Remote Control. */ + if (cntlr->cap.baseCap.bits.cecRc == 0) { + return; + } + HDF_LOGD("Now User Control Prtessed not support."); +} + +static void HdmiCecHandleUserControlReleasedMsg(struct HdmiCntlr *cntlr, + struct HdmiCecMsg *msg, struct HdmiCecMsg *txMsg) +{ + (void)msg; + (void)txMsg; + + /* Not support CEC Remote Control. */ + if (cntlr->cap.baseCap.bits.cecRc == 0) { + return; + } + HDF_LOGD("Now User Control Released not support."); +} + +static void HdmiCecHandleGetCecVersionMsg(struct HdmiCntlr *cntlr, + struct HdmiCecMsg *msg, struct HdmiCecMsg *txMsg) +{ + HdmiCecEncodingCecVersionMsg(txMsg, cntlr->cec->info.cecVersion); + if (HdmiCecSendMsg(cntlr, txMsg) != HDF_SUCCESS) { + HDF_LOGE("get cec version msg send fail"); + } +} + +static void HdmiCecHandleGivePhyAddressMsg(struct HdmiCntlr *cntlr, + struct HdmiCecMsg *msg, struct HdmiCecMsg *txMsg) +{ + /* Ignore for CEC switches using addr 15. */ + if ((cntlr->cec->info.primaryDeviceType == HDMI_CEC_DEVICE_TYPE_PURE_CEC_SWITCH) && + (HdmiCecGetMsgDestination(msg) == HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST)) { + return; + } + + HdmiCecEncodingReportPhyAddressMsg(txMsg, cntlr->cec->info.phyAddr, cntlr->cec->info.primaryDeviceType); + if (HdmiCecSendMsg(cntlr, txMsg) != HDF_SUCCESS) { + HDF_LOGE("give phy address msg send fail"); + } +} + +static void HdmiCecHandleGiveDeviceVendorIdMsg(struct HdmiCntlr *cntlr, + struct HdmiCecMsg *msg, struct HdmiCecMsg *txMsg) +{ + if (cntlr->cec->info.vendorId == HDMI_CEC_VENDOR_ID_UNKNOWN) { + HdmiCecEncodingFeatureAbortMsg(txMsg, + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT], + HDMI_CEC_ABORT_UNRECOGNIZED_OPCODE); + if (HdmiCecSendMsg(cntlr, txMsg) != HDF_SUCCESS) { + HDF_LOGE("feature abort msg send fail"); + } + return; + } + HdmiCecEncodingDeviceVendorIdMsg(txMsg, cntlr->cec->info.vendorId); + if (HdmiCecSendMsg(cntlr, txMsg) != HDF_SUCCESS) { + HDF_LOGE("give device vendor id msg send fail"); + } +} + +static void HdmiCecHandleAbortMsg(struct HdmiCntlr *cntlr, + struct HdmiCecMsg *msg, struct HdmiCecMsg *txMsg) +{ + /* Ignore for CEC switches. */ + if (cntlr->cec->info.primaryDeviceType == HDMI_CEC_DEVICE_TYPE_PURE_CEC_SWITCH) { + return; + } + HdmiCecEncodingFeatureAbortMsg(txMsg, msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT], HDMI_CEC_ABORT_REFUSED); + if (HdmiCecSendMsg(cntlr, txMsg) != HDF_SUCCESS) { + HDF_LOGE("feature abort msg send fail"); + } +} + +static void HdmiCecHandleGiveOsdNameMsg(struct HdmiCntlr *cntlr, + struct HdmiCecMsg *msg, struct HdmiCecMsg *txMsg) +{ + if (cntlr->cec->info.osdName[0] == 0) { + HdmiCecEncodingFeatureAbortMsg(txMsg, + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT], + HDMI_CEC_ABORT_UNRECOGNIZED_OPCODE); + if (HdmiCecSendMsg(cntlr, txMsg) != HDF_SUCCESS) { + HDF_LOGE("feature abort msg send fail"); + } + return; + } + + HdmiCecEncodingSetOsdNameMsg(txMsg, cntlr->cec->info.osdName, cntlr->cec->info.osdNameLen); + if (HdmiCecSendMsg(cntlr, txMsg) != HDF_SUCCESS) { + HDF_LOGE("set osd name msg send fail"); + } +} + +static void HdmiCecHandleGiveFeaturesMsg(struct HdmiCntlr *cntlr, + struct HdmiCecMsg *msg, struct HdmiCecMsg *txMsg) +{ + if (cntlr->cec->info.cecVersion < HDMI_CEC_VERSION_2_0) { + HdmiCecEncodingFeatureAbortMsg(txMsg, + msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT], + HDMI_CEC_ABORT_UNRECOGNIZED_OPCODE); + if (HdmiCecSendMsg(cntlr, txMsg) != HDF_SUCCESS) { + HDF_LOGE("feature abort msg send fail"); + } + return; + } + + HdmiCecEncodingReportFeaturesMsg(txMsg, &(cntlr->cec->info)); + if (HdmiCecSendMsg(cntlr, txMsg) != HDF_SUCCESS) { + HDF_LOGE("report feature msg send fail"); + } +} + +static void HdmiCecMsgDefaultHandle(struct HdmiCntlr *cntlr, + struct HdmiCecMsg *msg, struct HdmiCecMsg *txMsg) +{ + bool broadcast = HdmiCecIsBroadcastMsg(msg); + uint8_t opcode = msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT]; + bool isResponse = (cntlr->cec->info.isWaitingResponse == true && cntlr->cec->info.response == opcode); + + if (broadcast == true || isResponse == true) { + return; + } + if (opcode != HDMI_CEC_OPCODE_FEATURE_ABORT) { + return; + } + + HdmiCecEncodingFeatureAbortMsg(txMsg, opcode, HDMI_CEC_ABORT_UNRECOGNIZED_OPCODE); + if (HdmiCecSendMsg(cntlr, txMsg) != HDF_SUCCESS) { + HDF_LOGE("feature abort msg send fail"); + } +} + +static void HdmiCecMsgHandle(struct HdmiCntlr *cntlr, struct HdmiCecMsg *msg, + struct HdmiCecMsg *txMsg, uint8_t opcode) +{ + uint32_t i, len; + + struct HdmiCecHandleMsgFuncMap funcMap[] = { + { HDMI_CEC_OPCODE_GET_CEC_VERSION, HdmiCecHandleGetCecVersionMsg }, + { HDMI_CEC_OPCODE_REPORT_PHYSICAL_ADDRESS, HdmiCecHandleReportPhyAddressMsg }, + { HDMI_CEC_OPCODE_USER_CONTROL_PRESSED, HdmiCecHandleUserControlPrtessedMsg }, + { HDMI_CEC_OPCODE_USER_CONTROL_RELEASED, HdmiCecHandleUserControlReleasedMsg }, + { HDMI_CEC_OPCODE_GIVE_PHYSICAL_ADDRESS, HdmiCecHandleGivePhyAddressMsg }, + { HDMI_CEC_OPCODE_GIVE_DEVICE_VENDOR_ID, HdmiCecHandleGiveDeviceVendorIdMsg }, + { HDMI_CEC_OPCODE_ABORT, HdmiCecHandleAbortMsg }, + { HDMI_CEC_OPCODE_GIVE_OSD_NAME, HdmiCecHandleGiveOsdNameMsg }, + { HDMI_CEC_OPCODE_GIVE_FEATURES, HdmiCecHandleGiveFeaturesMsg } + }; + + len = sizeof(funcMap) / sizeof(funcMap[0]); + for (i = 0; i < len; i++) { + if (opcode == funcMap[i].opcode) { + funcMap[i].func(cntlr, msg, txMsg); + return; + } + } + HdmiCecMsgDefaultHandle(cntlr, msg, txMsg); +} + +static void HdmiCecUpdateResponseFlag(struct HdmiCec *cec, uint8_t opcode) +{ + /* receive response msg. */ + if (cec->info.isWaitingResponse == true && cec->info.response == opcode) { + cec->info.isWaitingResponse = false; + cec->info.response = 0; + } +} + +static void HdmiCecReceivedMsgHandle(struct HdmiCntlr *cntlr, struct HdmiCecMsg *msg) +{ + uint8_t opcode = msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT]; + bool broadcast = HdmiCecIsBroadcastMsg(msg); + bool unregistered = (HdmiCecGetMsgInitiator(msg) == HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST); + struct HdmiCecMsg txMsg = {0}; + + if (HdmiCecMsgIgnore(opcode, unregistered, broadcast) == true) { + HdmiCecUpdateResponseFlag(cntlr->cec, opcode); + return; + } + + HdmiCecFillMsgHeader(&txMsg, msg); + HdmiCecMsgHandle(cntlr, msg, &txMsg, opcode); + HdmiCecUpdateResponseFlag(cntlr->cec, opcode); +} + +int32_t HdmiCecReceivedMsg(struct HdmiCec *cec, struct HdmiCecMsg *msg) +{ + struct HdmiCntlr *cntlr = NULL; + uint8_t opcode, initiator, destination; + + if (cec == NULL || cec->priv == NULL || msg == NULL) { + HDF_LOGE("cec receive msg, input param invalid."); + return HDF_ERR_INVALID_PARAM; + } + + cntlr = (struct HdmiCntlr *)cec->priv; + if (cntlr->cap.baseCap.bits.cec == 0) { + HDF_LOGD("not support cec."); + return HDF_ERR_NOT_SUPPORT; + } + + if (msg->len < HDMI_CEC_MSG_MIN_LEN) { + HDF_LOGE("cec receive msg, len is error."); + return HDF_ERR_INVALID_PARAM; + } + + initiator = HdmiCecGetMsgInitiator(msg); + destination = HdmiCecGetMsgDestination(msg); + opcode = msg->data[HDMI_CEC_MSG_DATA_FIRST_ELEMENT]; + /* Check if this message is for us. */ + if ((initiator != HDMI_CEC_LOG_ADDR_UNREGISTERED_OR_BROADCAST) && + (HdmiCecLogAddrValid(cntlr->cec, initiator) == true)) { + return HDF_ERR_INVALID_PARAM; + } + if ((HdmiCecIsBroadcastMsg(msg) == false) && + (HdmiCecLogAddrValid(cec, destination) == false)) { + HDF_LOGD("this cec msg is not for us!"); + return HDF_ERR_INVALID_PARAM; + } + + if (cntlr->cec->info.logAddrMask == 0) { + return HDF_ERR_NOT_SUPPORT; + } + + /* CDC Only devices should ignore non-CDC messages. */ + if ((HdmiCecIsCdcOnlyDevice(cec) == true) && + (opcode != HDMI_CEC_OPCODE_CDC_MESSAGE)) { + HDF_LOGD("this cec msg is not cdc msg."); + return HDF_ERR_NOT_SUPPORT; + } + if (HdmiCecCheckMsgLen(cec, msg, opcode) == false) { + return HDF_ERR_INVALID_PARAM; + } + + HdmiCecReceivedMsgHandle(cntlr, msg); + return HDF_SUCCESS; +} diff --git a/support/platform/src/hdmi/hdmi_common.c b/support/platform/src/hdmi/hdmi_common.c new file mode 100644 index 0000000000000000000000000000000000000000..2cfac6c80a8cebe4fb88faff890ecee5d46c3f3f --- /dev/null +++ b/support/platform/src/hdmi/hdmi_common.c @@ -0,0 +1,345 @@ +/* + * Copyright (c) 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 "hdmi_common.h" +#include "hdf_log.h" + +#define HDF_LOG_TAG hdmi_common_c + +/* + * vic, pixel clk, vfreq, hactive, vactive, hblank, vblank, hfront, hsync, hback, vfront, vsync, vback, aspect, + * timing, I/P + */ +struct HdmiVideoDefInfo g_ceaVideoDefInfoMap[HDMI_CEA_VIDEO_CODE_MAX] = { + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + HDMI_PICTURE_ASPECT_NO_DATA, HDMI_VIDEO_TIMING_NONE, HDMI_VIDEO_FORMAT_NULL }, + { HDMI_VIC_640X480P60_4_3, 25175, 59940, 640, 480, 160, 45, 16, 96, 48, 10, 2, 33, + HDMI_PICTURE_ASPECT_4_3, HDMI_VIDEO_TIMING_640X480P60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_720X480P60_4_3, 27000, 59940, 720, 480, 138, 45, 16, 62, 60, 9, 6, 30, + HDMI_PICTURE_ASPECT_4_3, HDMI_VIDEO_TIMING_720X480P60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_720X480P60_16_9, 27000, 59940, 720, 480, 138, 45, 16, 62, 60, 9, 6, 30, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_720X480P60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_1280X720P60_16_9, 74250, 60000, 1280, 720, 370, 30, 110, 40, 220, 5, 5, 20, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_1280X720P60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_1920X1080I60_16_9, 74250, 60000, 1920, 1080, 280, 22, 88, 44, 148, 2, 5, 15, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_1920X1080I60, HDMI_VIDEO_FORMA_INTERLACE }, + { HDMI_VIC_1440X480I60_4_3, 27000, 59940, 1440, 480, 276, 22, 38, 124, 114, 4, 3, 15, + HDMI_PICTURE_ASPECT_4_3, HDMI_VIDEO_TIMING_1440X480I60, HDMI_VIDEO_FORMA_INTERLACE }, + { HDMI_VIC_1440X480I60_16_9, 27000, 59940, 1440, 480, 276, 22, 38, 124, 114, 4, 3, 15, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_1440X480I60, HDMI_VIDEO_FORMA_INTERLACE }, + { HDMI_VIC_1440X240P60_4_3, 27000, 60054, 1440, 240, 276, 22, 38, 124, 114, 4, 3, 15, + HDMI_PICTURE_ASPECT_4_3, HDMI_VIDEO_TIMING_1440X240P60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_1440X240P60_16_9, 27000, 60054, 1440, 240, 276, 22, 38, 124, 114, 4, 3, 15, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_1440X240P60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_2880X480I60_4_3, 54000, 59940, 2880, 480, 552, 22, 76, 248, 228, 4, 3, 15, + HDMI_PICTURE_ASPECT_4_3, HDMI_VIDEO_TIMING_2880X480I60, HDMI_VIDEO_FORMA_INTERLACE }, + { HDMI_VIC_2880X480I60_16_9, 54000, 59940, 2880, 480, 552, 22, 76, 248, 228, 4, 3, 15, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_2880X480I60, HDMI_VIDEO_FORMA_INTERLACE }, + { HDMI_VIC_2880X240P60_4_3, 54000, 60054, 2880, 240, 552, 22, 76, 248, 228, 4, 3, 15, + HDMI_PICTURE_ASPECT_4_3, HDMI_VIDEO_TIMING_2880X240I60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_2880X240P60_16_9, 54000, 60054, 2880, 240, 552, 23, 76, 248, 228, 4, 3, 15, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_2880X240I60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_1440X480P60_4_3, 54000, 59940, 1440, 480, 276, 45, 32, 124, 120, 9, 6, 30, + HDMI_PICTURE_ASPECT_4_3, HDMI_VIDEO_TIMING_1440X480P60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_1440X480P60_16_9, 54000, 59940, 1440, 480, 276, 45, 32, 124, 120, 9, 6, 30, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_1440X480P60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_1920X1080P60_16_9, 148500, 60000, 1920, 1080, 280, 45, 88, 44, 148, 4, 5, 36, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_1920X1080P60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_720X576P50_4_3, 27000, 50000, 720, 576, 144, 49, 12, 64, 68, 5, 5, 39, + HDMI_PICTURE_ASPECT_4_3, HDMI_VIDEO_TIMING_720X576P50, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_720X576P50_16_9, 27000, 50000, 720, 576, 144, 49, 12, 64, 68, 5, 5, 39, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_720X576P50, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_1280X720P50_16_9, 74250, 50000, 1280, 720, 700, 30, 440, 40, 220, 5, 5, 20, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_1280X720P50, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_1920X1080I50_16_9, 74250, 50000, 1920, 1080, 720, 24, 528, 44, 148, 2, 5, 15, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_1920X1080I50, HDMI_VIDEO_FORMA_INTERLACE }, + { HDMI_VIC_1440X576I50_4_3, 27000, 50000, 1440, 576, 288, 24, 24, 126, 138, 2, 3, 19, + HDMI_PICTURE_ASPECT_4_3, HDMI_VIDEO_TIMING_1440X576I50, HDMI_VIDEO_FORMA_INTERLACE }, + { HDMI_VIC_1440X576I50_16_9, 27000, 50000, 1440, 576, 288, 24, 24, 126, 138, 2, 3, 19, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_1440X576I50, HDMI_VIDEO_FORMA_INTERLACE }, + { HDMI_VIC_1440X576P50_4_3, 54000, 50000, 1440, 576, 288, 49, 24, 128, 136, 5, 5, 39, + HDMI_PICTURE_ASPECT_4_3, HDMI_VIDEO_TIMING_1440X576P50, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_1440X576P50_16_9, 54000, 50000, 1440, 576, 288, 49, 24, 128, 136, 5, 5, 39, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_1440X576P50, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_1920X1080P50_16_9, 148500, 50000, 1920, 1080, 720, 45, 528, 44, 148, 4, 5, 36, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_1920X1080P50, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_1920X1080P24_16_9, 742500, 24000, 1920, 1080, 830, 45, 638, 44, 148, 4, 5, 36, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_1920X1080P24, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_1920X1080P25_16_9, 742500, 25000, 1920, 1080, 720, 45, 528, 44, 148, 4, 5, 36, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_1920X1080P25, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_1920X1080P30_16_9, 742500, 30000, 1920, 1080, 280, 45, 88, 44, 148, 4, 5, 36, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_1920X1080P30, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_3840X2160P24_16_9, 297000, 24000, 3840, 2160, 1660, 90, 1276, 88, 296, 8, 10, 72, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_3840X2160P24, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_3840X2160P25_16_9, 297000, 25000, 3840, 2160, 1440, 90, 1056, 88, 296, 8, 10, 72, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_3840X2160P25, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_3840X2160P30_16_9, 297000, 30000, 3840, 2160, 560, 90, 176, 88, 296, 8, 10, 72, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_3840X2160P30, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_3840X2160P50_16_9, 594000, 50000, 3840, 2160, 1440, 90, 1056, 88, 296, 8, 10, 72, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_3840X2160P50, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_3840X2160P60_16_9, 594000, 60000, 3840, 2160, 560, 90, 176, 88, 296, 8, 10, 72, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_3840X2160P60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_4096X2160P24_256_135, 297000, 24000, 4096, 2160, 1404, 90, 1020, 88, 296, 8, 10, 72, + HDMI_PICTURE_ASPECT_256_135, HDMI_VIDEO_TIMING_4096X2160P24, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_4096X2160P25_256_135, 297000, 25000, 4096, 2160, 1184, 90, 968, 88, 128, 8, 10, 72, + HDMI_PICTURE_ASPECT_256_135, HDMI_VIDEO_TIMING_4096X2160P25, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_4096X2160P30_256_135, 297000, 30000, 4096, 2160, 304, 90, 88, 88, 128, 8, 10, 72, + HDMI_PICTURE_ASPECT_256_135, HDMI_VIDEO_TIMING_4096X2160P30, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_4096X2160P50_256_135, 594000, 50000, 4096, 2160, 1184, 90, 968, 88, 128, 8, 10, 72, + HDMI_PICTURE_ASPECT_256_135, HDMI_VIDEO_TIMING_4096X2160P50, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_4096X2160P60_256_135, 594000, 60000, 4096, 2160, 304, 90, 88, 88, 128, 8, 10, 72, + HDMI_PICTURE_ASPECT_256_135, HDMI_VIDEO_TIMING_4096X2160P60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_3840X2160P120_16_9, 1188000, 120000, 3840, 2160, 560, 90, 176, 88, 296, 8, 10, 72, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_3840X2160P120, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_7680X4320P24_16_9, 1188000, 24000, 7680, 4320, 3320, 180, 2552, 176, 592, 16, 20, 144, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_7680X4320P24, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_7680X4320P25_16_9, 1188000, 25000, 7680, 4320, 3120, 80, 2352, 176, 592, 16, 20, 44, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_7680X4320P25, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_7680X4320P30_16_9, 1188000, 30000, 7680, 4320, 1320, 80, 552, 176, 592, 16, 20, 44, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_7680X4320P30, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_VIC_4096X2160P120_256_135, 1188000, 120000, 4096, 2160, 304, 90, 88, 88, 128, 8, 10, 72, + HDMI_PICTURE_ASPECT_256_135, HDMI_VIDEO_TIMING_4096X2160P120, HDMI_VIDEO_FORMAT_PROGRESSIVE } +}; + +struct HdmiVideoDefInfo g_vesaVideoDefInfoMap[HDMI_VESA_VIDEO_CODE_MAX] = { + { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, HDMI_PICTURE_ASPECT_NO_DATA, + HDMI_VIDEO_TIMING_NONE, HDMI_VIDEO_FORMAT_NULL }, + { 0, 40000, 60317, 800, 600, 256, 28, 40, 128, 88, 1, 4, 23, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_800X600_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 33750, 60000, 848, 480, 240, 37, 16, 112, 112, 6, 8, 23, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_848X480_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 65000, 60004, 1024, 768, 320, 38, 24, 136, 160, 3, 6, 29, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1024X768_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 74250, 60000, 1280, 720, 370, 30, 110, 40, 220, 5, 5, 20, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1280X720_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 68250, 59995, 1280, 768, 160, 22, 48, 32, 80, 3, 7, 12, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1280X768_60_RB, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 79500, 59870, 1280, 768, 384, 30, 64, 128, 192, 3, 7, 20, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1280X768_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 71001, 59910, 1280, 800, 160, 23, 48, 32, 80, 3, 6, 14, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1280X800_60_RB, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 83500, 59810, 1280, 800, 400, 31, 72, 128, 200, 3, 6, 22, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1280X800_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 108000, 60000, 1280, 960, 520, 40, 96, 112, 312, 1, 3, 36, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1280X960_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 108000, 60020, 1280, 1024, 408, 42, 48, 112, 248, 1, 3, 38, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1280X1024_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 85500, 60015, 1360, 768, 432, 27, 64, 112, 256, 3, 6, 18, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1360X768_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 85501, 59790, 1366, 768, 426, 30, 70, 143, 213, 3, 3, 24, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1366X768_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 121749, 59978, 1400, 1050, 464, 39, 88, 144, 232, 3, 4, 32, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1400X1050_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 88749, 59901, 1440, 900, 160, 26, 48, 32, 80, 3, 6, 17, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1440X900_60_RB, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 106499, 59887, 1440, 900, 464, 34, 80, 152, 232, 3, 6, 25, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1440X900_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 108000, 60000, 1440, 1050, 144, 49, 12, 64, 68, 3, 6, 25, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1440X1050_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 108000, 60000, 1440, 1050, 144, 49, 12, 64, 68, 3, 6, 25, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1440X1050_60_RB, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 108000, 60000, 1600, 900, 200, 100, 24, 80, 96, 1, 3, 96, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1600X900_60_RB, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 162000, 60000, 1600, 1200, 560, 50, 64, 192, 304, 1, 3, 46, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1600X1200_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 118999, 59883, 1680, 1050, 160, 30, 48, 32, 80, 3, 6, 21, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1680X1050_60_RB, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 146249, 59954, 1680, 1050, 560, 39, 104, 176, 280, 3, 6, 30, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1680X1050_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 204751, 60000, 1792, 1344, 656, 50, 128, 200, 328, 1, 3, 46, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1792X1344_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 218249, 59995, 1856, 1392, 672, 47, 96, 224, 352, 1, 3, 43, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1856X1392_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 148500, 60000, 1920, 1080, 280, 45, 88, 44, 148, 4, 5, 36, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1920X1080_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 154000, 59950, 1920, 1200, 160, 35, 48, 32, 80, 3, 6, 26, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1920X1200_60_RB, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 193251, 59885, 1920, 1200, 672, 45, 136, 200, 336, 3, 6, 36, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1920X1200_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 234000, 60000, 1920, 1440, 680, 60, 128, 208, 344, 1, 3, 56, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_1920X1440_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 162000, 60000, 2048, 1152, 202, 48, 26, 80, 96, 1, 3, 44, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_2048X1152_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 82500, 50000, 2560, 1440, 520, 30, 260, 40, 220, 3, 3, 24, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_2560X1440_60_RB, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { 0, 348502, 59987, 2560, 1600, 944, 58, 192, 280, 472, 3, 6, 49, HDMI_PICTURE_ASPECT_16_9, + HDMI_VIDEO_TIMING_VESA_2560X1600_60, HDMI_VIDEO_FORMAT_PROGRESSIVE }, +}; + +struct HdmiVideo4kInfo g_video4kInfoMap[HDMI_VIDEO_4K_CODES_MAX] = { + { HDMI_4K_VIC_3840X2160_30, HDMI_VIC_3840X2160P30_16_9, 296703, 30, 3840, 2160, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_3840X2160P30, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_4K_VIC_3840X2160_25, HDMI_VIC_3840X2160P25_16_9, 297000, 25, 3840, 2160, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_3840X2160P25, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_4K_VIC_3840X2160_24, HDMI_VIC_3840X2160P24_16_9, 296703, 24, 3840, 2160, + HDMI_PICTURE_ASPECT_16_9, HDMI_VIDEO_TIMING_3840X2160P24, HDMI_VIDEO_FORMAT_PROGRESSIVE }, + { HDMI_4K_VIC_4096X2160_24, HDMI_VIC_4096X2160P24_256_135, 297000, 24, 4096, 2160, + HDMI_PICTURE_ASPECT_256_135, HDMI_VIDEO_TIMING_4096X2160P24, HDMI_VIDEO_FORMAT_PROGRESSIVE } +}; + +enum HdmiVideoBitDepth HdmiCommonDeepClolorConvertToColorDepth(enum HdmiDeepColor deepColor) +{ + enum HdmiVideoBitDepth colorDepth; + + switch (deepColor) { + case HDMI_DEEP_COLOR_24BITS: + colorDepth = HDMI_VIDEO_BIT_DEPTH_8; + break; + case HDMI_DEEP_COLOR_30BITS: + colorDepth = HDMI_VIDEO_BIT_DEPTH_10; + break; + case HDMI_DEEP_COLOR_36BITS: + colorDepth = HDMI_VIDEO_BIT_DEPTH_12; + break; + case HDMI_DEEP_COLOR_48BITS: + colorDepth = HDMI_VIDEO_BIT_DEPTH_16; + break; + default: + HDF_LOGD("deep color %d is not support, use default value.", deepColor); + colorDepth = HDMI_VIDEO_BIT_DEPTH_8; + break; + } + return colorDepth; +} + +enum HdmiDeepColor HdmiCommonColorDepthConvertToDeepClolor(enum HdmiVideoBitDepth colorDepth) +{ + enum HdmiDeepColor deepColor; + + switch (colorDepth) { + case HDMI_VIDEO_BIT_DEPTH_8: + deepColor = HDMI_DEEP_COLOR_24BITS; + break; + case HDMI_VIDEO_BIT_DEPTH_10: + deepColor = HDMI_DEEP_COLOR_30BITS; + break; + case HDMI_VIDEO_BIT_DEPTH_12: + deepColor = HDMI_DEEP_COLOR_36BITS; + break; + case HDMI_VIDEO_BIT_DEPTH_16: + deepColor = HDMI_DEEP_COLOR_48BITS; + break; + case HDMI_VIDEO_BIT_DEPTH_OFF: + deepColor = HDMI_DEEP_COLOR_OFF; + break; + default: + deepColor = HDMI_DEEP_COLOR_BUTT; + break; + } + return deepColor; +} + +enum HdmiVic HdmiCommonGetVic(enum HdmiVideoTiming timing, + enum HdmiPictureAspectRatio aspect, bool enable3d) +{ + uint32_t i, len; + enum HdmiVic vic = 0; + + len = sizeof(g_ceaVideoDefInfoMap) / sizeof(g_ceaVideoDefInfoMap[0]); + for (i = 0; i < len; i++) { + if (timing == g_ceaVideoDefInfoMap[i].timing && aspect == g_ceaVideoDefInfoMap[i].aspect) { + vic = g_ceaVideoDefInfoMap[i].vic; + break; + } + } + + if (enable3d == true) { + /* see hdmi spec 10.2. */ + if (vic == HDMI_VIC_3840X2160P24_16_9 || vic == HDMI_VIC_3840X2160P25_16_9 || + vic == HDMI_VIC_3840X2160P30_16_9 || vic == HDMI_VIC_4096X2160P24_256_135) { + HDF_LOGI("4k x 2k 2D vic:%d.", vic); + vic = HDMI_VIC_NONE; + } + } + return vic; +} + +static struct HdmiVideoDefInfo *HdmiCommonGetCommFormatInfo(enum HdmiVic vic) +{ + uint32_t i, len; + + len = sizeof(g_ceaVideoDefInfoMap) / sizeof(g_ceaVideoDefInfoMap[0]); + for (i = 0; i < len; i++) { + if (vic == g_ceaVideoDefInfoMap[i].vic) { + return &g_ceaVideoDefInfoMap[i]; + } + } + return NULL; +} + +static struct HdmiVideoDefInfo *HdmiCommonGetVesaFormatInfo(enum HdmiVideoTiming timing) +{ + uint32_t i, len; + + len = sizeof(g_vesaVideoDefInfoMap) / sizeof(g_vesaVideoDefInfoMap[0]); + for (i = 0; i < len; i++) { + if (timing == g_vesaVideoDefInfoMap[i].timing) { + return &g_vesaVideoDefInfoMap[i]; + } + } + return NULL; +} + +struct HdmiVideoDefInfo *HdmiCommonGetVideoDefInfo(enum HdmiVideoTiming timing, + enum HdmiPictureAspectRatio aspect, bool enable3d) +{ + enum HdmiVic vic; + struct HdmiVideoDefInfo *info = NULL; + + if (timing < HDMI_VIDEO_TIMING_VESA_DEFINE) { + vic = HdmiCommonGetVic(timing, aspect, enable3d); + info = HdmiCommonGetCommFormatInfo(vic); + } else if (timing < HDMI_VIDEO_TIMING_USER_DEFINE) { + info = HdmiCommonGetVesaFormatInfo(timing); + } + return info; +} + +enum HdmiVideoTiming HdmiCommonGetVideoTiming(enum HdmiVic vic, enum HdmiPictureAspectRatio aspect) +{ + uint32_t i, len; + enum HdmiVideoTiming timing = HDMI_VIDEO_TIMING_NONE; + + len = sizeof(g_ceaVideoDefInfoMap) / sizeof(g_ceaVideoDefInfoMap[0]); + for (i = 0; i < len; i++) { + if (vic == g_ceaVideoDefInfoMap[i].vic && aspect == g_ceaVideoDefInfoMap[i].aspect) { + timing = g_ceaVideoDefInfoMap[i].timing; + break; + } + } + return timing; +} + +struct HdmiVideo4kInfo *HdmiCommonGetVideo4kInfo(uint32_t _4kVic) +{ + uint32_t i, len; + + len = sizeof(g_video4kInfoMap) / sizeof(g_video4kInfoMap[0]); + for (i = 0; i < len; i++) { + if (_4kVic == g_video4kInfoMap[i]._4kVic) { + return &g_video4kInfoMap[i]; + } + } + HDF_LOGD("4k not support vic = %u", _4kVic); + return NULL; +} + +enum HdmiVideoTiming HdmiCommonGetVideo4kTiming(uint32_t _4kVic) +{ + uint32_t i, len; + enum HdmiVideoTiming timing = HDMI_VIDEO_TIMING_NONE; + + len = sizeof(g_video4kInfoMap) / sizeof(g_video4kInfoMap[0]); + for (i = 0; i < len; i++) { + if (_4kVic == g_video4kInfoMap[i]._4kVic) { + timing = g_video4kInfoMap[i].timing; + break; + } + } + return timing; +} diff --git a/support/platform/src/hdmi/hdmi_core.c b/support/platform/src/hdmi/hdmi_core.c new file mode 100644 index 0000000000000000000000000000000000000000..ea83b9f3a9ff40bb2be4c9137a025af3de232c01 --- /dev/null +++ b/support/platform/src/hdmi/hdmi_core.c @@ -0,0 +1,1439 @@ +/* + * Copyright (c) 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 "hdmi_core.h" +#include "device_resource_if.h" +#include "hdf_log.h" +#include "hdmi_dispatch.h" +#include "osal_mem.h" +#include "osal_time.h" +#include "securec.h" + +#define HDF_LOG_TAG hdmi_core_c + +int32_t HdmiCntlrAllocDev(struct HdmiCntlr *cntlr) +{ + struct HdmiDevice *dev = (struct HdmiDevice *)OsalMemCalloc(sizeof(struct HdmiDevice)); + + if (dev == NULL) { + HDF_LOGE("Hdmi alloc dev fail"); + return HDF_ERR_MALLOC_FAIL; + } + + dev->cntlr = cntlr; + cntlr->hdmi = dev; + return HDF_SUCCESS; +} + +void HdmiCntlrFreeDev(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL || cntlr->hdmi == NULL) { + return; + } + + OsalMemFree(cntlr->hdmi); + cntlr->hdmi = NULL; +} + +static void HdmiCecInit(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL) { + return; + } + if (cntlr->cap.baseCap.bits.cec == 0) { + HDF_LOGD("not support cec"); + return; + } + + if (cntlr->cec == NULL) { + cntlr->cec = (struct HdmiCec *)OsalMemCalloc(sizeof(struct HdmiCec)); + if (cntlr->cec == NULL) { + HDF_LOGE("cec malloc fail"); + return; + } + } + HDF_LOGE("HdmiCecInit, success."); + cntlr->cec->priv = (void *)cntlr; +} + +static void HdmiCecDeinit(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL) { + return; + } + if (cntlr->cec != NULL) { + OsalMemFree(cntlr->cec); + cntlr->cec = NULL; + } +} + +static void HdmiDdcInit(struct HdmiCntlr *cntlr) +{ + int32_t ret; + + if (cntlr == NULL) { + HDF_LOGE("ddc init: param is invalid"); + return; + } + cntlr->ddc.priv = (void *)cntlr; + if (cntlr->ddc.init == true) { + return; + } + ret = OsalMutexInit(&(cntlr->ddc.ddcMutex)); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiDdcInit: mutex init fail!"); + return; + } + HDF_LOGE("HdmiDdcInit, success."); + cntlr->ddc.init = true; +} + +static void HdmiDdcDeinit(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL) { + HDF_LOGE("ddc init: param is invalid"); + return; + } + + (void)OsalMutexDestroy(&(cntlr->ddc.ddcMutex)); + if (memset_s(&(cntlr->ddc), sizeof(struct HdmiDdc), 0, sizeof(struct HdmiDdc)) != EOK) { + HDF_LOGE("deinit ddc, memset_s fail."); + } + cntlr->ddc.priv = NULL; + cntlr->ddc.init = false; +} + +static void HdmiFrlInit(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL) { + return; + } + if (cntlr->cap.baseCap.bits.frl == 0) { + HDF_LOGD("not support frl"); + return; + } + + if (cntlr->frl == NULL) { + cntlr->frl = (struct HdmiFrl *)OsalMemCalloc(sizeof(struct HdmiFrl)); + if (cntlr->frl == NULL) { + HDF_LOGE("frl malloc fail"); + return; + } + } + HDF_LOGE("HdmiFrlInit, success."); + cntlr->frl->priv = (void *)cntlr; +} + +static void HdmiFrlDeinit(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL) { + return; + } + if (cntlr->frl != NULL) { + OsalMemFree(cntlr->frl); + cntlr->frl = NULL; + } +} + +static void HdmiHdcpInit(struct HdmiCntlr *cntlr) +{ + int32_t ret; + + if (cntlr == NULL) { + return; + } + if (cntlr->cap.baseCap.bits.hdcp == 0) { + HDF_LOGD("not support hdcp"); + return; + } + + if (cntlr->hdcp == NULL) { + cntlr->hdcp = (struct HdmiHdcp *)OsalMemCalloc(sizeof(struct HdmiHdcp)); + if (cntlr->hdcp == NULL) { + HDF_LOGE("hdcp malloc fail"); + return; + } + ret = OsalMutexInit(&(cntlr->hdcp->hdcpMutex)); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiHdcpInit: mutex init fail!"); + return; + } + } + HDF_LOGE("HdmiHdcpInit, success."); + cntlr->hdcp->priv = (void *)cntlr; +} + +static void HdmiHdcpDeinit(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL) { + return; + } + if (cntlr->hdcp != NULL) { + HdmiHdcpClose(cntlr->hdcp); + OsalMemFree(cntlr->hdcp); + cntlr->hdcp = NULL; + } +} + +static void HdmiHdrInit(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL) { + return; + } + if (cntlr->cap.baseCap.bits.hdr == 0) { + HDF_LOGD("not support hdr"); + return; + } + + if (cntlr->hdr == NULL) { + cntlr->hdr = (struct HdmiHdr *)OsalMemCalloc(sizeof(struct HdmiHdr)); + if (cntlr->hdr == NULL) { + HDF_LOGE("hdr malloc fail"); + return; + } + } + HDF_LOGE("HdmiHdrInit, success."); + cntlr->hdr->priv = (void *)cntlr; +} + +static void HdmiHdrDeinit(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL) { + return; + } + if (cntlr->hdr != NULL) { + OsalMemFree(cntlr->hdr); + cntlr->hdr = NULL; + } +} + +static void HdmiInfoFrameInit(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL) { + return; + } + HDF_LOGE("HdmiInfoFrameInit, success."); + cntlr->infoFrame.priv = (void *)cntlr; +} + +static void HdmiInfoFrameDeInit(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL) { + return; + } + + if (memset_s(&(cntlr->infoFrame), sizeof(struct HdmiInfoFrame), 0, sizeof(struct HdmiInfoFrame)) != EOK) { + HDF_LOGE("deinit infoFrame, memset_s fail."); + } + cntlr->infoFrame.priv = NULL; +} + +static void HdmiScdcInit(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL) { + return; + } + if (cntlr->cap.baseCap.bits.scdc == 0) { + HDF_LOGD("not support scdc"); + return; + } + + if (cntlr->scdc == NULL) { + cntlr->scdc = (struct HdmiScdc *)OsalMemCalloc(sizeof(struct HdmiScdc)); + if (cntlr->scdc == NULL) { + HDF_LOGE("scdc malloc fail"); + return; + } + } + HDF_LOGE("HdmiScdcInit, success."); + cntlr->scdc->priv = (void *)cntlr; +} + +static void HdmiScdcDeinit(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL) { + return; + } + if (cntlr->scdc != NULL) { + OsalMemFree(cntlr->scdc); + cntlr->scdc = NULL; + } +} + +static int32_t HdmiCntlrInit(struct HdmiCntlr *cntlr) +{ + int32_t ret; + + if (cntlr == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->hdfDevObj == NULL) { + HDF_LOGE("HdmiCntlrInit: no HdfDeviceObject attached!"); + return HDF_ERR_INVALID_OBJECT; + } + + ret = OsalMutexInit(&cntlr->mutex); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrInit: mutex init fail!"); + return ret; + } + + cntlr->msgQueue = PlatformQueueCreate(HdmiEventMsgHandleDefault, "PlatformHdmiWorkerThread", cntlr); + if (cntlr->msgQueue == NULL) { + HDF_LOGE("HdmiCntlrInit: failed to create msg queue!"); + return HDF_PLT_ERR_OS_API; + } + ret = PlatformQueueStart(cntlr->msgQueue); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrInit: failed to start msg queue!"); + PlatformQueueDestroy(cntlr->msgQueue); + return ret; + } + + cntlr->service.Dispatch = HdmiIoDispatch; + cntlr->hdfDevObj->service = &(cntlr->service); + cntlr->device.number = cntlr->deviceIndex; + cntlr->device.hdfDev = cntlr->hdfDevObj; + HdmiInfoFrameInit(cntlr); + HdmiDdcInit(cntlr); + return HDF_SUCCESS; +} + +static void HdmiCntlrUninit(struct HdmiCntlr *cntlr) +{ + if (cntlr != NULL) { + HdmiInfoFrameDeInit(cntlr); + HdmiScdcDeinit(cntlr); + HdmiDdcDeinit(cntlr); + HdmiCecDeinit(cntlr); + HdmiFrlDeinit(cntlr); + HdmiHdcpDeinit(cntlr); + HdmiCntlrFreeDev(cntlr); + (void)OsalMutexDestroy(&cntlr->mutex); + } +} + +int32_t HdmiCntlrAdd(struct HdmiCntlr *cntlr) +{ + int32_t ret; + + if (cntlr == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + ret = HdmiCntlrInit(cntlr); + if (ret != HDF_SUCCESS) { + return ret; + } + + cntlr->device.manager = PlatformManagerGet(PLATFORM_MODULE_HDMI); + ret = PlatformDeviceAdd(&cntlr->device); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrAdd: device add fail!"); + HdmiCntlrUninit(cntlr); + return ret; + } + return HDF_SUCCESS; +} + +void HdmiCntlrRemove(struct HdmiCntlr *cntlr) +{ + if (cntlr != NULL) { + HdmiCntlrUninit(cntlr); + PlatformDeviceDel(&cntlr->device); + } +} + +static int32_t HdmiCntlrParseVideoCaps(struct HdmiCntlr *cntlr, struct DeviceResourceIface *drsOps, + const struct DeviceResourceNode *node) +{ + int32_t ret; + + ret = drsOps->GetUint32(node, "maxTmdsClock", &(cntlr->cap.maxTmdsClock), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParseVideoCaps: read maxTmdsClock fail!"); + return ret; + } + + ret = drsOps->GetUint32(node, "defTmdsClock", &(cntlr->cap.defTmdsClock), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParseVideoCaps: read defTmdsClock fail!"); + return ret; + } + + ret = drsOps->GetUint32(node, "maxFrlRate", &(cntlr->cap.maxFrlRate), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParseVideoCaps: read maxFrlRate fail!"); + return ret; + } + + ret = drsOps->GetUint32(node, "videoTiming", &(cntlr->cap.videoTiming), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParseVideoCaps: read videoTiming fail!"); + return ret; + } + + ret = drsOps->GetUint32(node, "quantization", &(cntlr->cap.quantization), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParseVideoCaps: read quantization fail!"); + return ret; + } + + ret = drsOps->GetUint32(node, "colorSpace", &(cntlr->cap.colorSpace), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParseVideoCaps: read colorSpace fail!"); + return ret; + } + + ret = drsOps->GetUint32(node, "colorimetry", &(cntlr->cap.colorimetry), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParseVideoCaps: read colorimetry fail!"); + return ret; + } + return HDF_SUCCESS; +} + +static int32_t HdmiCntlrParseAudioCaps(struct HdmiCntlr *cntlr, struct DeviceResourceIface *drsOps, + const struct DeviceResourceNode *node) +{ + int32_t ret; + + ret = drsOps->GetUint32(node, "audioIfType", &(cntlr->cap.audioIfType), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParseAudioCaps: read audioIfType fail!"); + return ret; + } + HDF_LOGD("HdmiCntlrParseAudioCaps: audioIfType = %d", cntlr->cap.audioIfType); + + ret = drsOps->GetUint32(node, "audioBitDepth", &(cntlr->cap.audioBitDepth), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParseAudioCaps: read audioBitDepth fail!"); + return ret; + } + HDF_LOGD("HdmiCntlrParseAudioCaps: audioBitDepth = %d", cntlr->cap.audioBitDepth); + + ret = drsOps->GetUint32(node, "audioSampleRate", &(cntlr->cap.audioSampleRate), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParseAudioCaps: read audioSampleRate fail!"); + return ret; + } + HDF_LOGD("HdmiCntlrParseAudioCaps: audioSampleRate = %d", cntlr->cap.audioSampleRate); + + ret = drsOps->GetUint32(node, "audioChannels", &(cntlr->cap.audioChannels), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParseAudioCaps: read audioChannels fail!"); + return ret; + } + HDF_LOGD("HdmiCntlrParseAudioCaps: audioChannels = %d", cntlr->cap.audioChannels); + return HDF_SUCCESS; +} + +static int32_t HdmiCntlrParseHdrCaps(struct HdmiCntlr *cntlr, struct DeviceResourceIface *drsOps, + const struct DeviceResourceNode *node) +{ + int32_t ret; + + ret = drsOps->GetUint32(node, "hdrColorimetry", &(cntlr->cap.hdrColorimetry), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParseAudioCaps: read hdrColorimetry fail!"); + return ret; + } + HDF_LOGD("HdmiCntlrParseAudioCaps: hdrColorimetry = %d", cntlr->cap.hdrColorimetry); + + ret = drsOps->GetUint32(node, "hdrUserMode", &(cntlr->cap.hdrUserMode), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParseAudioCaps: read hdrUserMode fail!"); + return ret; + } + HDF_LOGD("HdmiCntlrParseAudioCaps: hdrUserMode = %d", cntlr->cap.hdrUserMode); + return HDF_SUCCESS; +} + +int32_t HdmiCntlrParse(struct HdmiCntlr *cntlr, struct HdfDeviceObject *obj) +{ + const struct DeviceResourceNode *node = NULL; + struct DeviceResourceIface *drsOps = NULL; + int32_t ret; + + if (obj == NULL || cntlr == NULL) { + HDF_LOGE("HdmiCntlrParse: input param is NULL."); + return HDF_FAILURE; + } + + node = obj->property; + if (node == NULL) { + HDF_LOGE("HdmiCntlrParse: drs node is NULL."); + return HDF_FAILURE; + } + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetUint32 == NULL) { + HDF_LOGE("HdmiCntlrParse: invalid drs ops fail!"); + return HDF_FAILURE; + } + + ret = drsOps->GetUint32(node, "index", &(cntlr->deviceIndex), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParse: read hostId fail!"); + return ret; + } + + ret = drsOps->GetUint32(node, "cap", &(cntlr->cap.baseCap.data), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParse: read baseCap fail!"); + return ret; + } + + ret = HdmiCntlrParseVideoCaps(cntlr, drsOps, node); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParse: read video caps fail!"); + return ret; + } + + ret = HdmiCntlrParseAudioCaps(cntlr, drsOps, node); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParse: read audio caps fail!"); + return ret; + } + + ret = HdmiCntlrParseHdrCaps(cntlr, drsOps, node); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiCntlrParse: read hdr caps fail!"); + return ret; + } + return HDF_SUCCESS; +} + +static struct HdmiSinkDeviceCapability *HdmiGetSinkCapability(struct HdmiDevice *hdmi) +{ + if (hdmi == NULL) { + return NULL; + } + + if (hdmi->edid.edidPhase == false) { + return NULL; + } + return &(hdmi->edid.sinkCap); +} + +int32_t HdmiCntlrGetSinkEdid(struct HdmiCntlr *cntlr, uint8_t *buffer, uint32_t len) +{ + int32_t ret; + + if (cntlr == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + if (HdmiHpdStatusDelayGet(cntlr) == false) { + HDF_LOGE("no hdmi sink device"); + HdmiCntlrFreeDev(cntlr); + return HDF_DEV_ERR_NO_DEVICE; + } + if (cntlr->hdmi != NULL) { + return HdmiEdidGetRaw(&(cntlr->hdmi->edid), buffer, len); + } + + ret = HdmiCntlrAllocDev(cntlr); + if (ret != HDF_SUCCESS) { + return ret; + } + + ret = HdmiEdidRawDataRead(&(cntlr->hdmi->edid), &(cntlr->ddc)); + if (ret != HDF_SUCCESS) { + HdmiCntlrFreeDev(cntlr); + return ret; + } + + if (cntlr->hdmi->edid.edidPhase != true) { + (void)HdmiEdidPhase(&(cntlr->hdmi->edid)); + cntlr->hdmi->edid.edidPhase = true; + } + return HdmiEdidGetRaw(&(cntlr->hdmi->edid), buffer, len); +} + +static void HdmiCntlrModeSelect(struct HdmiCntlr *cntlr) +{ + enum HdmiTmdsModeType tmdsMode; + struct HdmiCommonAttr *commAttr = &(cntlr->attr.commAttr); + struct HdmiScdcScrambleCap scramble = {0}; + struct HdmiScdcScrambleCap curScramble = {0}; + int32_t ret; + + /* support FRL. */ + if (HdmiFrlSupport(cntlr->frl) == true && + cntlr->cap.baseCap.bits.frl > 0) { + return; + } + + if (cntlr->cap.baseCap.bits.scdc > 0) { + ret = HdmiScdcFillScrambleCap(cntlr->scdc, &scramble, &tmdsMode); + if (ret != HDF_SUCCESS) { + return; + } + } else { + tmdsMode = (commAttr->enableHdmi == true) ? HDMI_TMDS_MODE_HDMI_1_4 : HDMI_TMDS_MODE_DVI; + } + + cntlr->tmdsMode = tmdsMode; + HdmiCntlrTmdsModeSet(cntlr, tmdsMode); + HdmiCntlrReset(cntlr); + + if (cntlr->cap.baseCap.bits.scdc > 0 && + HdmiEdidScdcSupport(cntlr->hdmi) == true) { + ret = HdmiScdcScrambleGet(cntlr->scdc, &curScramble); + if (ret != HDF_SUCCESS) { + return; + } + if (scramble.sinkScramble != curScramble.sinkScramble || + scramble.sourceScramble != curScramble.sourceScramble || + scramble.tmdsBitClockRatio40 != curScramble.tmdsBitClockRatio40) { + (void)HdmiScdcScrambleSet(cntlr->scdc, &scramble); + } + } +} + +static void HdmiCommonAttrInit(struct HdmiCntlr *cntlr) +{ + struct HdmiCommonAttr *commAttr = &(cntlr->attr.commAttr); + + commAttr->enableHdmi = true; + commAttr->enableVideo = true; + commAttr->enableAudio = true; + commAttr->audio = true; + commAttr->avi = true; + commAttr->hdcpMode = HDMI_HDCP_MODE_1_4; + commAttr->colorSpace = (enum HdmiColorSpace)cntlr->cap.colorSpace; + commAttr->quantization = (enum HdmiQuantizationRange)cntlr->cap.quantization; +} + +static void HdmiVideoAttrInit(struct HdmiCntlr *cntlr) +{ + struct HdmiVideoAttr *videoAttr = &(cntlr->attr.videoAttr); + bool colorimetry601; + + videoAttr->colorSpace = (enum HdmiColorSpace)cntlr->cap.colorSpace; + videoAttr->colorimetry = (enum HdmiColorimetry)cntlr->cap.colorimetry; + videoAttr->timing = (enum HdmiVideoTiming)cntlr->cap.videoTiming; + colorimetry601 = ((videoAttr->timing == HDMI_VIDEO_TIMING_720X480P60) || + (videoAttr->timing == HDMI_VIDEO_TIMING_720X576P50) || + (videoAttr->timing == HDMI_VIDEO_TIMING_1440X240P60) || + (videoAttr->timing == HDMI_VIDEO_TIMING_1440X480I60) || + (videoAttr->timing == HDMI_VIDEO_TIMING_1440X576I50) || + (videoAttr->timing == HDMI_VIDEO_TIMING_1440X576P50) || + (videoAttr->timing == HDMI_VIDEO_TIMING_1440X576I60)); + + if (videoAttr->timing == HDMI_VIDEO_TIMING_640X480P60) { + videoAttr->colorimetry = HDMI_COLORIMETRY_ITU709; + videoAttr->aspect = HDMI_PICTURE_ASPECT_4_3; + } else if (colorimetry601 == true) { + videoAttr->colorimetry = HDMI_COLORIMETRY_ITU601; + videoAttr->aspect = HDMI_PICTURE_ASPECT_4_3; + } else if (videoAttr->timing <= HDMI_VIDEO_TIMING_4096X2160P120 && + videoAttr->timing >= HDMI_VIDEO_TIMING_4096X2160P24) { + videoAttr->colorimetry = HDMI_COLORIMETRY_ITU709; + videoAttr->aspect = HDMI_PICTURE_ASPECT_256_135; + } else { + videoAttr->colorimetry = HDMI_COLORIMETRY_ITU709; + videoAttr->aspect = HDMI_PICTURE_ASPECT_16_9; + } + + videoAttr->pixelRepeat = 1; + if (videoAttr->timing == HDMI_VIDEO_TIMING_1440X480I60 || + videoAttr->timing == HDMI_VIDEO_TIMING_1440X576I50) { + videoAttr->pixelRepeat = 2; + } + + if (videoAttr->timing <= HDMI_VIDEO_TIMING_640X480P60) { + videoAttr->quantization = HDMI_QUANTIZATION_RANGE_DEFAULT; + } else { + videoAttr->yccQuantization = HDMI_YCC_QUANTIZATION_RANGE_LIMITED; + } + + if (videoAttr->timing != HDMI_VIDEO_TIMING_NONE && + videoAttr->timing != HDMI_VIDEO_TIMING_640X480P60) { + videoAttr->colorSpace = HDMI_COLOR_SPACE_YCBCR444; + } else { + videoAttr->colorSpace = HDMI_COLOR_SPACE_RGB; + } + + videoAttr->_3dStruct = HDMI_VS_VIDEO_3D_BUTT; + videoAttr->activeAspect = HDMI_ACTIVE_FORMAT_ASPECT_PICTURE; +} + +static void HdmiAudioAttrInit(struct HdmiCntlr *cntlr) +{ + struct HdmiAudioAttr *audioAttr = &(cntlr->attr.audioAttr); + + audioAttr->ifType = (enum HdmiAudioInterfaceType)cntlr->cap.audioIfType; + audioAttr->bitDepth = (enum HdmiAudioBitDepth)cntlr->cap.audioBitDepth; + audioAttr->sampleRate = (enum HdmiSampleRate)cntlr->cap.audioSampleRate; + audioAttr->channels = (enum HdmiAudioFormatChannel)cntlr->cap.audioChannels; +} + +static void HdmiHdrAttrInit(struct HdmiCntlr *cntlr) +{ + struct HdmiHdrAttr *hdrAttr = &(cntlr->attr.hdrAttr); + + hdrAttr->userMode = (enum HdmiHdrUserMode)cntlr->cap.hdrUserMode; + hdrAttr->colorimetry = (enum HdmiHdrColormetry)cntlr->cap.hdrColorimetry; +} + +static void HdmiAttrInit(struct HdmiCntlr *cntlr) +{ + HdmiCommonAttrInit(cntlr); + HdmiVideoAttrInit(cntlr); + HdmiAudioAttrInit(cntlr); + HdmiHdrAttrInit(cntlr); +} + +int32_t HdmiCntlrOpen(struct HdmiCntlr *cntlr) +{ + int32_t ret; + + if (cntlr == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + HdmiInfoFrameInit(cntlr); + HdmiDdcInit(cntlr); + HdmiScdcInit(cntlr); + HdmiFrlInit(cntlr); + HdmiHdcpInit(cntlr); + HdmiCecInit(cntlr); + HdmiHdrInit(cntlr); + HdmiAttrInit(cntlr); + HdmiCntlrHardWareInit(cntlr); + /* HDCP on. */ + if ((cntlr->cap.baseCap.data & HDMI_CAP_HDCP_MARK) > 0) { + ret = HdmiHdcpOpen(cntlr->hdcp); + if (ret != HDF_SUCCESS) { + HdmiHdcpClose(cntlr->hdcp); + } + } + cntlr->state |= HDMI_CNTLR_STATE_OPEN; + return HDF_SUCCESS; +} + +int32_t HdmiCntlrStart(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL || cntlr->ops == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + HdmiCntlrLowPowerSet(cntlr, false); + /* select mode */ + HdmiCntlrModeSelect(cntlr); + HdmiCntlrAvmuteSet(cntlr, false); + + if (cntlr->cap.baseCap.bits.hdr > 0 && + cntlr->cap.baseCap.bits.frl > 0) { + HdmiFrlEnable(cntlr->frl, true); + } else { + /* TMDS Transfer. */ + if (cntlr->ops->phyOutputEnable != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->phyOutputEnable(cntlr, true); + HdmiCntlrUnlock(cntlr); + } + } + + HdmiCntlrAudioPathEnable(cntlr, true); + HdmiCntlrBlackDataSet(cntlr, false); + + cntlr->state |= HDMI_CNTLR_STATE_START; + return HDF_SUCCESS; +} + +int32_t HdmiCntlrStop(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL || cntlr->ops == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + HdmiCntlrLock(cntlr); + if (cntlr->ops->audioPathEnable != NULL) { + cntlr->ops->audioPathEnable(cntlr, false); + } + if (cntlr->ops->avmuteSet != NULL) { + cntlr->ops->avmuteSet(cntlr, true); + } + if (cntlr->ops->blackDataSet != NULL) { + cntlr->ops->blackDataSet(cntlr, true); + } + HdmiFrlEnable(cntlr->frl, false); + if (cntlr->ops->phyOutputEnable != NULL) { + cntlr->ops->phyOutputEnable(cntlr, false); + } + HdmiCntlrUnlock(cntlr); + + HdmiCntlrLowPowerSet(cntlr, true); + cntlr->state = HDMI_CNTLR_STATE_STOP; + return HDF_SUCCESS; +} + +static void HdmiTmdsClockUpdate(struct HdmiVideoAttr *videoAttr, struct HdmiCommonAttr *commAttr) +{ + /* + * Video at the default 24-bit color depth is carried at a TMDS clock rate equal to the pixel clock rate. + * YCBCB 4:2:0 video is carried at a TMDS clock rate equal to the 1/2 pixel clock rate. + */ + if (commAttr->colorSpace == HDMI_COLOR_SPACE_YCBCR420) { + videoAttr->tmdsClock = HDMI_MULTIPLE_0P5(videoAttr->pixelClock); + return; + } + + /* + * The TMDS clock rate is ibcreased by the ratio of the pixel size to 24-bits: + * 24-bit mode: TMDS clock is 1.0 X pixel clock; + * 30-bit mode: TMDS clock is 1.25 X pixel clock; + * 36-bit mode: TMDS clock is 1.5 X pixel clock; + * 48-bit mode: TMDS clock is 2.0 X pixel clock; + */ + videoAttr->tmdsClock = videoAttr->pixelClock; + if (commAttr->colorSpace != HDMI_COLOR_SPACE_YCBCR422) { + if (commAttr->deepColor == HDMI_DEEP_COLOR_30BITS) { + videoAttr->tmdsClock = HDMI_MULTIPLE_1P25(videoAttr->pixelClock); + } else if (commAttr->deepColor == HDMI_DEEP_COLOR_36BITS) { + videoAttr->tmdsClock = HDMI_MULTIPLE_1P5(videoAttr->pixelClock); + } else if (commAttr->deepColor == HDMI_DEEP_COLOR_48BITS) { + videoAttr->tmdsClock = HDMI_MULTIPLE_2P0(videoAttr->pixelClock); + } + } else { + if ((commAttr->deepColor != HDMI_DEEP_COLOR_OFF) && + (commAttr->deepColor != HDMI_DEEP_COLOR_24BITS)) { + HDF_LOGD("Y422 foce deepcolor 8bit"); + commAttr->deepColor = HDMI_DEEP_COLOR_24BITS; + } + if (videoAttr->timing == HDMI_VIDEO_TIMING_1440X480I60 || + videoAttr->timing == HDMI_VIDEO_TIMING_1440X576I50) { + HDF_LOGD("Y422 is not support at pal and ntsc, force adapt to rgb!"); + commAttr->colorSpace = HDMI_COLOR_SPACE_RGB; + } + } +} + +static bool HdmiYcbcr420FormatCheck(struct HdmiSinkDeviceCapability *sinkCap, struct HdmiVideoAttr *videoAttr) +{ + uint32_t i; + enum HdmiVic vic; + + vic = HdmiCommonGetVic(videoAttr->timing, videoAttr->aspect, false); + if (vic == HDMI_VIC_NONE) { + HDF_LOGD("Y420 not have supported vic."); + return false; + } + + for (i = 0; i < sinkCap->y420Cap.SupportY420VicNum; i++) { + if (vic == sinkCap->y420Cap.SupportY420Format[i]) { + HDF_LOGD("Y420 supported vic is %d.", vic); + return true; + } + } + + for (i = 0; i < sinkCap->y420Cap.onlySupportY420VicNum; i++) { + if (vic == sinkCap->y420Cap.onlySupportY420Format[i]) { + HDF_LOGD("Y420 supported vic is %d.", vic); + return true; + } + } + + HDF_LOGD("Y420 have no supported vic."); + return false; +} + +static int32_t HdmiColorSpaceCheck(struct HdmiCntlr *cntlr, struct HdmiSinkDeviceCapability *sinkCap, + uint32_t maxTmdsClk) +{ + struct HdmiVideoAttr *videoAttr = &(cntlr->attr.videoAttr); + struct HdmiCommonAttr *commAttr = &(cntlr->attr.commAttr); + union HdmiCap *cap = &(cntlr->cap.baseCap); + bool supportColorSpace = false; + + if (videoAttr->pixelClock > maxTmdsClk && + commAttr->colorSpace != HDMI_COLOR_SPACE_YCBCR420) { + return HDF_ERR_INVALID_PARAM; + } + + switch (commAttr->colorSpace) { + case HDMI_COLOR_SPACE_RGB: + supportColorSpace = true; + if ((sinkCap->colorSpace.rgb444 && cap->bits.rgb444) == false) { + HDF_LOGD("sink or source not support RGB!"); + } + break; + case HDMI_COLOR_SPACE_YCBCR422: + supportColorSpace = sinkCap->colorSpace.ycbcr422 && cap->bits.ycbcr422; + break; + case HDMI_COLOR_SPACE_YCBCR444: + supportColorSpace = sinkCap->colorSpace.ycbcr444 && cap->bits.ycbcr444; + break; + case HDMI_COLOR_SPACE_YCBCR420: + supportColorSpace = cap->bits.ycbcr420 && HdmiYcbcr420FormatCheck(sinkCap, videoAttr); + break; + default: + HDF_LOGE("unknow color_space = %u!\n", commAttr->colorSpace); + break; + } + + if (supportColorSpace != true) { + return HDF_ERR_INVALID_PARAM; + } + return HDF_SUCCESS; +} + +static void HdmiDeepColor10bitsCheck(struct HdmiSinkDeviceCapability *sinkCap, struct HdmiCommonAttr *commAttr, + union HdmiCap *cap, uint32_t *tmdsClock, bool *supportDeepColor) +{ + uint32_t tmpTmdsClk = *tmdsClock; + + switch (commAttr->colorSpace) { + case HDMI_COLOR_SPACE_RGB: + tmpTmdsClk = HDMI_MULTIPLE_1P25(tmpTmdsClk); + *supportDeepColor = (sinkCap->vsdbInfo.deepColor.dc30bit && cap->bits.deepColor10bits) ? true : false; + break; + case HDMI_COLOR_SPACE_YCBCR444: + tmpTmdsClk = HDMI_MULTIPLE_1P25(tmpTmdsClk); + *supportDeepColor = (sinkCap->vsdbInfo.deepColor.dc30bit && cap->bits.deepColor10bits && + sinkCap->vsdbInfo.deepColor.dcY444) ? true : false; + break; + case HDMI_COLOR_SPACE_YCBCR420: + tmpTmdsClk = HDMI_MULTIPLE_1P25(tmpTmdsClk); + *supportDeepColor = (sinkCap->hfVsdbInfo.dc.dc30bit && cap->bits.deepColor10bits) ? true : false; + break; + default: + /* Y422, ignore deepclr */ + *supportDeepColor = true; + break; + } + *tmdsClock = tmpTmdsClk; +} + +static void HdmiDeepColor12bitsCheck(struct HdmiSinkDeviceCapability *sinkCap, struct HdmiCommonAttr *commAttr, + union HdmiCap *cap, uint32_t *tmdsClock, bool *supportDeepColor) +{ + uint32_t tmpTmdsClk = *tmdsClock; + + switch (commAttr->colorSpace) { + case HDMI_COLOR_SPACE_RGB: + tmpTmdsClk = HDMI_MULTIPLE_1P5(tmpTmdsClk); + *supportDeepColor = (sinkCap->vsdbInfo.deepColor.dc36bit && cap->bits.deepColor12bits) ? true : false; + break; + case HDMI_COLOR_SPACE_YCBCR444: + tmpTmdsClk = HDMI_MULTIPLE_1P5(tmpTmdsClk); + *supportDeepColor = (sinkCap->vsdbInfo.deepColor.dc36bit && cap->bits.deepColor12bits && + sinkCap->vsdbInfo.deepColor.dcY444) ? true : false; + break; + case HDMI_COLOR_SPACE_YCBCR420: + tmpTmdsClk = HDMI_MULTIPLE_1P5(tmpTmdsClk); + *supportDeepColor = (sinkCap->hfVsdbInfo.dc.dc36bit && cap->bits.deepColor12bits) ? true : false; + break; + default: + /* Y422, ignore deepclr */ + *supportDeepColor = true; + break; + } + *tmdsClock = tmpTmdsClk; +} + +static int32_t HdmiDeepColorCheck(struct HdmiCntlr *cntlr, struct HdmiSinkDeviceCapability *sinkCap, + uint32_t maxTmdsClk) +{ + struct HdmiVideoAttr *videoAttr = &(cntlr->attr.videoAttr); + struct HdmiCommonAttr *commAttr = &(cntlr->attr.commAttr); + union HdmiCap *cap = &(cntlr->cap.baseCap); + uint32_t tmdsClock = videoAttr->pixelClock; + bool supportDeepColor = false; + + if (commAttr->colorSpace == HDMI_COLOR_SPACE_YCBCR420) { + tmdsClock = HDMI_MULTIPLE_0P5(tmdsClock); + } + + switch (commAttr->deepColor) { + case HDMI_DEEP_COLOR_30BITS: + HdmiDeepColor10bitsCheck(sinkCap, commAttr, cap, &tmdsClock, &supportDeepColor); + break; + case HDMI_DEEP_COLOR_36BITS: + HdmiDeepColor12bitsCheck(sinkCap, commAttr, cap, &tmdsClock, &supportDeepColor); + break; + default: + commAttr->deepColor = HDMI_DEEP_COLOR_24BITS; + supportDeepColor = true; + break; + } + + if (supportDeepColor == false || tmdsClock > maxTmdsClk) { + return HDF_ERR_INVALID_PARAM; + } + videoAttr->tmdsClock = tmdsClock; + /* Y422 default 12bit output, deep_color force adapt to 8bit(24bit). */ + if (commAttr->colorSpace == HDMI_COLOR_SPACE_YCBCR422) { + if (videoAttr->timing == HDMI_VIDEO_TIMING_1440X480I60 || + videoAttr->timing == HDMI_VIDEO_TIMING_1440X576I50) { + HDF_LOGD("force change colorspace to RGB!"); + commAttr->colorSpace = HDMI_COLOR_SPACE_RGB; + } + if ((videoAttr->deepColor != HDMI_DEEP_COLOR_24BITS) && + (videoAttr->deepColor != HDMI_DEEP_COLOR_OFF)) { + videoAttr->deepColor = HDMI_DEEP_COLOR_OFF; + HDF_LOGD("when Y422, deep_color not support 10/12bit!"); + } + } + return HDF_SUCCESS; +} + +static int32_t HdmiColorBitSelect(struct HdmiCntlr *cntlr) +{ + struct HdmiSinkDeviceCapability *sinkCap = NULL; + uint32_t maxTmdsClk = 0; + + /* DVI mode, must set RGB and DEEP_COLOR_OFF */ + if (cntlr->attr.commAttr.enableHdmi == false) { + if (cntlr->attr.commAttr.colorSpace != HDMI_COLOR_SPACE_RGB) { + HDF_LOGE("DVI mode, the color space is not RGB!"); + return HDF_ERR_INVALID_PARAM; + } + cntlr->attr.commAttr.deepColor = HDMI_DEEP_COLOR_OFF; + cntlr->attr.videoAttr.tmdsClock = cntlr->attr.videoAttr.pixelClock; + return HDF_SUCCESS; + } + + /* FRL mode. */ + if (cntlr->cap.baseCap.bits.hdr > 0) { + HdmiTmdsClockUpdate(&(cntlr->attr.videoAttr), &(cntlr->attr.commAttr)); + if (cntlr->attr.videoAttr.tmdsClock > HDMI_HDMI20_MAX_TMDS_RATE) { + HDF_LOGD("HDMI2.1, tmds clock exceed max."); + return HDF_SUCCESS; + } + } + + sinkCap = HdmiGetSinkCapability(cntlr->hdmi); + if (sinkCap == NULL) { + HdmiTmdsClockUpdate(&(cntlr->attr.videoAttr), &(cntlr->attr.commAttr)); + return HDF_SUCCESS; + } + + if (sinkCap->maxTmdsClk == 0) { + /* use default clock. */ + maxTmdsClk = cntlr->cap.defTmdsClock; + } else { + maxTmdsClk = (sinkCap->maxTmdsClk < cntlr->cap.maxTmdsClock) ? + sinkCap->maxTmdsClk : cntlr->cap.maxTmdsClock; + } + /* MHz is converted to KHz */ + maxTmdsClk *= 1000; + + if (HdmiColorSpaceCheck(cntlr, sinkCap, maxTmdsClk) != HDF_SUCCESS) { + return HDF_ERR_INVALID_PARAM; + } + if (HdmiDeepColorCheck(cntlr, sinkCap, maxTmdsClk) != HDF_SUCCESS) { + return HDF_ERR_INVALID_PARAM; + } + return HDF_SUCCESS; +} + +static int32_t HdmiAudioAttrHandle(struct HdmiCntlr *cntlr) +{ + struct HdmiAudioConfigInfo audioCfg = {0}; + struct HdmiCommonAttr *commAttr = &(cntlr->attr.commAttr); + struct HdmiVideoAttr *videoAttr = &(cntlr->attr.videoAttr); + struct HdmiAudioAttr *audioAttr = &(cntlr->attr.audioAttr); + int32_t ret; + + audioCfg.downSample = audioAttr->downSample; + audioCfg.channels = audioAttr->channels; + audioCfg.bitDepth = audioAttr->bitDepth; + audioCfg.sampleRate = audioAttr->sampleRate; + audioCfg.ifType = audioAttr->ifType; + audioCfg.enable = (commAttr->enableAudio) && (commAttr->enableHdmi); + audioCfg.tmdsClock = videoAttr->tmdsClock; + audioCfg.pixelRepeat = videoAttr->pixelRepeat; + + HdmiCntlrAudioPathEnable(cntlr, false); + HdmiCntlrAudioPathSet(cntlr, &audioCfg); + ret = HdmiAudioInfoFrameSend(&(cntlr->infoFrame), ((commAttr->enableAudio) && (commAttr->audio))); + HdmiCntlrAudioPathEnable(cntlr, true); + return ret; +} + +static void HdmiHdrModeCheck(struct HdmiCommonAttr *commAttr, + struct HdmiVideoAttr *videoAttr, struct HdmiHdrAttr *hdrAttr) +{ + switch (hdrAttr->userMode) { + case HDMI_HDR_USERMODE_DOLBY: + videoAttr->yccQuantization = HDMI_YCC_QUANTIZATION_RANGE_LIMITED; + commAttr->colorSpace = HDMI_COLOR_SPACE_YCBCR444; + videoAttr->tmdsClock = videoAttr->pixelClock; + commAttr->deepColor = HDMI_DEEP_COLOR_24BITS; + videoAttr->quantization = HDMI_QUANTIZATION_RANGE_DEFAULT; + break; + case HDMI_HDR_USERMODE_HDR10: + if (hdrAttr->mode == HDMI_HDR_MODE_CEA_861_3) { + if (hdrAttr->colorimetry > HDMI_HDR_COLORIMETRY_EXTENDED) { + videoAttr->colorimetry = HDMI_COLORIMETRY_EXTENDED; + videoAttr->extColorimetry = (enum HdmiExtendedColorimetry)(hdrAttr->colorimetry - + HDMI_HDR_EXTENDED_COLORIMETRY_XV_YCC_601); + } else { + videoAttr->colorimetry = (enum HdmiColorimetry)(hdrAttr->colorimetry); + videoAttr->extColorimetry = HDMI_EXTENDED_COLORIMETRY_BUTT; + } + commAttr->xvyccMode = false; + } + break; + default: + break; + } +} + +static void HdmiFillVideoAttrFromHardwareStatus(struct HdmiVideoAttr *videoAttr, + struct HdmiHardwareStatus *hwStatus, struct HdmiCommonAttr *commAttr) +{ + bool rgb = false; + bool aspectIs256 = false; + uint8_t vic; + enum HdmiVsVideoFormat format; + enum Hdmi4kVic vic4k; + + rgb = ((hwStatus->videoStatus.rgb2Ycbcr) || + ((!hwStatus->videoStatus.ycbcr2Rgb) && (hwStatus->videoStatus.outColorSpace == HDMI_COLOR_SPACE_RGB))); + videoAttr->colorSpace = (rgb == true) ? HDMI_COLOR_SPACE_RGB : HDMI_COLOR_SPACE_YCBCR444; + + if (hwStatus->infoFrameStatus.aviEnable) { + vic = hwStatus->infoFrameStatus.avi[7]; + /* + * when the timing is 4096*2160, the aspect ratio in AVI infoFrame is 0 + * (but the real aspect ratio is 256:135<0x04>, the video_code is 0) + */ + aspectIs256 = (((vic == 0) && (hwStatus->infoFrameStatus.vsif[8] == 0x04)) || + ((vic >= HDMI_VIC_4096X2160P25_256_135) && (vic <= HDMI_VIC_4096X2160P60_256_135))); + videoAttr->aspect = (aspectIs256 == true) ? HDMI_PICTURE_ASPECT_256_135 : + ((hwStatus->infoFrameStatus.avi[5] >> 4) & 0x3); /* 4'b, BIT[2:1] */ + videoAttr->activeAspect = hwStatus->infoFrameStatus.avi[5] & 0xf; + videoAttr->colorimetry = (hwStatus->infoFrameStatus.avi[5] >> 6) & 0x3; /* 6'b, BIT[2:1] */ + videoAttr->quantization = (hwStatus->infoFrameStatus.avi[6] >> 2) & 0x3; /* 2'b, BIT[2:1] */ + videoAttr->extColorimetry = (hwStatus->infoFrameStatus.avi[6] >> 4) & 0x07; /* 4'b, BIT[3:1] */ + videoAttr->yccQuantization = (hwStatus->infoFrameStatus.avi[8] >> 6) & 0x3; /* 6'b, BIT[2:1] */ + videoAttr->pixelRepeat = (hwStatus->infoFrameStatus.avi[8] & 0xf) + 1; + videoAttr->timing = HdmiCommonGetVideoTiming(vic, videoAttr->aspect); + if ((!hwStatus->infoFrameStatus.vsifEnable) && (!vic)) { + videoAttr->timing = HDMI_VIDEO_TIMING_NONE; + } + commAttr->quantization = (commAttr->colorSpace == HDMI_COLOR_SPACE_RGB) ? + videoAttr->quantization : (videoAttr->yccQuantization + 1); + } + + videoAttr->_3dStruct = HDMI_VS_VIDEO_3D_BUTT; + if (hwStatus->infoFrameStatus.vsifEnable) { + format = (hwStatus->infoFrameStatus.vsif[7] >> 5) & 0x3; /* 5'b, BIT[2:1] */ + if (format == HDMI_VS_VIDEO_FORMAT_4K) { + vic4k = hwStatus->infoFrameStatus.vsif[8]; + videoAttr->timing = HdmiCommonGetVideo4kTiming(vic4k); + } else if (format == HDMI_VS_VIDEO_FORMAT_3D) { + videoAttr->_3dStruct = (hwStatus->infoFrameStatus.vsif[8] >> 4) & 0xf; /* 4'b, BIT[4:1] */ + } + } +} + +static void HdmiFillCommonAttrFromHardwareStatus(struct HdmiCommonAttr *commAttr, + struct HdmiHardwareStatus *hwStatus, struct HdmiAttr *attr) +{ + bool dolby = false; + + switch (hwStatus->commonStatus.tmdsMode) { + case HDMI_TMDS_MODE_HDMI_1_4: + case HDMI_TMDS_MODE_HDMI_2_0: + commAttr->enableHdmi = true; + commAttr->enableVideo = true; + break; + case HDMI_TMDS_MODE_DVI: + commAttr->enableHdmi = false; + commAttr->enableVideo = true; + break; + default: + commAttr->enableHdmi = false; + commAttr->enableVideo = false; + break; + } + + commAttr->enableAudio = (hwStatus->audioStatus.enable && hwStatus->infoFrameStatus.audioEnable); + commAttr->avi = hwStatus->infoFrameStatus.aviEnable; + commAttr->audio = hwStatus->infoFrameStatus.audioEnable; + commAttr->xvyccMode = hwStatus->infoFrameStatus.gdbEnable; + commAttr->deepColor = HdmiCommonColorDepthConvertToDeepClolor(hwStatus->videoStatus.outBitDepth); + + /* color space is ycbcr444 when the hdr mode is dolby. */ + dolby = ((attr->hdrAttr.userMode == HDMI_HDR_USERMODE_DOLBY) && + (!hwStatus->videoStatus.rgb2Ycbcr) && + (!hwStatus->videoStatus.ycbcr2Rgb) && + (!hwStatus->videoStatus.ycbcr444422) && + (!hwStatus->videoStatus.ycbcr422420) && + (!hwStatus->videoStatus.ycbcr422444) && + (!hwStatus->videoStatus.ycbcr420422)); + commAttr->colorSpace = (dolby == true) ? HDMI_COLOR_SPACE_YCBCR444 : hwStatus->videoStatus.outColorSpace; +} + +static bool HdmiCommonAttrChanged(struct HdmiCommonAttr *curCommAttr, struct HdmiCommonAttr *commAttr) +{ + bool change; + + change = (commAttr->enableHdmi != curCommAttr->enableHdmi) || + (commAttr->colorSpace != curCommAttr->colorSpace) || + (commAttr->xvyccMode != curCommAttr->xvyccMode) || + (commAttr->avi != curCommAttr->avi) || + (commAttr->quantization != curCommAttr->quantization); + + if (change == true) { + return true; + } + + if (((commAttr->deepColor == HDMI_DEEP_COLOR_OFF) || + (commAttr->deepColor == HDMI_DEEP_COLOR_24BITS)) && + ((curCommAttr->deepColor == HDMI_DEEP_COLOR_OFF) || + (curCommAttr->deepColor == HDMI_DEEP_COLOR_24BITS))) { + HDF_LOGI("deep color not change: %u", curCommAttr->deepColor); + } else if (commAttr->deepColor != curCommAttr->deepColor) { + return true; + } + return false; +} + +static bool HdmiVideoAttrChanged(struct HdmiVideoAttr *curVideoAttr, struct HdmiVideoAttr *videoAttr) +{ + bool change; + + change = (videoAttr->timing != curVideoAttr->timing) || + (videoAttr->colorSpace != curVideoAttr->colorSpace) || + (videoAttr->_3dStruct != curVideoAttr->_3dStruct) || + (videoAttr->pixelRepeat != curVideoAttr->pixelRepeat) || + (videoAttr->colorimetry != curVideoAttr->colorimetry) || + (videoAttr->extColorimetry != curVideoAttr->extColorimetry) || + (videoAttr->quantization != curVideoAttr->quantization) || + (videoAttr->yccQuantization != curVideoAttr->yccQuantization) || + (videoAttr->aspect != curVideoAttr->aspect); + return change; +} + +static int32_t HdmiVedioAttrHandle(struct HdmiCntlr *cntlr, struct HdmiHardwareStatus *hwStatus) +{ + struct HdmiCommonAttr *commAttr = &(cntlr->attr.commAttr); + struct HdmiVideoAttr *videoAttr = &(cntlr->attr.videoAttr); + struct HdmiCommonAttr curCommAttr = {0}; + struct HdmiVideoAttr curVideoAttr = {0}; + int32_t ret; + + /* support HDR. */ + if (cntlr->cap.baseCap.bits.hdr > 0) { + HdmiHdrModeCheck(commAttr, videoAttr, &(cntlr->attr.hdrAttr)); + } + + /* support FRL. */ + if (cntlr->cap.baseCap.bits.frl > 0) { + ret = HdmiFrlModeSelect(cntlr->frl); + if (ret != HDF_SUCCESS) { + return ret; + } + } + + HdmiFillCommonAttrFromHardwareStatus(&curCommAttr, hwStatus, &(cntlr->attr)); + HdmiFillVideoAttrFromHardwareStatus(&curVideoAttr, hwStatus, &curCommAttr); + if (HdmiCommonAttrChanged(&curCommAttr, commAttr) == false && + HdmiVideoAttrChanged(&curVideoAttr, videoAttr) == false && + HdmiFrlModeChanged(cntlr->frl) == false) { + HDF_LOGI("video and common attr is not changed."); + return HDF_SUCCESS; + } + + if (commAttr->enableVideo == true) { + HdmiCntlrVideoPathSet(cntlr, videoAttr); + } + + (void)HdmiAviInfoFrameSend(&(cntlr->infoFrame), (commAttr->enableHdmi && commAttr->avi)); + (void)HdmiVsInfoFrameSend(&(cntlr->infoFrame), commAttr->enableHdmi, commAttr->vsifDolby); + /* the drm infoFrame is stop because software was reset in videopath, so re-enable it if the mode is HDR10. */ + if (cntlr->cap.baseCap.bits.hdr > 0) { + if (cntlr->attr.hdrAttr.mode == HDMI_HDR_MODE_CEA_861_3) { + (void)HdmiDrmInfoFrameSend(&(cntlr->infoFrame), false); + (void)HdmiDrmInfoFrameSend(&(cntlr->infoFrame), true); + } + } + return HDF_SUCCESS; +} + +static void HdmiAttrUpdate(struct HdmiCntlr *cntlr) +{ + struct HdmiHardwareStatus hwStatus = {0}; + + if (HdmiColorBitSelect(cntlr) != HDF_SUCCESS) { + HDF_LOGD("attr update: color bit select fail."); + return; + } + + if (cntlr->ops->hardWareStatusGet == NULL) { + return; + } + + HdmiCntlrLock(cntlr); + cntlr->ops->hardWareStatusGet(cntlr, &hwStatus); + HdmiCntlrUnlock(cntlr); + + if (HdmiAudioAttrHandle(cntlr) != HDF_SUCCESS) { + HDF_LOGD("audio attr check fail"); + return; + } + if (HdmiVedioAttrHandle(cntlr, &hwStatus) != HDF_SUCCESS) { + HDF_LOGD("vedio attr check fail"); + } +} + +int32_t HdmiCntlrDeepColorSet(struct HdmiCntlr *cntlr, enum HdmiDeepColor color) +{ + if (cntlr == NULL || cntlr->ops == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->attr.commAttr.colorSpace == HDMI_COLOR_SPACE_YCBCR422) { + if (color != HDMI_DEEP_COLOR_24BITS && color != HDMI_DEEP_COLOR_OFF) { + HDF_LOGE("not support deepcolor %u when colorspace is ycbcr422.", color); + return HDF_ERR_INVALID_PARAM; + } + } + + /* if the current hdmi mode is dolby, deep color set is invalid. */ + if (cntlr->attr.hdrAttr.mode == HDMI_HDR_MODE_DOLBY_NORMAL || + cntlr->attr.hdrAttr.mode == HDMI_HDR_MODE_DOLBY_TUNNELING) { + HDF_LOGD("don't change deepcolor when dolby mode is %u.", cntlr->attr.hdrAttr.mode); + return HDF_ERR_NOT_SUPPORT; + } + + cntlr->attr.commAttr.deepColor = color; + HdmiCntlrAvmuteSet(cntlr, true); + HdmiAttrUpdate(cntlr); + HdmiCntlrAvmuteSet(cntlr, false); + return HDF_SUCCESS; +} + +int32_t HdmiCntlrDeepColorGet(struct HdmiCntlr *cntlr, enum HdmiDeepColor *color) +{ + if (cntlr == NULL || cntlr->ops == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + if (color == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + *color = cntlr->attr.commAttr.deepColor; + return HDF_SUCCESS; +} + +int32_t HdmiCntlrSetVideoAttribute(struct HdmiCntlr *cntlr, struct HdmiVideoAttr *attr) +{ + struct HdmiHardwareStatus hwStatus = {0}; + + if (cntlr == NULL || cntlr->ops == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + if (attr == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + cntlr->attr.videoAttr = *attr; + + if (cntlr->ops->hardWareStatusGet == NULL) { + return HDF_ERR_NOT_SUPPORT; + } + + HdmiCntlrLock(cntlr); + cntlr->ops->hardWareStatusGet(cntlr, &hwStatus); + HdmiCntlrUnlock(cntlr); + return HdmiVedioAttrHandle(cntlr, &hwStatus); +} + +int32_t HdmiCntlrSetAudioAttribute(struct HdmiCntlr *cntlr, struct HdmiAudioAttr *attr) +{ + if (cntlr == NULL || cntlr->ops == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + if (attr == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + cntlr->attr.audioAttr = *attr; + return HdmiAudioAttrHandle(cntlr); +} + +int32_t HdmiCntlrSetHdrAttribute(struct HdmiCntlr *cntlr, struct HdmiHdrAttr *attr) +{ + if (cntlr == NULL || cntlr->ops == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + if (attr == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + return HdmiHdrAttrHandle(cntlr->hdr, attr); +} + +int32_t HdmiCntlrInfoFrameGet(struct HdmiCntlr *cntlr, enum HdmiPacketType type, union HdmiInfoFrameInfo *frame) +{ + if (cntlr == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + return HdmiInfoFrameGetInfo(&(cntlr->infoFrame), type, frame); +} + +int32_t HdmiCntlrInfoFrameSet(struct HdmiCntlr *cntlr, enum HdmiPacketType type, union HdmiInfoFrameInfo *frame) +{ + if (cntlr == NULL || cntlr->ops == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + if (frame == NULL) { + return HDF_ERR_INVALID_PARAM; + } + return HdmiInfoFrameSetInfo(&(cntlr->infoFrame), type, frame); +} + +int32_t HdmiCntlrRegisterHpdCallbackFunc(struct HdmiCntlr *cntlr, struct HdmiHpdCallbackInfo *callback) +{ + if (cntlr == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + if (callback == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + cntlr->event.callback.data = callback->data; + cntlr->event.callback.callbackFunc = callback->callbackFunc; + return HDF_SUCCESS; +} + +int32_t HdmiCntlrUnregisterHpdCallbackFunc(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + cntlr->event.callback.data = NULL; + cntlr->event.callback.callbackFunc = NULL; + return HDF_SUCCESS; +} + +void HdmiCntlrClose(struct HdmiCntlr *cntlr) +{ + if (cntlr == NULL || cntlr->ops == NULL) { + return; + } + + if ((cntlr->state & HDMI_CNTLR_STATE_START) > 0) { + HdmiCntlrStop(cntlr); + } + + HdmiInfoFrameDeInit(cntlr); + HdmiDdcDeinit(cntlr); + HdmiScdcDeinit(cntlr); + HdmiFrlDeinit(cntlr); + HdmiHdcpDeinit(cntlr); + HdmiCecDeinit(cntlr); + HdmiHdrDeinit(cntlr); + cntlr->state = HDMI_CNTLR_STATE_CLOSE; +} diff --git a/support/platform/src/hdmi/hdmi_ddc.c b/support/platform/src/hdmi/hdmi_ddc.c new file mode 100644 index 0000000000000000000000000000000000000000..083ed1a14d5b07e1918e1c27759e0b1a532964b0 --- /dev/null +++ b/support/platform/src/hdmi/hdmi_ddc.c @@ -0,0 +1,45 @@ +/* + * Copyright (c) 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 "hdmi_core.h" + +#define HDF_LOG_TAG hdmi_ddc_c + +int32_t HdmiCntlrDdcTransfer(struct HdmiCntlr *cntlr, struct HdmiDdcCfg *ddcCfg) +{ + int32_t ret; + + if (cntlr == NULL || cntlr->ops == NULL || cntlr->ops->ddcTransfer == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + if (ddcCfg == NULL) { + return HDF_ERR_INVALID_PARAM; + } + HdmiCntlrLock(cntlr); + ret = cntlr->ops->ddcTransfer(cntlr, ddcCfg); + HdmiCntlrUnlock(cntlr); + return ret; +} + +int32_t HdmiDdcTransfer(struct HdmiDdc *ddc, struct HdmiDdcCfg *cfg) +{ + int32_t ret; + + if (ddc == NULL || cfg == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (cfg->mode >= HDMI_DDC_MODE_BUTT) { + return HDF_ERR_INVALID_PARAM; + } + + (void)OsalMutexLock(&(ddc->ddcMutex)); + ret = HdmiCntlrDdcTransfer(ddc->priv, cfg); + (void)OsalMutexUnlock(&(ddc->ddcMutex)); + return ret; +} diff --git a/support/platform/src/hdmi/hdmi_dfm.c b/support/platform/src/hdmi/hdmi_dfm.c new file mode 100644 index 0000000000000000000000000000000000000000..330f5cef0a58a6284a3ae6b60d97a6b39aba2eef --- /dev/null +++ b/support/platform/src/hdmi/hdmi_dfm.c @@ -0,0 +1,279 @@ +/* + * Copyright (c) 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 "hdmi_dfm.h" +#include "hdf_log.h" +#include "hdmi_common.h" + +#define HDF_LOG_TAG hdmi_dfm_c + +#define HDMI_DFM_THOUSAND 1000 +#define HDMI_DFM_INVALID_VAL (-1) + +uint32_t HdmiDfmGetPixelFormat(enum HdmiColorSpace colorSpace) +{ + uint32_t pixelFormat; + + switch (colorSpace) { + case HDMI_COLOR_SPACE_RGB: + pixelFormat = HDMI_DFM_PIXEL_FORMAT_MODE_0; + break; + case HDMI_COLOR_SPACE_YCBCR420: + pixelFormat = HDMI_DFM_PIXEL_FORMAT_MODE_1; + break; + case HDMI_COLOR_SPACE_YCBCR422: + pixelFormat = HDMI_DFM_PIXEL_FORMAT_MODE_2; + break; + case HDMI_COLOR_SPACE_YCBCR444: + pixelFormat = HDMI_DFM_PIXEL_FORMAT_MODE_3; + break; + default: + pixelFormat = HDMI_DFM_PIXEL_FORMAT_MODE_0; + break; + } + return pixelFormat; +} + +void HdmiDfmFillParam(struct HdmiDfmParam *param, struct HdmiVideoDefInfo *videoInfo, + struct HdmiAudioAttr *audioAttr, enum HdmiColorSpace colorSpace, enum HdmiDeepColor deepColor) +{ + if (param == NULL || videoInfo == NULL || audioAttr == NULL) { + return; + } + param->hactive = videoInfo->hactive; + param->vactive = videoInfo->vactive; + param->hblank = videoInfo->hblank; + param->vblank = videoInfo->vblank; + param->hsync = videoInfo->hsync; + param->hback = videoInfo->hback; + param->hfront = videoInfo->hfront; + param->vsync = videoInfo->vsync; + param->vback = videoInfo->vback; + param->vfront = videoInfo->vfront; + param->vfreq = videoInfo->rate; + param->colorDepth = HdmiCommonDeepClolorConvertToColorDepth(deepColor); + param->pixelFormat = HdmiDfmGetPixelFormat(colorSpace); + param->audioRate = (uint32_t)audioAttr->sampleRate; + param->layout = (audioAttr->channels > HDMI_AUDIO_FORMAT_CHANNEL_2) ? true : false; + /* ACAT packet_type */ + param->acat = HDMI_AUDIO_CHANNEL_ALLOC_TYPE3; + param->packetType = HDMI_AUDIO_SAMPLE_PACKET; +} + +static void HdmiDfmBaseInfoInit(struct HdmiDfmInfo *info, struct HdmiDfmParam *param) +{ + info->htotal = param->hactive + param->hblank; + info->vtotal = param->vactive + param->vblank; + info->pixelClk = (uint64_t)(info->htotal) * info->vtotal * param->vfreq / HDMI_DFM_THOUSAND; + + /* 1. Determine the maximum legal pixel rate. */ + info->maxPixelClk = info->pixelClk * (HDMI_DFM_THOUSAND + HDMI_DFM_FRL_PIXELCLK_TOLERANCE) / HDMI_DFM_THOUSAND; + info->minPixelClk = info->pixelClk * (HDMI_DFM_THOUSAND - HDMI_DFM_FRL_PIXELCLK_TOLERANCE) / HDMI_DFM_THOUSAND; + if (info->maxPixelClk == 0 || info->minPixelClk == 0) { + HDF_LOGE("max or min pixel clock is 0!"); + return; + } + + /* 2. Determine the minimum Video Line period. */ + info->lineMinTime = (uint64_t)info->htotal * 1000000000000 / info->maxPixelClk; + info->lineMaxTime = (uint64_t)info->htotal * 1000000000000 / info->minPixelClk; + + /* 3. Determine the Worst Case Slow Bit Rate. x10000 */ + info->minBitRate = (uint64_t)param->bitRate * 1000000000 * (10000 - HDMI_DFM_FRL_BITRATE_TOLERANCE) / 10000; + info->maxBitRate = (uint64_t)param->bitRate * 1000000000 * (10000 + HDMI_DFM_FRL_BITRATE_TOLERANCE) / 10000; + + /* 4. Determine the FRL Character Rate */ + info->minFrlCharRate = info->minBitRate / 18; + info->maxFrlCharRate = info->maxBitRate / 18; + + /* 5. Determine the Total FRL Characters per line Period. */ + info->minFrlCharsPerLine = (uint32_t)(info->lineMinTime * info->minFrlCharRate * param->laneNum / 1000000000000); + info->maxFrlCharsPerLine = (uint32_t)(info->lineMaxTime * info->maxFrlCharRate * param->laneNum / 1000000000000); + + info->cFrlSb = HDMI_DFM_FRL_SB_LEN(param->laneNum); + info->overheadSb = param->laneNum * 100000 / info->cFrlSb; + info->overheadRs = HDMI_DFM_RS_NUM_PER_CB * HDMI_DFM_FRL_CB_NUM_PER_SB * 100000 / info->cFrlSb; + info->overheadMap = 25 * 10000 / info->cFrlSb; /* FRL map chars per blk. */ + info->overheadMin = info->overheadSb + info->overheadRs + info->overheadMap; + info->overheadMax = info->overheadMin + HDMI_DFM_OVERHEAD_SIZE; +} + +static uint32_t HdmiDfmGetAudioPackets(struct HdmiDfmParam *param) +{ + uint32_t ap = 0; + + switch (param->packetType) { + case HDMI_AUDIO_SAMPLE_PACKET: + case HDMI_ONE_BIT_AUDIO_SAMPLE_PACKET: + ap = HDMI_AUDIO_AP_SIZE_100; + if (param->layout == false) { + ap = HDMI_AUDIO_AP_SIZE_25; + } + break; + case HDMI_DTS_AUDIO_PACKET: + case HDMI_HBR_AUDIO_PACKET: + case HDMI_MULTI_STREAM_AUDIO_SAMPLE_PACKET: + case HDMI_ONE_BIT_MULTI_STREAM_AUDIO_SAMPLE_PACKET: + ap = HDMI_AUDIO_AP_SIZE_100; + break; + case HDMI_AUDIO_3D_SAMPLE_PACKET: + case HDMI_ONE_BIT_AUDIO_3D_SAMPLE_PACKET: + if (param->acat == HDMI_AUDIO_CHANNEL_ALLOC_TYPE1) { + ap = HDMI_AUDIO_AP_SIZE_200; + } else if (param->acat == HDMI_AUDIO_CHANNEL_ALLOC_TYPE2) { + ap = HDMI_AUDIO_AP_SIZE_300; + } else if (param->acat == HDMI_AUDIO_CHANNEL_ALLOC_TYPE3) { + ap = HDMI_AUDIO_AP_SIZE_400; + } + break; + default: + HDF_LOGE("audio packet type 0x%x, is not support.", param->packetType); + break; + } + + return ap; +} + +static void HdmiDfmCaculateAudioInfo(struct HdmiDfmInfo *info, struct HdmiDfmParam *param) +{ + /* 1. Determine the number of audio packets required to carry each sample. */ + info->audioAp = HdmiDfmGetAudioPackets(param); + + /* 2. Determine Average Audio Related Packet Rate. */ + info->audioRap = (uint32_t)((uint64_t)param->audioRate * (1000 + HDMI_DFM_FRL_AUDIOCLK_TOLERANCE) * + info->audioAp / 100000); + + /* 3. Determine Average Required Packets per line. */ + info->avgAudioPacketsPerLine = (uint32_t)((uint64_t)info->audioRap * info->lineMinTime / 1000000000); + + /* 4. Determine the Packets per Hblank that must be supportable. */ + info->audioPacketsLine = (info->avgAudioPacketsPerLine + HDMI_DFM_THOUSAND - 1) / HDMI_DFM_THOUSAND; + + /* + * 5. Determine The c_frl_blank_min(64(guard bands, two 12-character control periods, c_frl_active_extra) + * and 32 audio_packets). + */ + info->hblankAudioMin = 64 + 32 * info->audioPacketsLine; +} + +static void HdmiDfmCaculateVideoBorrowInfo(struct HdmiDfmInfo *info) +{ + if (info->activeTimeRef >= info->activeTimeMin && info->blankTimeRef >= info->blankTimeMin) { + info->tBorrow = 0; + } else if (info->activeTimeRef < info->activeTimeMin && info->blankTimeRef >= info->blankTimeMin) { + info->tBorrow = info->activeTimeMin - info->activeTimeRef; + } else { + info->tBorrow = HDMI_DFM_INVALID_VAL; + } + if (info->tBorrow == HDMI_DFM_INVALID_VAL) { + info->tbBorrow = HDMI_DFM_INVALID_VAL; + } else { + info->tbBorrow = ((int32_t)(info->tBorrow * info->avgTbRate / 100000000000) + 10 - 1) / 10; + } +} + +static void HdmiDfmCaculateVideoInfo(struct HdmiDfmInfo *info, struct HdmiDfmParam *param) +{ + uint32_t kcd, k420; + + /* + * 1. if 4:2:2 pixels, kcd is 1. Otherwise, kcd is CD / 8. + * if 4:2:0 pixels, k420 is 2. Otherwise, k420 is 1. + */ + kcd = (param->pixelFormat == 2) ? HDMI_DFM_MAGNIFICATION_8 : param->colorDepth; + k420 = (param->pixelFormat == 1) ? 2 : 1; + + /* 2. Determine Bits per Pixel */ + info->bpp = ((24 * kcd) / k420) / HDMI_DFM_MAGNIFICATION_8; + + /* 3. Determine Video Bytes per line. */ + info->activeBytesPerLine = info->bpp * param->hactive / HDMI_DFM_MAGNIFICATION_8; + + /* + * 4. Determine Required Characters to carry Active Video per line. + * 3 is means active_bytes_per_line need 3 characters. + */ + info->activeTbPerLine = (info->activeBytesPerLine + 3 - 1) / 3; + + /* 5. Determine Required Characters to carry H-Blank Video per line. */ + info->hblankTbPerLine = (param->hblank * kcd / k420 + HDMI_DFM_MAGNIFICATION_8 - 1) / HDMI_DFM_MAGNIFICATION_8; + + /* 6. 32 is FRL characters each packet, 7 is guard bands island(4 FRL char) + video(3 FRL char) */ + if (((param->hblank * kcd) / k420) / HDMI_DFM_MAGNIFICATION_8 > 32 * (1 + info->audioPacketsLine) + 7) { + info->cFrlFree = ((param->hblank * kcd) / k420) / HDMI_DFM_MAGNIFICATION_8 - + 32 * (1 + info->audioPacketsLine) - 7; + } + + /* 7. add 1 character each for RC break caused by 4 */ + info->cFrlRcMargin = 4; + /* 8. RC compression transmit control characters reduce 7/8th total characters. */ + if (7 * info->cFrlFree / HDMI_DFM_MAGNIFICATION_8 > info->cFrlRcMargin) { + info->cFrlRcSavings = 7 * info->cFrlFree / HDMI_DFM_MAGNIFICATION_8 - info->cFrlRcMargin; + } + + if (info->htotal == 0) { + HDF_LOGE("htotal is 0!"); + return; + } + info->avgTbRate = info->maxPixelClk * (info->activeTbPerLine + info->hblankTbPerLine) / info->htotal; + info->activeTimeRef = (uint64_t)info->lineMinTime * param->hactive / info->htotal; + info->blankTimeRef = (uint64_t)info->lineMinTime * param->hblank / info->htotal; + + /* 9. (3 / 2) is active_tb coefficient in protocol */ + info->activeTimeMin = (uint64_t)info->activeTbPerLine * 3 * 100000000000000 / + (2 * param->laneNum * info->minFrlCharRate * (HDMI_DFM_RATE_MAGNIFICATION - info->overheadMax) / + HDMI_DFM_THOUSAND); + info->blankTimeMin = (uint64_t)info->hblankTbPerLine * 100000000000000 / + (param->laneNum * info->minFrlCharRate * (HDMI_DFM_RATE_MAGNIFICATION - info->overheadMax) / + HDMI_DFM_THOUSAND); + + /* 10. Determine Borrow Info */ + HdmiDfmCaculateVideoBorrowInfo(info); + + /* 11. (3 / 2) is active_tb coefficient in protocol */ + info->cFrlActualPayload = + (3 * info->activeTbPerLine + 2 - 1) / 2 + info->hblankTbPerLine - info->cFrlRcSavings; + + if (info->minFrlCharsPerLine == 0) { + HDF_LOGE("min FRL Characters per line is 0!"); + return; + } + info->utilization = (uint64_t)info->cFrlActualPayload * 100000 / (uint64_t)info->minFrlCharsPerLine; + info->margin = 100000 - (info->utilization + info->overheadMax); +} + +static void HdmiDfmFillInfo(struct HdmiDfmInfo *info, struct HdmiDfmParam *param) +{ + HdmiDfmBaseInfoInit(info, param); + HdmiDfmCaculateAudioInfo(info, param); + HdmiDfmCaculateVideoInfo(info, param); + + /* Check Audio Cap. */ + info->audioSupport = (info->hblankTbPerLine >= info->hblankAudioMin) ? true : false; + /* Check Video Cap. */ + if (info->tbBorrow == HDMI_DFM_INVALID_VAL) { + info->videoSupport = false; + } else { + info->videoSupport = (info->tbBorrow <= HDMI_DFM_FRL_MAX_TB_BORROW) ? true : false; + } + + info->uncompressSupport = (info->margin >= 0) ? true : false; + info->canbeTrans = (info->audioSupport && info->videoSupport && info->uncompressSupport) ? true : false; + info->isExtraMode = (info->canbeTrans && (info->tbBorrow > 0)) ? true : false; +} + +bool HdmiDfmFormatSupport(struct HdmiDfmParam *param) +{ + struct HdmiDfmInfo info = {0}; + + HdmiDfmFillInfo(&info, param); + if (info.audioSupport == true && info.videoSupport == true && info.uncompressSupport == true) { + return true; + } + return false; +} diff --git a/support/platform/src/hdmi/hdmi_dispatch.c b/support/platform/src/hdmi/hdmi_dispatch.c new file mode 100644 index 0000000000000000000000000000000000000000..c8f796cbe82d384fd0af891535f73b4a638fe04e --- /dev/null +++ b/support/platform/src/hdmi/hdmi_dispatch.c @@ -0,0 +1,290 @@ +/* + * Copyright (c) 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 "hdmi_dispatch.h" +#include "hdf_log.h" +#include "hdmi_core.h" +#include "hdmi_if.h" + +#define HDF_LOG_TAG hdmi_dispatch_c + +enum HdmiIoCmd { + HDMI_CMD_OPEN, + HDMI_CMD_CLOSE, + HDMI_CMD_START, + HDMI_CMD_STOP, + HDMI_CMD_AVMUTE_SET, + HDMI_CMD_DEEP_COLOR_SET, + HDMI_CMD_DEEP_COLOR_GET, + HDMI_CMD_VIDEO_ATTR_SET, + HDMI_CMD_AUDIO_ATTR_SET, + HDMI_CMD_HDR_ATTR_SET, + HDMI_CMD_READ_SINK_EDID, + HDMI_CMD_INFOFRAME_SET, + HDMI_CMD_INFOFRAME_GET, + HDMI_CMD_REGISTER_HPD_CALLBACK_FUNC, + HDMI_CMD_UNREGISTER_HPD_CALLBACK_FUNC, + HDMI_CMD_BUTT, +}; + +struct HdmiDispatchFunc { + int32_t cmd; + int32_t (*func)(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply); +}; + +static int32_t HdmiCmdOpen(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)data; + (void)reply; + + return HdmiCntlrOpen(cntlr); +} + +static int32_t HdmiCmdClose(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)data; + (void)reply; + + HdmiCntlrClose(cntlr); + return HDF_SUCCESS; +} + +static int32_t HdmiCmdStart(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)data; + (void)reply; + + return HdmiCntlrStart(cntlr); +} + +static int32_t HdmiCmdStop(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)data; + (void)reply; + + return HdmiCntlrStop(cntlr); +} + +static int32_t HdmiCmdAvmuteSet(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + bool *enable = NULL; + size_t size; + (void)reply; + + if (!HdfSbufReadBuffer(data, (const void **)&enable, &size)) { + HDF_LOGE("HdmiCmdAvmuteSet: sbuf read buffer failed"); + return HDF_ERR_IO; + } + HdmiCntlrAvmuteSet(cntlr, *enable); + return HDF_SUCCESS; +} + +static int32_t HdmiCmdDeepColorSet(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + enum HdmiDeepColor *color = NULL; + size_t size; + (void)reply; + + if (!HdfSbufReadBuffer(data, (const void **)&color, &size)) { + HDF_LOGE("HdmiCmdDeepColorSet: sbuf read buffer failed"); + return HDF_ERR_IO; + } + return HdmiCntlrDeepColorSet(cntlr, *color); +} + +static int32_t HdmiCmdDeepColorGet(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + int32_t ret; + enum HdmiDeepColor color; + (void)data; + + if (reply == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + ret = HdmiCntlrDeepColorGet(cntlr, &color); + if (ret != HDF_SUCCESS) { + return ret; + } + + if (HdfSbufWriteBuffer(reply, &color, sizeof(color)) == false) { + HDF_LOGE("HdmiCmdDeepColorGet: write back color fail!"); + return HDF_ERR_IO; + } + return HDF_SUCCESS; +} + +static int32_t HdmiCmdVideoAttrSet(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + struct HdmiVideoAttr *attr = NULL; + size_t size; + (void)reply; + + if (!HdfSbufReadBuffer(data, (const void **)&attr, &size)) { + HDF_LOGE("HdmiCmdVideoAttrSet: sbuf read buffer failed"); + return HDF_ERR_IO; + } + return HdmiCntlrSetVideoAttribute(cntlr, attr); +} + +static int32_t HdmiCmdAudioAttrSet(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + struct HdmiAudioAttr *attr = NULL; + size_t size; + (void)reply; + + if (!HdfSbufReadBuffer(data, (const void **)&attr, &size)) { + HDF_LOGE("HdmiCmdAudioAttrSet: sbuf read buffer failed"); + return HDF_ERR_IO; + } + return HdmiCntlrSetAudioAttribute(cntlr, attr); +} + +static int32_t HdmiCmdHdrAttrSet(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + struct HdmiHdrAttr *attr = NULL; + size_t size; + (void)reply; + + if (!HdfSbufReadBuffer(data, (const void **)&attr, &size)) { + HDF_LOGE("HdmiCmdHdrAttrSet: sbuf read buffer failed"); + return HDF_ERR_IO; + } + return HdmiCntlrSetHdrAttribute(cntlr, attr); +} + +static int32_t HdmiCmdReadSinkEdid(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + int32_t ret; + uint8_t edid[HDMI_EDID_TOTAL_SIZE] = {0}; + (void)data; + + if (reply == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + ret = HdmiCntlrGetSinkEdid(cntlr, edid, HDMI_EDID_TOTAL_SIZE); + if (ret != HDF_SUCCESS) { + return ret; + } + + if (HdfSbufWriteBuffer(reply, edid, HDMI_EDID_TOTAL_SIZE) == false) { + HDF_LOGE("HdmiCmdReadSinkEdid: write back edid fail!"); + return HDF_ERR_IO; + } + + return HDF_SUCCESS; +} + +static int32_t HdmiCmdInfoFrameSet(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + enum HdmiPacketType type; + union HdmiInfoFrameInfo *frame = NULL; + size_t size; + + if (!HdfSbufReadUint16(data, (uint16_t *)&type)) { + HDF_LOGE("HdmiCmdInfoFrameSet: sbuf read uint16 failed"); + return HDF_ERR_IO; + } + + if (!HdfSbufReadBuffer(data, (const void **)&frame, &size)) { + HDF_LOGE("HdmiCmdInfoFrameSet: sbuf read buffer failed"); + return HDF_ERR_IO; + } + return HdmiCntlrInfoFrameSet(cntlr, type, frame); +} + +static int32_t HdmiCmdInfoFrameGet(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + size_t size; + int32_t ret; + enum HdmiPacketType *type = NULL; + union HdmiInfoFrameInfo frame = {0}; + + if (!HdfSbufReadBuffer(data, (const void **)&type, &size)) { + HDF_LOGE("HdmiCmdInfoFrameGet: sbuf read buffer failed"); + return HDF_ERR_IO; + } + + ret = HdmiCntlrInfoFrameGet(cntlr, *type, &frame); + if (ret != HDF_SUCCESS) { + return ret; + } + + if (HdfSbufWriteBuffer(reply, &frame, sizeof(frame)) == false) { + HDF_LOGE("HdmiCmdInfoFrameGet: write back frame fail!"); + return HDF_ERR_IO; + } + + return HDF_SUCCESS; +} + +static int32_t HdmiCmdRegisterHpdCallbackFunc(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + uint32_t *addr = NULL; + size_t size; + (void)reply; + + if (!HdfSbufReadBuffer(data, (const void **)&addr, &size)) { + HDF_LOGE("HdmiCmdRegisterHpdCallbackFunc: sbuf read buffer failed"); + return HDF_ERR_IO; + } + return HdmiCntlrRegisterHpdCallbackFunc(cntlr, (struct HdmiHpdCallbackInfo *)(uintptr_t)(*addr)); +} + +static int32_t HdmiCmdUnregisterHpdCallbackFunc(struct HdmiCntlr *cntlr, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)data; + (void)reply; + + return HdmiCntlrUnregisterHpdCallbackFunc(cntlr); +} + +int32_t HdmiIoDispatch(struct HdfDeviceIoClient *client, int32_t cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + struct HdmiCntlr *cntlr = NULL; + uint32_t i, len; + struct HdmiDispatchFunc dispatchFunc[] = { + { HDMI_CMD_OPEN, HdmiCmdOpen }, + { HDMI_CMD_CLOSE, HdmiCmdClose }, + { HDMI_CMD_START, HdmiCmdStart }, + { HDMI_CMD_STOP, HdmiCmdStop }, + { HDMI_CMD_AVMUTE_SET, HdmiCmdAvmuteSet }, + { HDMI_CMD_DEEP_COLOR_SET, HdmiCmdDeepColorSet }, + { HDMI_CMD_DEEP_COLOR_GET, HdmiCmdDeepColorGet }, + { HDMI_CMD_VIDEO_ATTR_SET, HdmiCmdVideoAttrSet }, + { HDMI_CMD_AUDIO_ATTR_SET, HdmiCmdAudioAttrSet }, + { HDMI_CMD_HDR_ATTR_SET, HdmiCmdHdrAttrSet }, + { HDMI_CMD_READ_SINK_EDID, HdmiCmdReadSinkEdid }, + { HDMI_CMD_INFOFRAME_SET, HdmiCmdInfoFrameSet }, + { HDMI_CMD_INFOFRAME_GET, HdmiCmdInfoFrameGet }, + { HDMI_CMD_REGISTER_HPD_CALLBACK_FUNC, HdmiCmdRegisterHpdCallbackFunc }, + { HDMI_CMD_UNREGISTER_HPD_CALLBACK_FUNC, HdmiCmdUnregisterHpdCallbackFunc }, + }; + + if (client == NULL || client->device == NULL) { + HDF_LOGE("HdmiIoDispatch: client or hdf dev obj is NULL"); + return HDF_ERR_INVALID_OBJECT; + } + + cntlr = (struct HdmiCntlr *)client->device->service; + if (cntlr == NULL) { + HDF_LOGE("HdmiIoDispatch: service is NULL"); + return HDF_ERR_INVALID_OBJECT; + } + + len = sizeof(dispatchFunc) / sizeof(dispatchFunc[0]); + for (i = 0; i < len; i++) { + if (dispatchFunc[i].cmd == cmd) { + return dispatchFunc[i].func(cntlr, data, reply); + } + } + + HDF_LOGE("HdmiIoDispatch: cmd %d is not support", cmd); + return HDF_ERR_NOT_SUPPORT; +} diff --git a/support/platform/src/hdmi/hdmi_edid.c b/support/platform/src/hdmi/hdmi_edid.c new file mode 100644 index 0000000000000000000000000000000000000000..9048333eb53646544e1e0cdac192874c16f301ba --- /dev/null +++ b/support/platform/src/hdmi/hdmi_edid.c @@ -0,0 +1,1376 @@ +/* + * Copyright (c) 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_log.h" +#include "hdmi_core.h" +#include "securec.h" + +#define HDF_LOG_TAG hdmi_edid_c + +/* + * Address locations 0x00 and 0x07 contain data values 0x00 and locations 0x01 through 0x06 contain 0xFF as data + * values. CTA-861 requires this data. This header is used to determine the beginning of an EDID structure in a Sink. + */ +uint8_t g_edidHeader[HDMI_EDID_BLOCK_HEADER_FIELD_LEN] = { 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 }; + +int32_t HdmiEdidReset(struct HdmiEdid *edid) +{ + if (edid == NULL) { + return HDF_ERR_INVALID_PARAM; + } + if (memset_s(edid, sizeof(struct HdmiEdid), 0, sizeof(struct HdmiEdid)) != EOK) { + HDF_LOGE("memset_s fail."); + return HDF_ERR_IO; + } + return HDF_SUCCESS; +} + +int32_t HdmiEdidGetRaw(struct HdmiEdid *edid, uint8_t *raw, uint32_t len) +{ + uint32_t length; + + if (edid == NULL || raw == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + length = ((len < edid->rawLen) ? len : edid->rawLen); + if (length == 0) { + HDF_LOGE("edid data not get."); + return (int32_t)length; + } + if (memcpy_s(raw, len, edid->raw, length) != EOK) { + HDF_LOGE("memcpy_s fail."); + return HDF_ERR_IO; + } + return (int32_t)length; +} + +static int32_t HdmiEdidHeaderPhase(struct HdmiEdid *edid) +{ + struct HdmiEdidFirstBlockInfo *block = (struct HdmiEdidFirstBlockInfo *)edid->raw; + uint32_t i; + + for (i = 0; i < HDMI_EDID_BLOCK_HEADER_FIELD_LEN; i++) { + if (block->header[i] != g_edidHeader[i]) { + HDF_LOGE("header[%d] = 0x%x, is error.", i, block->header[i]); + return HDF_ERR_INVALID_PARAM; + } + } + return HDF_SUCCESS; +} + +static int32_t HdmiEdidBlockCheckSum(uint8_t *data) +{ + uint32_t i; + uint32_t checkSum = 0; + + HDF_LOGD("check sum is 0x%x", data[HDMI_EDID_CHECKSUM_ADDR]); + for (i = 0; i < HDMI_EDID_SINGLE_BLOCK_SIZE; i++) { + checkSum += data[i]; + } + if ((checkSum & HDMI_EDID_CHECK_SUM_MARK) == 0) { + return HDF_SUCCESS; + } + HDF_LOGE("checksum = 0x%x, is invalid.", checkSum); + return HDF_FAILURE; +} + +static int32_t HdmiEdidVendorInfoPhase(struct HdmiEdid *edid) +{ + uint16_t data, i, tmpData; + struct HdmiSinkDeviceCapability *sinkCap = &(edid->sinkCap); + struct HdmiEdidFirstBlockInfo *block = (struct HdmiEdidFirstBlockInfo *)edid->raw; + + /* Manufacturer Name */ + data = (block->vendorName[UINT8_ARRAY_TElEMENT_0] << + HDMI_EDID_MANUFACRURER_NAME_SHIFT) | + (block->vendorName[UINT8_ARRAY_TElEMENT_1]); + for (i = 0; i < HDMI_EDID_MANUFACRURER_NAME_MAX_LEN - 1; i++) { + tmpData = (data & (HDMI_EDID_MANUFACRURER_NAME_CHAR_MARK << (HDMI_EDID_MANUFACRURER_NAME_CHAR_SHIFT * i))); + tmpData = (tmpData >> (HDMI_EDID_MANUFACRURER_NAME_CHAR_SHIFT * i)); + if (tmpData > HDMI_EDID_MANUFACRURER_NAME_LOW_INVALID && + tmpData < HDMI_EDID_MANUFACRURER_NAME_HIGH_INVALID) { + sinkCap->vendorInfo.mfrName[2 - i] = (char)('A' + tmpData - 1); + } + } + + /* Product Code */ + data = (block->productCode[UINT8_ARRAY_TElEMENT_1] << + HDMI_EDID_PRODUCT_CODE_SHIFT) | + (block->productCode[UINT8_ARRAY_TElEMENT_0]); + sinkCap->vendorInfo.productCode = data; + + /* Serial Number */ + for (i = 0; i < HDMI_EDID_SERIAL_NUMBER_FIELD_LEN; i++) { + sinkCap->vendorInfo.serialNumber |= (block->serialNumber[i] << (HDMI_EDID_SERIAL_NUMBER_SHIFT * i)); + } + sinkCap->vendorInfo.week = block->week; + sinkCap->vendorInfo.year = block->year + HDMI_EDID_YEAR_BASE; + return HDF_SUCCESS; +} + +static int32_t HdmiEdidVersionInfoPhase(struct HdmiEdid *edid) +{ + struct HdmiSinkDeviceCapability *sinkCap = &(edid->sinkCap); + struct HdmiEdidFirstBlockInfo *block = (struct HdmiEdidFirstBlockInfo *)edid->raw; + + sinkCap->verInfo.version = block->version; + sinkCap->verInfo.revision = block->revision; + if (sinkCap->verInfo.version != HDMI_EDID_VERSION_NUM) { + HDF_LOGW("edid version is %d", sinkCap->verInfo.version); + } + if (sinkCap->verInfo.revision != HDMI_EDID_REVISION_NUM) { + HDF_LOGW("edid revision is %d", sinkCap->verInfo.revision); + } + return HDF_SUCCESS; +} + +static int32_t HdmiEdidBasicDispPhase(struct HdmiEdid *edid) +{ + struct HdmiSinkDeviceCapability *sinkCap = &(edid->sinkCap); + struct HdmiEdidFirstBlockInfo *block = (struct HdmiEdidFirstBlockInfo *)edid->raw; + + sinkCap->disp.width = block->width; + sinkCap->disp.height = block->height; + HDF_LOGI("width = %d, height = %d", block->width, block->height); + return HDF_SUCCESS; +} + +static int32_t HdmiEdidColorFeaturePhase(struct HdmiEdid *edid) +{ + struct HdmiSinkDeviceCapability *sinkCap = &(edid->sinkCap); + struct HdmiEdidFirstBlockInfo *block = (struct HdmiEdidFirstBlockInfo *)edid->raw; + + /* red color phase */ + sinkCap->colorInfo.redX = (block->redX << HDMI_EDID_COLOR_HIGH_OFFSET) | + ((block->redGreenLow >> HDMI_EDID_COLOR_RED_X_LOW_OFFSET) & HDMI_EDID_COLOR_LOW_BITS_MARK); + sinkCap->colorInfo.redY = (block->redY << HDMI_EDID_COLOR_HIGH_OFFSET) | + ((block->redGreenLow >> HDMI_EDID_COLOR_RED_Y_LOW_OFFSET) & HDMI_EDID_COLOR_LOW_BITS_MARK); + /* green color phase */ + sinkCap->colorInfo.greenX = (block->greenX << HDMI_EDID_COLOR_HIGH_OFFSET) | + ((block->redGreenLow >> HDMI_EDID_COLOR_GREEN_X_LOW_OFFSET) & HDMI_EDID_COLOR_LOW_BITS_MARK); + sinkCap->colorInfo.greenY = (block->greenY << HDMI_EDID_COLOR_HIGH_OFFSET) | + (block->redGreenLow & HDMI_EDID_COLOR_LOW_BITS_MARK); + /* blue color phase */ + sinkCap->colorInfo.blueX = (block->blueX << HDMI_EDID_COLOR_HIGH_OFFSET) | + ((block->blueWhiteLow >> HDMI_EDID_COLOR_BLUE_X_LOW_OFFSET) & HDMI_EDID_COLOR_LOW_BITS_MARK); + sinkCap->colorInfo.blueY = (block->blueY << HDMI_EDID_COLOR_HIGH_OFFSET) | + ((block->blueWhiteLow >> HDMI_EDID_COLOR_BLUE_Y_LOW_OFFSET) & HDMI_EDID_COLOR_LOW_BITS_MARK); + /* white color phase */ + sinkCap->colorInfo.whiteX = (block->whiteX << HDMI_EDID_COLOR_HIGH_OFFSET) | + ((block->blueWhiteLow >> HDMI_EDID_COLOR_WHITE_X_LOW_OFFSET) & HDMI_EDID_COLOR_LOW_BITS_MARK); + sinkCap->colorInfo.whiteY = (block->whiteY << HDMI_EDID_COLOR_HIGH_OFFSET) | + (block->blueWhiteLow & HDMI_EDID_COLOR_LOW_BITS_MARK); + return HDF_SUCCESS; +} + +static int32_t HdmiEdidEstablisedTimingPhase(struct HdmiEdid *edid) +{ + uint32_t i; + uint32_t data = 0; + struct HdmiSinkDeviceCapability *sinkCap = &(edid->sinkCap); + struct HdmiEdidFirstBlockInfo *block = (struct HdmiEdidFirstBlockInfo *)edid->raw; + + for (i = 0; i < HDMI_EDID_ESTABLISHED_TIMINGS_FIELD_LEN; i++) { + data |= (block->estTimings[i] << (i * HDMI_ONE_BYTE_SHIFT)); + } + + /* + * The established timing block is a field of one-bit flags, which are used to inducate support for established + * VESA and other common timing in a very compact form. A bit set to "1" indicate support for that timing. + */ + for (i = 0; i < HDMI_EDID_ESTABLISHED_TIMING_BUTT; i++) { + if ((data & (1 << i)) > 0) { + sinkCap->establishedTimingsInfo.estTimings[i] = i; + sinkCap->establishedTimingsInfo.estTimingsNum++; + } + } + return HDF_SUCCESS; +} + +static uint32_t HdmiEdidGetStandardTimingVertPixel(uint32_t aspectRatio, uint32_t horizPixel) +{ + uint32_t vertPixel = 0; + + switch (aspectRatio) { + case HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_16_10: + vertPixel = horizPixel * VIDEO_WIDTH_10 / VIDEO_LENGTH_16; + break; + case HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_5_4: + vertPixel = horizPixel * VIDEO_WIDTH_4 / VIDEO_LENGTH_5; + break; + case HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_4_3: + vertPixel = horizPixel * VIDEO_WIDTH_3 / VIDEO_LENGTH_4; + break; + case HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_16_9: + vertPixel = horizPixel * VIDEO_WIDTH_9 / VIDEO_LENGTH_16; + break; + default: + HDF_LOGE("aspectRatio %d is invalid.", aspectRatio); + break; + } + return vertPixel; +} + +static int32_t HdmiEdidStandardTimingPhase(struct HdmiEdid *edid) +{ + uint32_t i, aspectRatio; + struct HdmiSinkDeviceCapability *sinkCap = &(edid->sinkCap); + struct HdmiEdidFirstBlockInfo *block = (struct HdmiEdidFirstBlockInfo *)edid->raw; + uint8_t *data = block->stdTiming; + + /* + * A 2-byte timing identifier identifies each timing mode. + * Unused fields in this section shall be set to 01h, 01h. + */ + for (i = 0; i < HDMI_EDID_STANDARD_TIMING_COUNT; i++) { + if (data[UINT8_ARRAY_TElEMENT_0] != HDMI_EDID_STANDARD_TIMING_UNUSED_FLAG || + data[UINT8_ARRAY_TElEMENT_1] != HDMI_EDID_STANDARD_TIMING_UNUSED_FLAG) { + sinkCap->stdTimingsInfo[i].horizPixel = (data[UINT8_ARRAY_TElEMENT_0] + + HDMI_EDID_STANDARD_TIMING_HORIZ_PIXEL_BASE) * + HDMI_EDID_STANDARD_TIMING_HORIZ_PIXEL_FACTOR; + sinkCap->stdTimingsInfo[i].refreshRate = (data[UINT8_ARRAY_TElEMENT_1] & + HDMI_EDID_STANDARD_TIMING_REFRESH_RATE_MARK) + + HDMI_EDID_STANDARD_TIMING_REFRESH_RATE_BASE; + aspectRatio = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_MARK) >> + HDMI_EDID_STANDARD_TIMING_ASPECT_RATE_SHIFT; + sinkCap->stdTimingsInfo[i].vertPixel = + HdmiEdidGetStandardTimingVertPixel(aspectRatio, sinkCap->stdTimingsInfo[i].horizPixel); + } + data += HDMI_EDID_PER_STANDARD_TIMING_BYTE_NUM; + } + return HDF_SUCCESS; +} + +static void HdmiEdidMonitorDescriptorPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint32_t len) +{ + struct HdmiEdidMonitorBlockInfo *block = (struct HdmiEdidMonitorBlockInfo *)data; + + if (block->dataTag != HDMI_EDID_MONITOR_DATA_NAME) { + return; + } + if (memcpy_s(sinkCap->sinkDeviceName, HDMI_EDID_MAX_SINK_NAME_COUNT, + block->data, HDMI_EDID_MONITOR_DATA_FIELD_LEN) != EOK) { + HDF_LOGE("memcpy_s sink name fail"); + } +} + +static void HdmiEdidDigitalSyncSignal(struct HdmiEdidPreferredTimingInfo *perTiming, uint8_t flags) +{ + /* bit3/bit2/bit1 */ + switch ((flags & HDMI_EDID_DETAILED_TIMING_SYNC_SIGNAL_TYPE_MARK) >> 1) { + case HDMI_EDID_DETAILED_TIMING_SYNC_DCS_WS_0: + case HDMI_EDID_DETAILED_TIMING_SYNC_DCS_WS_1: + case HDMI_EDID_DETAILED_TIMING_SYNC_DCS_DS_2: + case HDMI_EDID_DETAILED_TIMING_SYNC_DCS_DS_3: + perTiming->ihs = false; + perTiming->ivs = false; + break; + case HDMI_EDID_DETAILED_TIMING_SYNC_DSS_VN_HN_4: + perTiming->ihs = false; + perTiming->ivs = false; + break; + case HDMI_EDID_DETAILED_TIMING_SYNC_DSS_VN_HP_5: + perTiming->ihs = true; + perTiming->ivs = false; + break; + case HDMI_EDID_DETAILED_TIMING_SYNC_DSS_VP_HN_6: + perTiming->ihs = false; + perTiming->ivs = true; + break; + case HDMI_EDID_DETAILED_TIMING_SYNC_DSS_VP_HP_7: + perTiming->ihs = true; + perTiming->ivs = true; + break; + default: + break; + } +} + +static void HdmiEdidDetailedTimingDescriptorPhase(struct HdmiSinkDeviceCapability *cap, uint8_t *data, uint32_t len) +{ + struct HdmiEdidDetailedTimingBlockInfo *block = (struct HdmiEdidDetailedTimingBlockInfo *)data; + struct HdmiEdidPreferredTimingInfo *perTiming = NULL; + uint32_t pixelClock; + + if (cap->preTimingCnt >= HDMI_EDID_MAX_DETAILED_TIMING_COUNT) { + HDF_LOGE("preTimingCnt reach the maximum"); + return; + } + + perTiming = &cap->preTimingInfo[cap->preTimingCnt]; + pixelClock = (block->pixelClk[UINT8_ARRAY_TElEMENT_1] << + HDMI_ONE_BYTE_SHIFT) | + (block->pixelClk[UINT8_ARRAY_TElEMENT_0]); + if (pixelClock == 0) { + HDF_LOGD(" pixel clock is 0. preTimingCnt = %d", cap->preTimingCnt); + return; + } + + perTiming->pixelClk = pixelClock * HDMI_EDID_DETAILED_TIMING_PIXEL_CLK_KHZ_FACTOR; + perTiming->hActive = (block->hActive) | + ((block->hActiveBlanking & HDMI_EDID_DETAILED_TIMING_UPPER_4BITS_MARK) << HDMI_NIBBLE_SHIFT); + perTiming->hBackBlank = (block->hBlanking) | + ((block->hActiveBlanking & HDMI_EDID_DETAILED_TIMING_LOWER_4BITS_MARK) << HDMI_ONE_BYTE_SHIFT); + perTiming->hFrontBlank = (block->hSyncOffset) | + ((block->hsOffsetVsOffset & HDMI_EDID_DETAILED_TIMING_HS_OFFSET_MARK) << HDMI_2_BITS_SHIFT); + perTiming->hSyncPluseWidth = (block->hSyncPulseWidth) | + ((block->hsOffsetVsOffset & HDMI_EDID_DETAILED_TIMING_HS_PULSE_WIDTH_MARK) << HDMI_NIBBLE_SHIFT); + + perTiming->vActive = (block->vActive) | + ((block->vActiveBlanking & HDMI_EDID_DETAILED_TIMING_UPPER_4BITS_MARK) << HDMI_NIBBLE_SHIFT); + perTiming->vBackBlank = (block->vBlanking) | + ((block->vActiveBlanking & HDMI_EDID_DETAILED_TIMING_LOWER_4BITS_MARK) << HDMI_ONE_BYTE_SHIFT); + perTiming->vFrontBlank = + ((block->hsOffsetVsOffset & HDMI_EDID_DETAILED_TIMING_VS_OFFSET_MARK) << HDMI_2_BITS_SHIFT) | + ((block->vsOffesetPulseWidth & HDMI_EDID_DETAILED_TIMING_UPPER_4BITS_MARK) >> HDMI_NIBBLE_SHIFT); + perTiming->vSyncPluseWidth = + ((block->hsOffsetVsOffset & HDMI_EDID_DETAILED_TIMING_VS_PULSE_WIDTH_MARK) << HDMI_NIBBLE_SHIFT) | + (block->vsOffesetPulseWidth & HDMI_EDID_DETAILED_TIMING_LOWER_4BITS_MARK); + + perTiming->imageWidth = (block->hImageSize) | + ((block->hvImageSize & HDMI_EDID_DETAILED_TIMING_UPPER_4BITS_MARK) << HDMI_NIBBLE_SHIFT); + perTiming->imageHeight = (block->vImageSize) | + ((block->hvImageSize & HDMI_EDID_DETAILED_TIMING_LOWER_4BITS_MARK) << HDMI_ONE_BYTE_SHIFT); + perTiming->interlaceFlag = (block->flags & HDMI_BIT7_MARK) ? true : false; + /* Digital composite/separate */ + if ((block->flags & HDMI_BIT4_MARK) != 0) { + HdmiEdidDigitalSyncSignal(perTiming, block->flags); + } + cap->preTimingCnt++; +} + +static void HdmiEdidDetailedTiming(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint32_t len) +{ + /* + * Monitor Descriptor flag: data0/data1/data2 is 0x00. + */ + if (data[UINT8_ARRAY_TElEMENT_0] == 0x00 && + data[UINT8_ARRAY_TElEMENT_1] == 0x00 && + data[UINT8_ARRAY_TElEMENT_2] == 0x00) { + HdmiEdidMonitorDescriptorPhase(sinkCap, data, len); + return; + } + + /* + * Those 18-byte blocks not used for Monitor Descriptors shall be used for detailed timings. + */ + HdmiEdidDetailedTimingDescriptorPhase(sinkCap, data, len); +} + +static int32_t HdmiEdidDetailedTimingPhase(struct HdmiEdid *edid) +{ + struct HdmiSinkDeviceCapability *sinkCap = &(edid->sinkCap); + struct HdmiEdidFirstBlockInfo *block = (struct HdmiEdidFirstBlockInfo *)edid->raw; + + /* + * The detailed timing section is divided into four descriptor blocks, which are 18 bytes each. + * The first descriptor block shall be used to indicate the display's preferred timing mode. + * A Monitor Name Descriptor must be provided. + */ + HdmiEdidDetailedTiming(sinkCap, block->detailedTiming1, HDMI_EDID_DETAILED_TIMING_DESCRIPTOR_FIELD_LEN); + HdmiEdidDetailedTiming(sinkCap, block->detailedTiming2, HDMI_EDID_DETAILED_TIMING_DESCRIPTOR_FIELD_LEN); + HdmiEdidDetailedTiming(sinkCap, block->detailedTiming3, HDMI_EDID_DETAILED_TIMING_DESCRIPTOR_FIELD_LEN); + HdmiEdidDetailedTiming(sinkCap, block->detailedTiming4, HDMI_EDID_DETAILED_TIMING_DESCRIPTOR_FIELD_LEN); + return HDF_SUCCESS; +} + +static int32_t HdmiEdidExtBlockNumPhase(struct HdmiEdid *edid) +{ + struct HdmiSinkDeviceCapability *sinkCap = &(edid->sinkCap); + + sinkCap->extBlockNum = edid->raw[HDMI_EDID_EXTENSION_BLOCK_ADDR]; + HDF_LOGD("edid extBlockNum = %d.", sinkCap->extBlockNum); + if (sinkCap->extBlockNum > (HDMI_EDID_MAX_BLOCK_NUM - 1)) { + HDF_LOGW("ext block number %d is invallid.", sinkCap->extBlockNum); + sinkCap->extBlockNum = HDMI_EDID_MAX_BLOCK_NUM - 1; + } + return HDF_SUCCESS; +} + +static int32_t HdmiEdidFirstBlockPhase(struct HdmiEdid *edid) +{ + uint32_t i, len; + int32_t ret; + HdmiEdidPhaseFunc func[] = { + HdmiEdidHeaderPhase, + HdmiEdidVendorInfoPhase, + HdmiEdidVersionInfoPhase, + HdmiEdidBasicDispPhase, + HdmiEdidColorFeaturePhase, + HdmiEdidEstablisedTimingPhase, + HdmiEdidStandardTimingPhase, + HdmiEdidDetailedTimingPhase, + HdmiEdidExtBlockNumPhase + }; + + ret = HdmiEdidBlockCheckSum(edid->raw); + if (ret != HDF_SUCCESS) { + HDF_LOGE("edid block0 check sum fail."); + return ret; + } + + len = sizeof(func) / sizeof(func[UINT8_ARRAY_TElEMENT_0]); + for (i = 0; i < len; i++) { + if (func[i] == NULL) { + continue; + } + ret = (func[i])(edid); + if (ret != HDF_SUCCESS) { + HDF_LOGE("func[%d] exe fail.", i); + return ret; + } + } + return HDF_SUCCESS; +} + +static void HdmiEdidExtAdbSampleRatePhase(struct HdmiEdidAudioInfo *audio, uint8_t data, uint8_t formatCode) +{ + if ((data & HDMI_BIT0_MARK) > 0 && + audio->sampleRateNum < HDMI_EDID_EXTENSION_AUDIO_MAX_SAMPLE_RATE_NUM) { + audio->sampleRate[audio->sampleRateNum] = HDMI_SAMPLE_RATE_32K; + audio->sampleRateNum++; + } + if ((data & HDMI_BIT1_MARK) > 0 && + audio->sampleRateNum < HDMI_EDID_EXTENSION_AUDIO_MAX_SAMPLE_RATE_NUM) { + audio->sampleRate[audio->sampleRateNum] = HDMI_SAMPLE_RATE_44K; + audio->sampleRateNum++; + } + if ((data & HDMI_BIT2_MARK) > 0 && + audio->sampleRateNum < HDMI_EDID_EXTENSION_AUDIO_MAX_SAMPLE_RATE_NUM) { + audio->sampleRate[audio->sampleRateNum] = HDMI_SAMPLE_RATE_48K; + audio->sampleRateNum++; + } + if ((data & HDMI_BIT3_MARK) > 0 && + audio->sampleRateNum < HDMI_EDID_EXTENSION_AUDIO_MAX_SAMPLE_RATE_NUM) { + audio->sampleRate[audio->sampleRateNum] = HDMI_SAMPLE_RATE_88K; + audio->sampleRateNum++; + } + if ((data & HDMI_BIT4_MARK) > 0 && + audio->sampleRateNum < HDMI_EDID_EXTENSION_AUDIO_MAX_SAMPLE_RATE_NUM) { + audio->sampleRate[audio->sampleRateNum] = HDMI_SAMPLE_RATE_96K; + audio->sampleRateNum++; + } + + if (formatCode >= HDMI_AUDIO_CODING_TYPE_LPCM && formatCode <= HDMI_AUDIO_CODING_TYPE_WMA_PRO) { + if ((data & HDMI_BIT5_MARK) > 0 && + audio->sampleRateNum < HDMI_EDID_EXTENSION_AUDIO_MAX_SAMPLE_RATE_NUM) { + audio->sampleRate[audio->sampleRateNum] = HDMI_SAMPLE_RATE_176K; + audio->sampleRateNum++; + } + if ((data & HDMI_BIT6_MARK) > 0 && + audio->sampleRateNum < HDMI_EDID_EXTENSION_AUDIO_MAX_SAMPLE_RATE_NUM) { + audio->sampleRate[audio->sampleRateNum] = HDMI_SAMPLE_RATE_192K; + audio->sampleRateNum++; + } + } +} + +static void HdmiEdidExtAdbDepthAndMaxRatePhase(struct HdmiEdidAudioInfo *audio, uint8_t data, uint8_t formatCode) +{ + /* + * Audio Format Code is 1, bit[2:0] bit depth; + * Audio Format Codes 2 to 8, Maximum bit rate divided by 8 kHz. + */ + if (formatCode == HDMI_AUDIO_CODING_TYPE_LPCM) { + if ((data & HDMI_BIT0_MARK) > 0 && + audio->bitDepthNum < HDMI_EDID_EXTENSION_AUDIO_MAX_BIT_DEPTH_NUM) { + audio->bitDepth[audio->bitDepthNum] = HDMI_ADIO_BIT_DEPTH_16; + audio->bitDepthNum++; + } + if ((data & HDMI_BIT1_MARK) > 0 && + audio->bitDepthNum < HDMI_EDID_EXTENSION_AUDIO_MAX_BIT_DEPTH_NUM) { + audio->bitDepth[audio->bitDepthNum] = HDMI_ADIO_BIT_DEPTH_20; + audio->bitDepthNum++; + } + if ((data & HDMI_BIT2_MARK) > 0 && + audio->bitDepthNum < HDMI_EDID_EXTENSION_AUDIO_MAX_BIT_DEPTH_NUM) { + audio->bitDepth[audio->bitDepthNum] = HDMI_ADIO_BIT_DEPTH_24; + audio->bitDepthNum++; + } + } else if (formatCode >= HDMI_AUDIO_CODING_TYPE_AC3 && formatCode <= HDMI_AUDIO_CODING_TYPE_ATRAC) { + audio->maxBitRate = data * HDMI_EDID_EXTENSION_AUDIO_BIT_RATE_FACTOR; + } else { + HDF_LOGI("formatCode %d reserved or not care", formatCode); + } +} + +static int32_t HdmiEdidExtAudioDataBlockPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len) +{ + uint8_t i, formatCode; + + /* + * Each Short Audio Descriptor is 3-bytes long. There can be up to 31 bytes following any tag, + * therefore there may be up to 10 Short Audio Descriptors in the Audio Data Block (ADB). + */ + if (len > (HDMI_EDID_EXTENSION_SHORT_AUDIO_DESCRIPTOR_LEN * HDMI_EDID_EXTENSION_MAX_SHORT_AUDIO_DESCRIPTOR_NUM)) { + HDF_LOGE("ADB: len %d is invalid", len); + return HDF_ERR_INVALID_PARAM; + } + + for (i = 0; i < (len / HDMI_EDID_EXTENSION_SHORT_AUDIO_DESCRIPTOR_LEN); i++) { + if (sinkCap->audioInfoCnt >= HDMI_EDID_EXTENSION_AUDIO_CAP_COUNT) { + HDF_LOGE("ADB: info cnt reach the maximum"); + break; + } + data += (i * HDMI_EDID_EXTENSION_SHORT_AUDIO_DESCRIPTOR_LEN); + /* byte0: bit[6:3] Audio Format Code; bit[2:0] Max Number of channels - 1 */ + formatCode = (data[UINT8_ARRAY_TElEMENT_0] & HDMI_EDID_EXTENSION_AUDIO_FORMAT_CODE_MARK) >> + HDMI_EDID_EXTENSION_AUDIO_FORMAT_CODE_SHIFT; + sinkCap->audioInfo[sinkCap->audioInfoCnt].formatCode = (enum HdmiAudioCodingType)formatCode; + sinkCap->audioInfo[sinkCap->audioInfoCnt].channels = + (data[UINT8_ARRAY_TElEMENT_0] & HDMI_EDID_EXTENSION_AUDIO_MAX_CHANNEL_MARK) + 1; + /* byte1: Sample Rate */ + HdmiEdidExtAdbSampleRatePhase(&(sinkCap->audioInfo[sinkCap->audioInfoCnt]), + data[UINT8_ARRAY_TElEMENT_1], + formatCode); + /* byte2: bit depth or maximum bit rate */ + HdmiEdidExtAdbDepthAndMaxRatePhase(&(sinkCap->audioInfo[sinkCap->audioInfoCnt]), + data[UINT8_ARRAY_TElEMENT_2], + formatCode); + sinkCap->audioInfoCnt++; + } + return HDF_SUCCESS; +} + +static int32_t HdmiEdidExtVideoDataBlockPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len) +{ + uint8_t i; + uint32_t vicAll, vicLower; + uint32_t implicitNative = 0; + + for (i = 0; i < len; i++) { + if (sinkCap->videoInfo.vicNum >= HDMI_EDID_EXTENSION_MAX_VIC_COUNT) { + HDF_LOGD("VDB: vicNum reach the maximum"); + break; + } + vicAll = data[i]; + vicLower = (vicAll & HDMI_EDID_EXTENSION_VIC_LOWER7_MARK); + if (vicAll == 0) { + continue; + } + /* + * For VICs 1 through 64, the lower 7-bits are an index associated with the Video Format supported. + * The most significant bit declares whether the format is a Native Video Format of the + * display (native =1, not native = 0). Typically, there is a single SVD, with its native bit set. + */ + if ((vicAll & HDMI_BIT7_MARK) > 0 && vicLower < HDMI_EDID_EXTENSION_VIC_NATIVE_MAX) { + if (sinkCap->videoInfo.nativeFormat == 0) { + sinkCap->videoInfo.nativeFormat = vicLower; + } + } + /* set the first valid vic as implicit native */ + if (implicitNative == 0) { + implicitNative = vicAll; + } + if ((vicAll & HDMI_BIT7_MARK) > 0 && vicLower < HDMI_EDID_EXTENSION_VIC_NATIVE_MAX) { + sinkCap->videoInfo.vic[sinkCap->videoInfo.vicNum] = vicLower; + } else { + sinkCap->videoInfo.vic[sinkCap->videoInfo.vicNum] = vicAll; + } + sinkCap->videoInfo.vicNum++; + } + + if (sinkCap->videoInfo.nativeFormat == 0) { + sinkCap->videoInfo.nativeFormat = implicitNative; + } + return HDF_SUCCESS; +} + +static void HdmiEdidVsdbCecPhyAddrPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len) +{ + if (len >= 5) { + sinkCap->vsdbInfo.cecAddr.phyAddrA = (data[UINT8_ARRAY_TElEMENT_3] & HDMI_UPPER_NIBBLE_MARK) >> + HDMI_NIBBLE_SHIFT; + sinkCap->vsdbInfo.cecAddr.phyAddrB = (data[UINT8_ARRAY_TElEMENT_3] & HDMI_LOWER_NIBBLE_MARK); + sinkCap->vsdbInfo.cecAddr.phyAddrC = (data[UINT8_ARRAY_TElEMENT_4] & HDMI_UPPER_NIBBLE_MARK) >> + HDMI_NIBBLE_SHIFT; + sinkCap->vsdbInfo.cecAddr.phyAddrD = (data[UINT8_ARRAY_TElEMENT_4] & HDMI_LOWER_NIBBLE_MARK); + sinkCap->vsdbInfo.cecAddr.addrValid = + (sinkCap->vsdbInfo.cecAddr.phyAddrA != HDMI_EDID_EXTENSION_VSDB_CEC_INVALID_ADDR) && + (sinkCap->vsdbInfo.cecAddr.phyAddrB != HDMI_EDID_EXTENSION_VSDB_CEC_INVALID_ADDR) && + (sinkCap->vsdbInfo.cecAddr.phyAddrC != HDMI_EDID_EXTENSION_VSDB_CEC_INVALID_ADDR) && + (sinkCap->vsdbInfo.cecAddr.phyAddrD != HDMI_EDID_EXTENSION_VSDB_CEC_INVALID_ADDR); + } +} + +static void HdmiEdidVsdbColorDepthPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len) +{ + if (len >= 6) { + sinkCap->vsdbInfo.supportAi = (data[UINT8_ARRAY_TElEMENT_5] & HDMI_BIT7_MARK) ? true : false; + sinkCap->vsdbInfo.supportDviDual = (data[UINT8_ARRAY_TElEMENT_5] & HDMI_BIT0_MARK) ? true : false; + sinkCap->vsdbInfo.deepColor.dcY444 = (data[UINT8_ARRAY_TElEMENT_5] & HDMI_BIT3_MARK) ? true : false; + sinkCap->vsdbInfo.deepColor.dc30bit = (data[UINT8_ARRAY_TElEMENT_5] & HDMI_BIT4_MARK) ? true : false; + sinkCap->vsdbInfo.deepColor.dc36bit = (data[UINT8_ARRAY_TElEMENT_5] & HDMI_BIT5_MARK) ? true : false; + sinkCap->vsdbInfo.deepColor.dc48bit = (data[UINT8_ARRAY_TElEMENT_5] & HDMI_BIT6_MARK) ? true : false; + } +} + +static void HdmiEdidVsdbMaxTmdsClockPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len) +{ + /* + * This field shall be set cprrectly and non-zero if the sink support TMDS clock frequencies above 165MHz or + * supports ant Deep Color mode or supports DVI dual-link. A value of zeor means that no clock rate is indicated. + */ + if (len >= 7) { + sinkCap->maxTmdsClk = data[UINT8_ARRAY_TElEMENT_6] * HDMI_EDID_EXTENSION_TMDS_FACTOR; + sinkCap->supportHdmi20 = (sinkCap->maxTmdsClk > HDMI_EDID_EXTENSION_MAX_HDMI14_TMDS_RATE) ? true : false; + } +} + +static void HdmiEdidVsdbSinkPresentPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len) +{ + if (len >= 8) { + sinkCap->vsdbInfo.latencyFieldsPresent = (data[UINT8_ARRAY_TElEMENT_7] & HDMI_BIT7_MARK) ? true : false; + sinkCap->vsdbInfo.iLatencyFieldsPresent = (data[UINT8_ARRAY_TElEMENT_7] & HDMI_BIT6_MARK) ? true : false; + sinkCap->vsdbInfo.hdmiVideoPresent = (data[UINT8_ARRAY_TElEMENT_7] & HDMI_BIT5_MARK) ? true : false; + } +} + +static void HdmiEdidVsdbSinkLatencyPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len) +{ + if (sinkCap->vsdbInfo.latencyFieldsPresent == true) { + if (len >= 9) { + sinkCap->vsdbInfo.videoLatency = data[UINT8_ARRAY_TElEMENT_8]; + } + if (len >= 10) { + sinkCap->vsdbInfo.videoLatency = data[UINT8_ARRAY_TElEMENT_9]; + } + } + if (sinkCap->vsdbInfo.iLatencyFieldsPresent == true) { + if (len >= 11) { + sinkCap->vsdbInfo.interlacedVideoLatency = data[UINT8_ARRAY_TElEMENT_10]; + } + if (len >= 12) { + sinkCap->vsdbInfo.interlacedAudioLatency = data[UINT8_ARRAY_TElEMENT_11]; + } + } +} + +static void HdmiEdidVsdbVicInfoPhase(struct HdmiSinkDeviceCapability *sinkCap, + uint8_t *data, uint8_t vicLen, uint8_t *offset) +{ + uint8_t i, index; + /* see hdmi spec 1.4 table 8-13. */ + uint32_t hdmi4kVic[] = { + 0, + HDMI_VIC_3840X2160P30_16_9, + HDMI_VIC_3840X2160P25_16_9, + HDMI_VIC_3840X2160P24_16_9, + HDMI_VIC_4096X2160P24_256_135 + }; + + for (i = 0; i < vicLen; i++) { + if (sinkCap->videoInfo.vicNum >= HDMI_EDID_EXTENSION_MAX_VIC_COUNT) { + break; + } + index = data[(*offset)]; + if (index != 0 && index < sizeof(hdmi4kVic) / sizeof(hdmi4kVic[UINT8_ARRAY_TElEMENT_0])) { + sinkCap->videoInfo.vic[sinkCap->videoInfo.vicNum] = hdmi4kVic[index]; + sinkCap->videoInfo.vicNum++; + } + (*offset)++; + } +} + +static void HdmiEdidVsdb3dStructureInfoPhase(struct HdmiSinkDeviceCapability *sinkCap, + uint8_t *data, uint8_t len, uint8_t *offset) +{ + /* + * If 3D_Multi_present is 1 or 2, 3D_Struct_ALL_15...0 is present and assigns 3D formats to + * all of the VICs listed in the first 16 entries in the EDID. + */ + if (((sinkCap->vsdbInfo._3dMultiPresent) & HDMI_EDID_EXTENSION_VSDB_3D_STR_INVALID_MARK) == 0) { + return; + } + /* see hdmi spec 1.4 table H-8. */ + if ((*offset) <= len) { + /* + * bit[15:9]: reserved. + * bit8: sinks support "Side-by-side(half) with all sub-sampling methods" 3D formats. + */ + sinkCap->vsdbInfo.support3dType[HDMI_VS_VIDEO_3D_SIDE_BY_SIDE_HALF] = + (data[(*offset)] & HDMI_BIT0_MARK) ? true : false; + (*offset)++; + } + + if ((*offset) <= len) { + sinkCap->vsdbInfo.support3dType[HDMI_VS_VIDEO_3D_FRAME_PACKING] = + (data[(*offset)] & HDMI_BIT0_MARK) ? true : false; + sinkCap->vsdbInfo.support3dType[HDMI_VS_VIDEO_3D_FIELD_ALTERNATIVE] = + (data[(*offset)] & HDMI_BIT1_MARK) ? true : false; + sinkCap->vsdbInfo.support3dType[HDMI_VS_VIDEO_3D_LINE_ALTERNATIVE] = + (data[(*offset)] & HDMI_BIT2_MARK) ? true : false; + sinkCap->vsdbInfo.support3dType[HDMI_VS_VIDEO_3D_SIDE_BY_SIDE_FULL] = + (data[(*offset)] & HDMI_BIT3_MARK) ? true : false; + sinkCap->vsdbInfo.support3dType[HDMI_VS_VIDEO_3D_L_DEPTH] = + (data[(*offset)] & HDMI_BIT4_MARK) ? true : false; + sinkCap->vsdbInfo.support3dType[HDMI_VS_VIDEO_3D_L_DEPTH_GFX_GFX_DEPTH] = + (data[(*offset)] & HDMI_BIT5_MARK) ? true : false; + sinkCap->vsdbInfo.support3dType[HDMI_VS_VIDEO_3D_TOP_AND_BOTTOM] = + (data[(*offset)] & HDMI_BIT6_MARK) ? true : false; + (*offset)++; + } +} + +static void HdmiEdidVsdbVicAnd3dInfoPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len) +{ + uint8_t hdmiVicLen = 0; + uint8_t hdmi3dLen = 0; + uint8_t offset; + + if (len < 13) { + HDF_LOGD("vsdb: these is no vic/3d field."); + return; + } + sinkCap->vsdbInfo._3dPresent = (data[UINT8_ARRAY_TElEMENT_12] & HDMI_BIT7_MARK) ? true : false; + sinkCap->vsdbInfo._3dMultiPresent = (data[UINT8_ARRAY_TElEMENT_12] & + HDMI_EDID_EXTENSION_VSDB_3D_MULTI_PRESENT_MARK) >> + HDMI_EDID_EXTENSION_VSDB_3D_MULTI_PRESENT_SHIFT; + + if (len >= 14) { + hdmiVicLen = (data[UINT8_ARRAY_TElEMENT_13] & + HDMI_EDID_EXTENSION_VSDB_VIC_LEN_MARK) >> + HDMI_EDID_EXTENSION_VSDB_VIC_LEN_SHIFT; + hdmi3dLen = (data[UINT8_ARRAY_TElEMENT_13] & HDMI_EDID_EXTENSION_VSDB_3D_LEN_MARK); + } + + /* byte14~byteN: Vic info/3D info */ + offset = 14; + if (hdmiVicLen > 0 && (hdmiVicLen + offset + 1) <= len) { + HdmiEdidVsdbVicInfoPhase(sinkCap, data, hdmiVicLen, &offset); + } + + if (hdmi3dLen > 0 && + sinkCap->vsdbInfo._3dPresent == true && + (hdmi3dLen + offset + 1) <= len) { + HdmiEdidVsdb3dStructureInfoPhase(sinkCap, data, len, &offset); + } +} + +static int32_t HdmiEdidVsdbPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len) +{ + /* byte3 byte4: cec addr */ + if (len < 5) { + HDF_LOGD("vsdb: len = %d, too short.", len); + return HDF_SUCCESS; + } + HdmiEdidVsdbCecPhyAddrPhase(sinkCap, data, len); + /* byte 5: color depth flags */ + HdmiEdidVsdbColorDepthPhase(sinkCap, data, len); + /* byte 6: max tmds clock. */ + HdmiEdidVsdbMaxTmdsClockPhase(sinkCap, data, len); + /* byte7: some sink present */ + HdmiEdidVsdbSinkPresentPhase(sinkCap, data, len); + /* + * byte8: Video_Latency + * byte9: Audio_Latency + * byte10: Interlaced_Video_Latency + * byte11: Interlaced_Audio_Latency + */ + HdmiEdidVsdbSinkLatencyPhase(sinkCap, data, len); + /* + * byte12: 3D_Present, 3D_Multi_present + * byte13: HDMI_VIC_LEN/HDMI_3D_LEN + * byte14~byteN: Vic info/3D info + */ + HdmiEdidVsdbVicAnd3dInfoPhase(sinkCap, data, len); + return HDF_SUCCESS; +} + +static void HdmiEdidHfVsdb21Phase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len) +{ + sinkCap->hfVsdbInfo.maxFrlRate = (data[UINT8_ARRAY_TElEMENT_6] & HDMI_UPPER_NIBBLE_MARK) >> HDMI_NIBBLE_SHIFT; + + sinkCap->hfVsdbInfo.fapaStartLocation = (data[UINT8_ARRAY_TElEMENT_7] & HDMI_BIT0_MARK) ? true : false; + sinkCap->hfVsdbInfo.allm = (data[UINT8_ARRAY_TElEMENT_7] & HDMI_BIT1_MARK) ? true : false; + sinkCap->hfVsdbInfo.fva = (data[UINT8_ARRAY_TElEMENT_7] & HDMI_BIT2_MARK) ? true : false; + sinkCap->hfVsdbInfo.cnmVrr = (data[UINT8_ARRAY_TElEMENT_7] & HDMI_BIT3_MARK) ? true : false; + sinkCap->hfVsdbInfo.cinemaVrr = (data[UINT8_ARRAY_TElEMENT_7] & HDMI_BIT4_MARK) ? true : false; + sinkCap->hfVsdbInfo.mDelta = (data[UINT8_ARRAY_TElEMENT_7] & HDMI_BIT5_MARK) ? true : false; + sinkCap->hfVsdbInfo.vrrMin = (data[UINT8_ARRAY_TElEMENT_8] & 0x3F); + sinkCap->hfVsdbInfo.vrrMax = ((data[UINT8_ARRAY_TElEMENT_8] & 0xC0) << 2) | data[UINT8_ARRAY_TElEMENT_9]; + + sinkCap->hfVsdbInfo.dscInfo.dsc1p2 = (data[UINT8_ARRAY_TElEMENT_10] & HDMI_BIT7_MARK) ? true : false; + sinkCap->hfVsdbInfo.dscInfo.dscNative420 = (data[UINT8_ARRAY_TElEMENT_10] & HDMI_BIT6_MARK) ? true : false; + sinkCap->hfVsdbInfo.dscInfo.dscAllBpp = (data[UINT8_ARRAY_TElEMENT_10] & HDMI_BIT3_MARK) ? true : false; + sinkCap->hfVsdbInfo.dscInfo.dsc10bpc = (data[UINT8_ARRAY_TElEMENT_10] & HDMI_BIT2_MARK) ? true : false; + sinkCap->hfVsdbInfo.dscInfo.dsc20bpc = (data[UINT8_ARRAY_TElEMENT_10] & HDMI_BIT1_MARK) ? true : false; + sinkCap->hfVsdbInfo.dscInfo.dsc16bpc = (data[UINT8_ARRAY_TElEMENT_10] & HDMI_BIT0_MARK) ? true : false; + sinkCap->hfVsdbInfo.dscInfo.dscMaxSlices = (data[UINT8_ARRAY_TElEMENT_11] & HDMI_LOWER_NIBBLE_MARK); + sinkCap->hfVsdbInfo.dscInfo.dscMaxFrlRate = (data[UINT8_ARRAY_TElEMENT_11] & HDMI_UPPER_NIBBLE_MARK) >> + HDMI_NIBBLE_SHIFT; + sinkCap->hfVsdbInfo.dscInfo.dscTotalChunkKBytes = (data[UINT8_ARRAY_TElEMENT_12] & 0x3F); +} + +static int32_t HdmiEdidHfVsdbPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len) +{ + if (len < HDMI_EDID_EXTENSION_HFVSDB_MIN_INVALID_LEN) { + HDF_LOGD("vsdb: data len %d is too short.", len); + return HDF_SUCCESS; + } + + /* byte3: Version */ + if (data[UINT8_ARRAY_TElEMENT_3] != HDMI_EDID_EXTENSION_HFVSDB_VERSION) { + HDF_LOGD("vsdb: verdion %d is invalid.", data[UINT8_ARRAY_TElEMENT_3]); + } + /* byte4: Max_TMDS_Character_Rate */ + sinkCap->maxTmdsClk = data[UINT8_ARRAY_TElEMENT_4] * HDMI_EDID_EXTENSION_TMDS_FACTOR; + sinkCap->supportHdmi20 = (sinkCap->maxTmdsClk > HDMI_EDID_EXTENSION_MAX_HDMI14_TMDS_RATE) ? true : false; + /* byte5: several sink present */ + sinkCap->hfVsdbInfo.scdcPresent = (data[UINT8_ARRAY_TElEMENT_5] & HDMI_BIT7_MARK) ? true : false; + sinkCap->hfVsdbInfo.rrCapable = (data[UINT8_ARRAY_TElEMENT_5] & HDMI_BIT6_MARK) ? true : false; + sinkCap->hfVsdbInfo.lte340McscScramble = (data[UINT8_ARRAY_TElEMENT_5] & HDMI_BIT3_MARK) ? true : false; + sinkCap->hfVsdbInfo.independentView = (data[UINT8_ARRAY_TElEMENT_5] & HDMI_BIT2_MARK) ? true : false; + sinkCap->hfVsdbInfo.dualView = (data[UINT8_ARRAY_TElEMENT_5] & HDMI_BIT1_MARK) ? true : false; + sinkCap->hfVsdbInfo._3dOsdDisparity = (data[UINT8_ARRAY_TElEMENT_5] & HDMI_BIT0_MARK) ? true : false; + /* byte6: deep color */ + sinkCap->hfVsdbInfo.dc.dc30bit = (data[UINT8_ARRAY_TElEMENT_6] & HDMI_BIT0_MARK) ? true : false; + sinkCap->hfVsdbInfo.dc.dc36bit = (data[UINT8_ARRAY_TElEMENT_6] & HDMI_BIT1_MARK) ? true : false; + sinkCap->hfVsdbInfo.dc.dc48bit = (data[UINT8_ARRAY_TElEMENT_6] & HDMI_BIT2_MARK) ? true : false; + if (len > HDMI_EDID_EXTENSION_HFVSDB_MIN_INVALID_LEN && + len <= HDMI_EDID_EXTENSION_HFVSDB_MAX_INVALID_LEN) { + HdmiEdidHfVsdb21Phase(sinkCap, data, len); + } + return HDF_SUCCESS; +} + +static int32_t HdmiEdidExtVsDataBlockPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len) +{ + int32_t ret = HDF_SUCCESS; + bool vsdb = false; + bool hfVsdb = false; + + if (len >= HDMI_EDID_EXTENSION_VSDB_LEN && + data[UINT8_ARRAY_TElEMENT_0] == HDMI_EDID_EXTENSION_VSDB_IEEE_1ST && + data[UINT8_ARRAY_TElEMENT_1] == HDMI_EDID_EXTENSION_VSDB_IEEE_2ND && + data[UINT8_ARRAY_TElEMENT_2] == HDMI_EDID_EXTENSION_VSDB_IEEE_3RD) { + vsdb = true; + } + + if (len >= HDMI_EDID_EXTENSION_VSDB_LEN && + data[UINT8_ARRAY_TElEMENT_0] == HDMI_EDID_EXTENSION_HFVSDB_IEEE_1ST && + data[UINT8_ARRAY_TElEMENT_1] == HDMI_EDID_EXTENSION_HFVSDB_IEEE_2ND && + data[UINT8_ARRAY_TElEMENT_2] == HDMI_EDID_EXTENSION_HFVSDB_IEEE_3RD) { + hfVsdb = true; + } + + if (vsdb == true) { + sinkCap->supportHdmi14 = true; + ret = HdmiEdidVsdbPhase(sinkCap, data, len); + } else if (hfVsdb == true) { + ret = HdmiEdidHfVsdbPhase(sinkCap, data, len); + } + return ret; +} + +static int32_t HdmiEdidExtSpeakerDataBlockPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len) +{ + if (len < HDMI_EDID_EXTENSION_SADB_MIN_INVALID_LEN) { + HDF_LOGD("SADB: len %d is too short", len); + return HDF_SUCCESS; + } + + sinkCap->supportAudioSpeaker[HDMI_EDID_AUDIO_SPEAKER_FL_FR] = + (data[UINT8_ARRAY_TElEMENT_0] & HDMI_BIT0_MARK) ? true : false; + sinkCap->supportAudioSpeaker[HDMI_EDID_AUDIO_SPEAKER_LFE] = + (data[UINT8_ARRAY_TElEMENT_0] & HDMI_BIT1_MARK) ? true : false; + sinkCap->supportAudioSpeaker[HDMI_EDID_AUDIO_SPEAKER_FC] = + (data[UINT8_ARRAY_TElEMENT_0] & HDMI_BIT2_MARK) ? true : false; + sinkCap->supportAudioSpeaker[HDMI_EDID_AUDIO_SPEAKER_BL_BR] = + (data[UINT8_ARRAY_TElEMENT_0] & HDMI_BIT3_MARK) ? true : false; + sinkCap->supportAudioSpeaker[HDMI_EDID_AUDIO_SPEAKER_BC] = + (data[UINT8_ARRAY_TElEMENT_0] & HDMI_BIT4_MARK) ? true : false; + sinkCap->supportAudioSpeaker[HDMI_EDID_AUDIO_SPEAKER_FLC_FRC] = + (data[UINT8_ARRAY_TElEMENT_0] & HDMI_BIT5_MARK) ? true : false; + sinkCap->supportAudioSpeaker[HDMI_EDID_AUDIO_SPEAKER_RLC_RRC] = + (data[UINT8_ARRAY_TElEMENT_0] & HDMI_BIT6_MARK) ? true : false; + sinkCap->supportAudioSpeaker[HDMI_EDID_AUDIO_SPEAKER_FLW_FRW] = + (data[UINT8_ARRAY_TElEMENT_0] & HDMI_BIT7_MARK) ? true : false; + sinkCap->supportAudioSpeaker[HDMI_EDID_AUDIO_SPEAKER_TPFL_TPFH] = + (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT0_MARK) ? true : false; + sinkCap->supportAudioSpeaker[HDMI_EDID_AUDIO_SPEAKER_TPC] = + (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT1_MARK) ? true : false; + sinkCap->supportAudioSpeaker[HDMI_EDID_AUDIO_SPEAKER_TPFC] = + (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT2_MARK) ? true : false; + return HDF_SUCCESS; +} + +static void HdmiEdidExtUseExtDataBlockVcdbPhase(struct HdmiSinkDeviceCapability *sinkCap, + uint8_t *data, uint8_t len) +{ + if (len < HDMI_EDID_VCDB_LEN) { + HDF_LOGD("VCDB: len is too short"); + return; + } + + sinkCap->videoCap.qy = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT7_MARK) ? true : false; + sinkCap->videoCap.qs = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT6_MARK) ? true : false; +} + +static void HdmiEdidExtUseExtDataBlockCdbPhase(struct HdmiSinkDeviceCapability *sinkCap, + uint8_t *data, uint8_t len) +{ + if (len < HDMI_EDID_CDB_LEN) { + HDF_LOGD("CDB: len is too short"); + return; + } + + sinkCap->colorimetry.xvYcc601 = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT0_MARK) ? true : false; + sinkCap->colorimetry.xvYcc709 = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT1_MARK) ? true : false; + sinkCap->colorimetry.sYcc601 = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT2_MARK) ? true : false; + sinkCap->colorimetry.opYcc601 = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT3_MARK) ? true : false; + sinkCap->colorimetry.opRgb = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT4_MARK) ? true : false; + sinkCap->colorimetry.bt2020cYcc = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT5_MARK) ? true : false; + sinkCap->colorimetry.bt2020Ycc = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT6_MARK) ? true : false; + sinkCap->colorimetry.bt2020Rgb = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT7_MARK) ? true : false; + + sinkCap->colorimetry.dciP3 = (data[UINT8_ARRAY_TElEMENT_2] & HDMI_BIT7_MARK) ? true : false; + sinkCap->colorimetry.md = (data[UINT8_ARRAY_TElEMENT_2] & HDMI_LOWER_NIBBLE_MARK); +} + +static void HdmiEdidExtUseExtDataBlockY420VdbPhase(struct HdmiSinkDeviceCapability *sinkCap, + uint8_t *data, uint8_t len) +{ + uint8_t i; + uint32_t vic; + + for (i = 1; i < len; i++) { + if (sinkCap->y420Cap.onlySupportY420VicNum >= HDMI_EDID_EXTENSION_MAX_VIC_COUNT) { + HDF_LOGD("Y420Vdb: vic num reach to max."); + break; + } + vic = data[i]; + if (vic == 0 || + (vic >= HDMI_EDID_EXTENSION_VIC_INVALID_LOW && vic <= HDMI_EDID_EXTENSION_VIC_INVALID_HIGH)) { + continue; + } + sinkCap->y420Cap.onlySupportY420Format[sinkCap->y420Cap.onlySupportY420VicNum] = vic; + sinkCap->y420Cap.onlySupportY420VicNum++; + sinkCap->colorSpace.ycbcr420 = true; + } +} + +static void HdmiEdidExtUseExtDataBlockY420CmdbPhase(struct HdmiSinkDeviceCapability *sinkCap, + uint8_t *data, uint8_t len) +{ + uint32_t i, loop; + + /* + * When the Length field is set to 1, the Y420CMDB does not include a YCBCR 4:2:0 Capability Bit Map and + * all the SVDs in the regular Video Data Block(s) support YCBCR 4:2:0 sampling mode. + */ + if (len == 1) { + for (i = 0; (i < sinkCap->videoInfo.vicNum) && (i < HDMI_EDID_EXTENSION_MAX_VIC_COUNT); i++) { + if (sinkCap->y420Cap.SupportY420VicNum >= HDMI_EDID_EXTENSION_MAX_VIC_COUNT) { + break; + } + sinkCap->y420Cap.SupportY420Format[sinkCap->y420Cap.SupportY420VicNum] = sinkCap->videoInfo.vic[i]; + sinkCap->y420Cap.SupportY420VicNum++; + sinkCap->colorSpace.ycbcr420 = true; + } + return; + } + + /* + * Bit 0 of data byte 3 is associated with the first sequential SVD listed in the regular Video Data Block(s) + * of the EDID, bit 1 the second SVD, bit 2 the third, and so on. + */ + loop = len * HDMI_BITS_OF_ONE_BYTE; + loop = (loop > HDMI_EDID_EXTENSION_MAX_VIC_COUNT) ? HDMI_EDID_EXTENSION_MAX_VIC_COUNT : loop; + data++; + for (i = 0; (i < loop) && (i < sinkCap->videoInfo.vicNum); i++) { + if (sinkCap->y420Cap.SupportY420VicNum >= HDMI_EDID_EXTENSION_MAX_VIC_COUNT) { + break; + } + if ((data[i / HDMI_BITS_OF_ONE_BYTE] & (0x01 << (i % HDMI_BITS_OF_ONE_BYTE))) > 0) { + sinkCap->y420Cap.SupportY420Format[sinkCap->y420Cap.SupportY420VicNum] = sinkCap->videoInfo.vic[i]; + sinkCap->y420Cap.SupportY420VicNum++; + sinkCap->colorSpace.ycbcr420 = true; + } + } +} + +static void HdmiEdidExtUseExtDataBlockHdrSmdbPhase(struct HdmiSinkDeviceCapability *sinkCap, + uint8_t *data, uint8_t len) +{ + if (len < HDMI_EDID_HDR_SMDB_MIN_LEN) { + HDF_LOGD("Hdr SMDB: len is too short"); + return; + } + + sinkCap->hdrCap.eotf.sdr = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT0_MARK) ? true : false; + sinkCap->hdrCap.eotf.hdr = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT1_MARK) ? true : false; + sinkCap->hdrCap.eotf.smpteSt2048 = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT2_MARK) ? true : false; + sinkCap->hdrCap.eotf.hlg = (data[UINT8_ARRAY_TElEMENT_1] & HDMI_BIT2_MARK) ? true : false; + sinkCap->hdrCap.smType1 = (data[UINT8_ARRAY_TElEMENT_2] & HDMI_BIT0_MARK) ? true : false; + + /* + * The length of the data block, n, in Byte 1 indicates which of the Bytes 5 to 7 are present. Bytes 5 to 7 are + * optional to declare. When n is 3, Bytes 5 to 7 are not present. When n is 4, Byte 5 is present; when n is 5, + * Bytes 5 and 6 are present; and when n is 6, Bytes 5 to 7 are present. + */ + if (len >= 4) { + sinkCap->hdrCap.maxLuminancedata = data[UINT8_ARRAY_TElEMENT_3]; + } + if (len >= 5) { + sinkCap->hdrCap.maxFrameAverageLuminanceData = data[UINT8_ARRAY_TElEMENT_4]; + } + if (len >= 6) { + sinkCap->hdrCap.maxFrameAverageLuminanceData = data[UINT8_ARRAY_TElEMENT_5]; + } +} + +static void HdmiEdidDolbyCapVersionZeroPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data) +{ + sinkCap->dolbyCap.globalDimming = (data[UINT8_ARRAY_TElEMENT_4] & HDMI_BIT2_MARK) ? true : false; + sinkCap->dolbyCap.redX = ((data[UINT8_ARRAY_TElEMENT_5] & + HDMI_UPPER_NIBBLE_MARK) >> + HDMI_NIBBLE_SHIFT) | + (data[UINT8_ARRAY_TElEMENT_6] << HDMI_NIBBLE_SHIFT); + sinkCap->dolbyCap.redY = (data[UINT8_ARRAY_TElEMENT_5] & + HDMI_LOWER_NIBBLE_MARK) | + (data[UINT8_ARRAY_TElEMENT_7] << HDMI_NIBBLE_SHIFT); + sinkCap->dolbyCap.greenX = ((data[UINT8_ARRAY_TElEMENT_8] & HDMI_UPPER_NIBBLE_MARK) >> + HDMI_NIBBLE_SHIFT) | + (data[UINT8_ARRAY_TElEMENT_9] << HDMI_NIBBLE_SHIFT); + sinkCap->dolbyCap.greenY = (data[UINT8_ARRAY_TElEMENT_8] & + HDMI_LOWER_NIBBLE_MARK) | + (data[UINT8_ARRAY_TElEMENT_10] << HDMI_NIBBLE_SHIFT); + sinkCap->dolbyCap.blueX = ((data[UINT8_ARRAY_TElEMENT_11] & HDMI_UPPER_NIBBLE_MARK) >> + HDMI_NIBBLE_SHIFT) | + (data[UINT8_ARRAY_TElEMENT_12] << HDMI_NIBBLE_SHIFT); + sinkCap->dolbyCap.blueY = (data[UINT8_ARRAY_TElEMENT_11] & + HDMI_LOWER_NIBBLE_MARK) | + (data[UINT8_ARRAY_TElEMENT_13] << HDMI_NIBBLE_SHIFT); + sinkCap->dolbyCap.whiteX = ((data[UINT8_ARRAY_TElEMENT_14] & HDMI_UPPER_NIBBLE_MARK) >> + HDMI_NIBBLE_SHIFT) | + (data[UINT8_ARRAY_TElEMENT_15] << HDMI_NIBBLE_SHIFT); + sinkCap->dolbyCap.whiteY = (data[UINT8_ARRAY_TElEMENT_14] & HDMI_LOWER_NIBBLE_MARK) | + (data[UINT8_ARRAY_TElEMENT_16] << HDMI_NIBBLE_SHIFT); + sinkCap->dolbyCap.minLuminance = ((data[UINT8_ARRAY_TElEMENT_17] & HDMI_UPPER_NIBBLE_MARK) >> + HDMI_NIBBLE_SHIFT) | + (data[UINT8_ARRAY_TElEMENT_18] << HDMI_NIBBLE_SHIFT); + sinkCap->dolbyCap.maxLuminance = (data[UINT8_ARRAY_TElEMENT_17] & HDMI_LOWER_NIBBLE_MARK) | + (data[UINT8_ARRAY_TElEMENT_19] << HDMI_NIBBLE_SHIFT); + sinkCap->dolbyCap.dMajorVer = (data[UINT8_ARRAY_TElEMENT_20] & HDMI_UPPER_NIBBLE_MARK) >> + HDMI_NIBBLE_SHIFT; + sinkCap->dolbyCap.dMinorVer = (data[UINT8_ARRAY_TElEMENT_20] & HDMI_LOWER_NIBBLE_MARK); +} + +static void HdmiEdidDolbyCapVersionOnePhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data) +{ + sinkCap->dolbyCap.dmVer = (data[UINT8_ARRAY_TElEMENT_4] & HDMI_EDID_VSVDB_DOLBY_DM_VER_MARK) >> + HDMI_EDID_VSVDB_DOLBY_DM_VER_SHIFT; + sinkCap->dolbyCap.globalDimming = (data[UINT8_ARRAY_TElEMENT_5] & HDMI_BIT0_MARK) ? true : false; + sinkCap->dolbyCap.maxLuminance = ((data[UINT8_ARRAY_TElEMENT_5] >> 1) & HDMI_EDID_VSVDB_DOLBY_LOWER_7BIT_MARK); + sinkCap->dolbyCap.colorimetry = (data[UINT8_ARRAY_TElEMENT_6] & HDMI_BIT0_MARK) ? true : false; + sinkCap->dolbyCap.minLuminance = ((data[UINT8_ARRAY_TElEMENT_6] >> 1) & HDMI_EDID_VSVDB_DOLBY_LOWER_7BIT_MARK); + sinkCap->dolbyCap.redX = data[UINT8_ARRAY_TElEMENT_8]; + sinkCap->dolbyCap.redY = data[UINT8_ARRAY_TElEMENT_9]; + sinkCap->dolbyCap.greenX = data[UINT8_ARRAY_TElEMENT_10]; + sinkCap->dolbyCap.greenY = data[UINT8_ARRAY_TElEMENT_11]; + sinkCap->dolbyCap.blueX = data[UINT8_ARRAY_TElEMENT_12]; + sinkCap->dolbyCap.blueY = data[UINT8_ARRAY_TElEMENT_13]; +} + +static void HdmiEdidExtUseExtDataBlockVsvdbPhase(struct HdmiSinkDeviceCapability *sinkCap, + uint8_t *data, + uint8_t len) +{ + uint32_t oui; + + if (len != HDMI_EDID_VSVDB_DOLBY_VERSION_0_LEN && + len != HDMI_EDID_VSVDB_DOLBY_VERSION_1_LEN) { + HDF_LOGD("Vsvdb: invalid dolby len"); + return; + } + + oui = (data[UINT8_ARRAY_TElEMENT_1]) | (data[UINT8_ARRAY_TElEMENT_2] << 8) | (data[UINT8_ARRAY_TElEMENT_3] << 16); + if (oui != HDMI_EDID_VSVDB_DOLBY_OUI) { + return; + } + sinkCap->dolbyCap.oui = oui; + sinkCap->dolbyCap.version = (data[UINT8_ARRAY_TElEMENT_4] & + HDMI_EDID_VSVDB_DOLBY_VERSION_MARK) >> HDMI_EDID_VSVDB_DOLBY_VERSION_SHIFT; + sinkCap->dolbyCap.yuv422 = (data[UINT8_ARRAY_TElEMENT_4] & HDMI_BIT0_MARK) ? true : false; + sinkCap->dolbyCap.b2160p60 = (data[UINT8_ARRAY_TElEMENT_4] & HDMI_BIT1_MARK) ? true : false; + if (sinkCap->dolbyCap.version == HDMI_EDID_VSVDB_DOLBY_VERSION_0) { + HdmiEdidDolbyCapVersionZeroPhase(sinkCap, data); + return; + } + if (sinkCap->dolbyCap.version == HDMI_EDID_VSVDB_DOLBY_VERSION_1) { + HdmiEdidDolbyCapVersionOnePhase(sinkCap, data); + } +} + +static int32_t HdmiEdidExtUseExtDataBlockPhase(struct HdmiSinkDeviceCapability *sinkCap, uint8_t *data, uint8_t len) +{ + uint8_t extTagCode = data[UINT8_ARRAY_TElEMENT_0]; + + switch (extTagCode) { + case HDMI_EDID_EXT_VCDB: + HdmiEdidExtUseExtDataBlockVcdbPhase(sinkCap, data, len); + break; + case HDMI_EDID_EXT_VSVDB: + HdmiEdidExtUseExtDataBlockVsvdbPhase(sinkCap, data, len); + break; + case HDMI_EDID_EXT_CDB: + HdmiEdidExtUseExtDataBlockCdbPhase(sinkCap, data, len); + break; + case HDMI_EDID_EXT_HDR_SMDB: + HdmiEdidExtUseExtDataBlockHdrSmdbPhase(sinkCap, data, len); + break; + case HDMI_EDID_EXT_YCBCR420_VDB: + HdmiEdidExtUseExtDataBlockY420VdbPhase(sinkCap, data, len); + break; + case HDMI_EDID_EXT_YCBCR420_CMDB: + HdmiEdidExtUseExtDataBlockY420CmdbPhase(sinkCap, data, len); + break; + default: + HDF_LOGD("ext use ext DB: tag code %d unphase", extTagCode); + break; + } + return HDF_SUCCESS; +} + +static int32_t HdmiEdidExtDataBlockPhase(struct HdmiSinkDeviceCapability *sinkCap, + uint8_t *data, uint8_t len, uint8_t tag) +{ + int32_t ret = HDF_SUCCESS; + + if (len == 0) { + HDF_LOGD("ext DB: len is 0"); + return ret; + } + + switch (tag) { + case HDMI_EDID_AUDIO_DATA_BLOCK: + /* Audio Data Block (includes one or more Short Audio Descriptors) */ + ret = HdmiEdidExtAudioDataBlockPhase(sinkCap, data, len); + break; + case HDMI_EDID_VIDEO_DATA_BLOCK: + /* Video Data Block (includes one or more Short Video Descriptors) */ + ret = HdmiEdidExtVideoDataBlockPhase(sinkCap, data, len); + break; + case HDMI_EDID_VENDOR_SPECIFIC_DATA_BLOCK: + ret = HdmiEdidExtVsDataBlockPhase(sinkCap, data, len); + break; + case HDMI_EDID_SPEAKER_ALLOCATION_DATA_BLOCK: + ret = HdmiEdidExtSpeakerDataBlockPhase(sinkCap, data, len); + break; + case HDMI_EDID_USE_EXT_DATA_BLOCK: + ret = HdmiEdidExtUseExtDataBlockPhase(sinkCap, data, len); + break; + default: + HDF_LOGD("tag = %d is reserved or unphase block", tag); + break; + } + return ret; +} + +static void HdmiEdidExtSeveralDataBlockPhase(struct HdmiEdid *edid, uint8_t blockNum) +{ + uint8_t *data = edid->raw + (blockNum * HDMI_EDID_SINGLE_BLOCK_SIZE); + struct HdmiSinkDeviceCapability *sinkCap = &(edid->sinkCap); + uint8_t blkOffset = HDMI_EDID_EXTENSION_BLOCK_OFFSET; + uint8_t dtdOffset = data[UINT8_ARRAY_TElEMENT_2]; + uint8_t dbTagCode, blkLen; + int32_t ret; + + data += blkOffset; + /* phase data block */ + for (blkLen = 0; (blkOffset < dtdOffset) && (data != NULL); blkOffset += (blkLen + 1)) { + data += blkLen; + blkLen = (data[UINT8_ARRAY_TElEMENT_0] & HDMI_EDID_EXTENSION_DATA_BLOCK_LEN_MARK); + dbTagCode = (data[UINT8_ARRAY_TElEMENT_0] & HDMI_EDID_EXTENSION_DATA_BLOCK_TAG_CODE_MARK) >> + HDMI_EDID_EXTENSION_DATA_BLOCK_TAG_CODE_SHIFT; + data++; + ret = HdmiEdidExtDataBlockPhase(sinkCap, data, blkLen, dbTagCode); + if (ret != HDF_SUCCESS) { + HDF_LOGE("data block %d phase fail", dbTagCode); + return; + } + } + + data += blkLen; + /* phase detialed timing descriptors */ + while ((HDMI_EDID_SINGLE_BLOCK_SIZE - 1 - blkOffset) >= HDMI_EDID_DETAILED_TIMING_DESCRIPTOR_FIELD_LEN) { + HdmiEdidDetailedTiming(sinkCap, data, HDMI_EDID_DETAILED_TIMING_DESCRIPTOR_FIELD_LEN); + blkOffset += HDMI_EDID_DETAILED_TIMING_DESCRIPTOR_FIELD_LEN; + data += HDMI_EDID_DETAILED_TIMING_DESCRIPTOR_FIELD_LEN; + } +} + +static int32_t HdmiEdidExtBlockPhase(struct HdmiEdid *edid, uint8_t blockNum) +{ + uint8_t *data = edid->raw; + struct HdmiSinkDeviceCapability *sinkCap = &(edid->sinkCap); + int32_t ret; + + if (blockNum >= HDMI_EDID_MAX_BLOCK_NUM) { + HDF_LOGE("blockNum %d is invalid", blockNum); + return HDF_ERR_INVALID_PARAM; + } + + data += (blockNum * HDMI_EDID_SINGLE_BLOCK_SIZE); + ret = HdmiEdidBlockCheckSum(data); + if (ret != HDF_SUCCESS) { + HDF_LOGE("edid block%d check sum fail.", blockNum); + return ret; + } + + /* byte0: Extension Tag */ + if (data[UINT8_ARRAY_TElEMENT_0] != HDMI_EDID_CTA_EXTENSION_TAG) { + HDF_LOGD("ext tag is %d", data[UINT8_ARRAY_TElEMENT_0]); + } + /* byte1: Extension Revision Number */ + if (data[UINT8_ARRAY_TElEMENT_1] != HDMI_EDID_CTA_EXTENSION3_REVISION) { + HDF_LOGD("revision number is %d", data[UINT8_ARRAY_TElEMENT_1]); + } + /* + * byte2: Byte number offset d where 18-byte descriptors begin (typically Detailed Timing Descriptors). + * If no data is provided in the reserved data block, then d is 4. If d is 0, then no detailed timing + * descriptors are provided and no data is provided in the reserved data block collection. + */ + if (data[UINT8_ARRAY_TElEMENT_2] < HDMI_EDID_EXTENSION_D_INVALID_MIN_VAL) { + HDF_LOGD("ext block%d no dtd", blockNum); + return HDF_SUCCESS; + } + /* byte3: indication of underscan support, audio support, support of YCBCR and total number of native DTDs. */ + sinkCap->colorSpace.rgb444 = true; + sinkCap->colorSpace.ycbcr422 = (data[UINT8_ARRAY_TElEMENT_3] & HDMI_BIT4_MARK) ? true : false; + sinkCap->colorSpace.ycbcr444 = (data[UINT8_ARRAY_TElEMENT_3] & HDMI_BIT5_MARK) ? true : false; + sinkCap->supportAudio = (data[UINT8_ARRAY_TElEMENT_3] & HDMI_BIT6_MARK) ? true : false; + /* + * Video Data Block, Audio Data Block, Speaker Allocation Data Block, + * Vendor Specific Data Block and Video Capability Data Block phase. + */ + HdmiEdidExtSeveralDataBlockPhase(edid, blockNum); + return HDF_SUCCESS; +} + +int32_t HdmiEdidPhase(struct HdmiEdid *edid) +{ + uint8_t blockNum; + int32_t ret; + struct HdmiSinkDeviceCapability *sinkCap = NULL; + + if (edid == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + ret = HdmiEdidFirstBlockPhase(edid); + if (ret != HDF_SUCCESS) { + HDF_LOGE("edid first block phase fail."); + return ret; + } + + sinkCap = &(edid->sinkCap); + for (blockNum = 1; blockNum <= sinkCap->extBlockNum; blockNum++) { + ret = HdmiEdidExtBlockPhase(edid, blockNum); + if (ret != HDF_SUCCESS) { + HDF_LOGE("edid ext block%d phase fail.", blockNum); + return ret; + } + } + return HDF_SUCCESS; +} + +int32_t HdmiEdidRawDataRead(struct HdmiEdid *edid, struct HdmiDdc *ddc) +{ + struct HdmiDdcCfg cfg = {0}; + int32_t ret; + uint8_t extBlkNum; + + if (edid == NULL || ddc == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + /* read block0 */ + cfg.type = HDMI_DDC_DEV_EDID; + cfg.mode = HDMI_DDC_MODE_READ_MUTIL_NO_ACK; + cfg.data = edid->raw; + cfg.dataLen = HDMI_EDID_SINGLE_BLOCK_SIZE; + cfg.readFlag = true; + cfg.devAddr = HDMI_DDC_EDID_DEV_ADDRESS; + ret = HdmiDdcTransfer(ddc, &cfg); + if (ret != HDF_SUCCESS) { + HDF_LOGE("edid block0 read fail"); + return ret; + } + edid->rawLen += HDMI_EDID_SINGLE_BLOCK_SIZE; + + extBlkNum = edid->raw[HDMI_EDID_EXTENSION_BLOCK_ADDR]; + if (extBlkNum > (HDMI_EDID_MAX_BLOCK_NUM - 1)) { + extBlkNum = (HDMI_EDID_MAX_BLOCK_NUM - 1); + HDF_LOGD("extBlkNum > max, use max."); + } + if (extBlkNum == 0) { + HDF_LOGD("edid only has block0"); + return HDF_SUCCESS; + } + + /* read block1 */ + cfg.data += HDMI_EDID_SINGLE_BLOCK_SIZE; + ret = HdmiDdcTransfer(ddc, &cfg); + if (ret != HDF_SUCCESS) { + HDF_LOGE("edid block1 read fail"); + return ret; + } + edid->rawLen += HDMI_EDID_SINGLE_BLOCK_SIZE; + + if (extBlkNum == 1) { + HDF_LOGD("edid only has block0~1"); + return HDF_SUCCESS; + } + /* read block2~3 */ + cfg.data += HDMI_EDID_SINGLE_BLOCK_SIZE; + cfg.dataLen = (extBlkNum - 1) * HDMI_EDID_SINGLE_BLOCK_SIZE; + cfg.mode = HDMI_DDC_MODE_READ_SEGMENT_NO_ACK; + cfg.segment = 1; + ret = HdmiDdcTransfer(ddc, &cfg); + if (ret != HDF_SUCCESS) { + HDF_LOGE("edid block2~3 read fail"); + return ret; + } + edid->rawLen += (extBlkNum - 1) * HDMI_EDID_SINGLE_BLOCK_SIZE; + return HDF_SUCCESS; +} + +bool HdmiEdidSupportFrl(struct HdmiDevice *hdmi) +{ + if (hdmi == NULL) { + HDF_LOGD("no hdmi sink."); + return false; + } + + if (hdmi->edid.sinkCap.hfVsdbInfo.scdcPresent == true && + hdmi->edid.sinkCap.hfVsdbInfo.maxFrlRate > 0) { + return true; + } + return false; +} + +uint8_t HdmiEdidGetMaxFrlRate(struct HdmiDevice *hdmi) +{ + if (hdmi == NULL) { + HDF_LOGD("no hdmi sink."); + return 0; + } + return hdmi->edid.sinkCap.hfVsdbInfo.maxFrlRate; +} + +bool HdmiEdidScdcSupport(struct HdmiDevice *hdmi) +{ + if (hdmi == NULL) { + HDF_LOGD("no hdmi sink."); + return false; + } + return hdmi->edid.sinkCap.hfVsdbInfo.scdcPresent; +} diff --git a/support/platform/src/hdmi/hdmi_event.c b/support/platform/src/hdmi/hdmi_event.c new file mode 100644 index 0000000000000000000000000000000000000000..c9f337c17a194c0460a1e4f1732f688f33b25f42 --- /dev/null +++ b/support/platform/src/hdmi/hdmi_event.c @@ -0,0 +1,273 @@ +/* + * Copyright (c) 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_log.h" +#include "hdmi_core.h" +#include "osal_mem.h" + +#define HDF_LOG_TAG hdmi_event_c + +static int32_t HdmiEventPostMsg(struct HdmiCntlr *cntlr, struct HdmiEventMsg *event) +{ + int32_t ret; + + if (cntlr == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + if (event == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + PlatformQueueAddMsg(cntlr->msgQueue, &event->msg); + ret = PlatformMsgWait(&event->msg); + if (event->msg.block == true) { + (void)OsalSemDestroy(&event->msg.sem); + OsalMemFree(event); + } + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiEventPostMsg: wait hdmi event msg fail!"); + return ret; + } + return HDF_SUCCESS; +} + +bool HdmiHpdStatusGet(struct HdmiCntlr *cntlr) +{ + bool ret = false; + + if (cntlr == NULL || cntlr->ops == NULL || cntlr->ops->hotPlugStateGet == NULL) { + return ret; + } + + HdmiCntlrLock(cntlr); + ret = cntlr->ops->hotPlugStateGet(cntlr); + HdmiCntlrUnlock(cntlr); + return ret; +} + +bool HdmiHpdStatusDelayGet(struct HdmiCntlr *cntlr) +{ + uint32_t i; + + /* + * An HDMI Sink shall indicate any change to the contents of the EDID by driving a low voltage level pulse + * on the Hot Plug Detect pin. This pluse shall be at least 100 msec. + */ + for (i = 0; i < HDMI_READ_HPD_STATUS_DELAY; i++) { + if (HdmiHpdStatusGet(cntlr) == true) { + return true; + } + OsalMSleep(1); + } + return false; +} + +int32_t HdmiAddEventMsgToQueue(struct HdmiCntlr *cntlr, int32_t code, bool block, void *data) +{ + struct HdmiEventMsg *event = NULL; + + if (cntlr == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + event = (struct HdmiEventMsg *)OsalMemCalloc(sizeof(struct HdmiEventMsg)); + if (event == NULL) { + HDF_LOGE("HdmiAddEventMsgToQueue: OsalMemCalloc fail!n"); + return HDF_ERR_MALLOC_FAIL; + } + event->msg.code = code; + event->msg.data = (void *)cntlr; + event->msg.block = block; + event->priv = data; + return HdmiEventPostMsg(cntlr, event); +} + +static int32_t HdmiEventHotPlugHandleComm(struct HdmiCntlr *cntlr) +{ + int32_t ret; + + cntlr->event.plugged = true; + HDF_LOGD("Hdmi sink device plugged!"); + if (cntlr->hdmi == NULL) { + ret = HdmiCntlrAllocDev(cntlr); + if (ret != HDF_SUCCESS) { + goto __END; + } + HDF_LOGE("HdmiEventHotPlugHandleComm HdmiCntlrAllocDev success."); + } + + /* Update EDID. */ + if (HdmiEdidReset(&(cntlr->hdmi->edid)) != HDF_SUCCESS) { + HDF_LOGE("edid reset fail."); + ret = HDF_ERR_IO; + goto __END; + } + ret = HdmiEdidRawDataRead(&(cntlr->hdmi->edid), &(cntlr->ddc)); + if (ret != HDF_SUCCESS) { + goto __END; + } + ret = HdmiEdidPhase(&(cntlr->hdmi->edid)); + if (ret != HDF_SUCCESS) { + goto __END; + } + +__END: + if (ret != HDF_SUCCESS) { + cntlr->event.plugged = false; + cntlr->event.hpdDetected = false; + return ret; + } + cntlr->event.hpdDetected = true; + if (cntlr->event.callback.callbackFunc != NULL) { + cntlr->event.callback.callbackFunc(cntlr->event.callback.data, true); + } + return HDF_SUCCESS; +} + +static int32_t HdmiEventHotPlugHandle(struct HdmiCntlr *cntlr) +{ + if (HdmiHpdStatusDelayGet(cntlr) == false) { + HDF_LOGD("not detect HPD."); + return HDF_ERR_IO; + } + + if (cntlr->event.plugged == true) { + HDF_LOGD("HdmiEventHotPlugHandle: hdp state not change"); + return HDF_SUCCESS; + } + return HdmiEventHotPlugHandleComm(cntlr); +} + +static int32_t HdmiEventHotUnplugHandle(struct HdmiCntlr *cntlr) +{ + if (cntlr->event.plugged == false) { + HDF_LOGD("HdmiEventHotUnplugHandle: plug state not change"); + return HDF_SUCCESS; + } + + HdmiCntlrClose(cntlr); + HdmiCntlrFreeDev(cntlr); + cntlr->event.plugged = false; + cntlr->event.hpdDetected = false; + if (cntlr->event.callback.callbackFunc != NULL) { + cntlr->event.callback.callbackFunc(cntlr->event.callback.data, false); + } + return HDF_SUCCESS; +} + +static int32_t HdmiEventDetectSinkHandle(struct HdmiCntlr *cntlr) +{ + if (HdmiHpdStatusDelayGet(cntlr) == false) { + HDF_LOGD("not detect HPD."); + return HDF_SUCCESS; + } + return HdmiEventHotPlugHandleComm(cntlr); +} + +static int32_t HdmiEventCecMsgHandle(struct HdmiCntlr *cntlr, struct HdmiCecMsg *msg) +{ + if (msg == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + return HdmiCecReceivedMsg(cntlr->cec, msg); +} + +static int32_t HdmiEventHdrZeroDrmIfTimeout(struct HdmiCntlr *cntlr) +{ + return HdmiHdrDrmInfoFrameStop(cntlr->hdr); +} + +static int32_t HdmiEventSwitchToHdrModeTimeout(struct HdmiCntlr *cntlr) +{ + return HdmiHdrModeChangeTimeout(cntlr->hdr); +} + +int32_t HdmiEventMsgHandleDefault(struct PlatformQueue *queue, struct PlatformMsg *msg) +{ + int32_t ret; + struct HdmiCntlr *cntlr = NULL; + struct HdmiEventMsg *event = NULL; + + if (queue == NULL || msg == NULL) { + HDF_LOGE("HdmiEventMsgHandleDefault: msg or queue is null!"); + return HDF_ERR_INVALID_OBJECT; + } + + cntlr = (struct HdmiCntlr *)queue->data; + if (cntlr == NULL) { + HDF_LOGE("HdmiEventMsgHandleDefault: cntlr is null!"); + return HDF_ERR_INVALID_OBJECT; + } + event = (struct HdmiEventMsg *)msg; + switch (msg->code) { + case HDMI_EVENT_HOTPLUG: + ret = HdmiEventHotPlugHandle(cntlr); + break; + case HDMI_EVENT_HOTUNPLUG: + ret = HdmiEventHotUnplugHandle(cntlr); + break; + case HDMI_EVENT_DETECT_SINK: + ret = HdmiEventDetectSinkHandle(cntlr); + break; + case HDMI_EVENT_CEC_MSG: + ret = HdmiEventCecMsgHandle(cntlr, event->priv); + break; + case HDMI_EVENT_ZERO_DRMIF_TIMEOUT: + ret = HdmiEventHdrZeroDrmIfTimeout(cntlr); + break; + case HDMI_EVENT_SWITCH_TO_HDRMODE_TIMEOUT: + ret = HdmiEventSwitchToHdrModeTimeout(cntlr); + break; + default: + ret = HDF_ERR_NOT_SUPPORT; + break; + } + + if (event->msg.block == false) { + OsalMemFree(event); + } + return ret; +} + +int32_t HdmiEventHandle(struct HdmiCntlr *cntlr, enum HdmiEventType event, void *data) +{ + int32_t ret = HDF_SUCCESS; + + if (cntlr == NULL) { + HDF_LOGE("HdmiEventHandleIrq: cntlr is null!"); + return HDF_ERR_INVALID_OBJECT; + } + switch (event) { + case HDMI_EVENT_HOTPLUG: + ret = HdmiAddEventMsgToQueue(cntlr, HDMI_EVENT_HOTPLUG, false, data); + break; + case HDMI_EVENT_HOTUNPLUG: + ret = HdmiAddEventMsgToQueue(cntlr, HDMI_EVENT_HOTUNPLUG, false, data); + break; + case HDMI_EVENT_DETECT_SINK: + ret = HdmiAddEventMsgToQueue(cntlr, HDMI_EVENT_DETECT_SINK, false, data); + break; + case HDMI_EVENT_CEC_MSG: + ret = HdmiAddEventMsgToQueue(cntlr, HDMI_EVENT_CEC_MSG, false, data); + break; + case HDMI_EVENT_HDCP_MSG: + ret = HdmiAddEventMsgToQueue(cntlr, HDMI_EVENT_HDCP_MSG, false, data); + break; + case HDMI_EVENT_ZERO_DRMIF_TIMEOUT: + ret = HdmiAddEventMsgToQueue(cntlr, HDMI_EVENT_ZERO_DRMIF_TIMEOUT, false, data); + break; + case HDMI_EVENT_SWITCH_TO_HDRMODE_TIMEOUT: + ret = HdmiAddEventMsgToQueue(cntlr, HDMI_EVENT_SWITCH_TO_HDRMODE_TIMEOUT, false, data); + break; + default: + HDF_LOGE("event %d is not support", event); + break; + } + return ret; +} \ No newline at end of file diff --git a/support/platform/src/hdmi/hdmi_frl.c b/support/platform/src/hdmi/hdmi_frl.c new file mode 100644 index 0000000000000000000000000000000000000000..d6602d6b5ad2ea7c85a328fd35b0daa6e2464097 --- /dev/null +++ b/support/platform/src/hdmi/hdmi_frl.c @@ -0,0 +1,869 @@ +/* + * Copyright (c) 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_log.h" +#include "hdmi_common.h" +#include "hdmi_core.h" +#include "hdmi_dfm.h" +#include "hdmi_ncts.h" + +#define HDF_LOG_TAG hdmi_frl_c + +static uint8_t HdmiFrlGetSinkVersion(struct HdmiScdc *scdc) +{ + uint8_t version = 0; + + if (HdmiScdcOptMsgHandle(scdc, HDMI_SCDC_OPT_GET_SINK_VER, &version, sizeof(version)) != HDF_SUCCESS) { + HDF_LOGD("frl get sink version fail"); + return 0; + } + return version; +} + +static bool HdmiFrlGetFltUpdate(struct HdmiScdc *scdc) +{ + bool fltUpdate = false; + uint8_t flag = 0; + + if (HdmiScdcOptMsgHandle(scdc, HDMI_SCDC_OPT_GET_FLT_UPDATE, &flag, sizeof(flag)) != HDF_SUCCESS) { + HDF_LOGD("frl get flt update fail"); + return fltUpdate; + } + + fltUpdate = (flag & HDMI_SCDC_FLT_UPDATE_MARK) ? true : false; + return fltUpdate; +} + +static bool HdmiFrlGetFrlStart(struct HdmiScdc *scdc) +{ + bool frlStart = false; + uint8_t flag = 0; + + if (HdmiScdcOptMsgHandle(scdc, HDMI_SCDC_OPT_GET_FLT_UPDATE, &flag, sizeof(flag)) != HDF_SUCCESS) { + HDF_LOGD("frl get frl start fail"); + return frlStart; + } + + frlStart = (flag & HDMI_SCDC_FRL_START_MARK) ? true : false; + return frlStart; +} + +static bool HdmiFrlGetFltReady(struct HdmiScdc *scdc) +{ + bool fltReady = false; + uint8_t flag = 0; + + if (HdmiScdcOptMsgHandle(scdc, HDMI_SCDC_OPT_GET_FLT_READY, &flag, sizeof(flag)) != HDF_SUCCESS) { + HDF_LOGD("frl get flt ready fail"); + return fltReady; + } + + fltReady = (flag & HDMI_SCDC_FLT_READY_MARK) ? true : false; + return fltReady; +} + +static uint8_t HdmiFrlGetTestConfig1(struct HdmiScdc *scdc) +{ + uint8_t cfg = 0; + + if (HdmiScdcOptMsgHandle(scdc, HDMI_SCDC_OPT_GET_TEST_CONFIG_1, &cfg, sizeof(cfg)) != HDF_SUCCESS) { + HDF_LOGD("frl get test cfg1 fail"); + return 0; + } + return cfg; +} + +static void HdmiFrlSetFltUpdate(struct HdmiScdc *scdc, bool fltUpdate) +{ + uint8_t flag = 0; + + if (HdmiScdcOptMsgHandle(scdc, HDMI_SCDC_OPT_GET_FLT_UPDATE, &flag, sizeof(flag)) != HDF_SUCCESS) { + HDF_LOGD("frl get flt update fail"); + return; + } + + if (fltUpdate == true) { + flag |= HDMI_SCDC_FLT_UPDATE_MARK; + } else { + flag &= (~HDMI_SCDC_FLT_UPDATE_MARK); + } + if (HdmiScdcOptMsgHandle(scdc, HDMI_SCDC_OPT_SET_FLT_UPDATE, &flag, sizeof(flag)) != HDF_SUCCESS) { + HDF_LOGD("frl set flt update fail"); + } +} + +static void HdmiFrlSetFrlStart(struct HdmiScdc *scdc, bool frlStart) +{ + uint8_t flag = 0; + + if (HdmiScdcOptMsgHandle(scdc, HDMI_SCDC_OPT_GET_FLT_UPDATE, &flag, sizeof(flag)) != HDF_SUCCESS) { + HDF_LOGD("frl get frl start fail"); + return; + } + + if (frlStart == true) { + flag |= HDMI_SCDC_FRL_START_MARK; + } else { + flag &= (~HDMI_SCDC_FRL_START_MARK); + } + + if (HdmiScdcOptMsgHandle(scdc, HDMI_SCDC_OPT_GET_FLT_UPDATE, &flag, sizeof(flag)) != HDF_SUCCESS) { + HDF_LOGD("frl set frl start fail"); + } +} + +static void HdmiFrlSetConfig1(struct HdmiScdc *scdc, uint8_t *data) +{ + if (HdmiScdcOptMsgHandle(scdc, HDMI_SCDC_OPT_SET_CONFIG1, data, sizeof(*data)) != HDF_SUCCESS) { + HDF_LOGD("frl set cfg1 fail"); + } +} + +static void HdmiFrlSetTrainRate(struct HdmiFrl *frl) +{ + union HdmiScdcsConfig1 cfg = {0}; + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + + if (cntlr == NULL) { + HDF_LOGE("frl set train rate fail"); + return; + } + + if (frl->info.mode == HDMI_FRL_MODE_FRL) { + cfg.bits.frlRate = frl->info.curFrlRate; + cfg.bits.ffeLevels = HDMI_FRL_TXFFE_MODE_0; + } + HdmiFrlSetConfig1(cntlr->scdc, &(cfg.data)); +} + +static bool HdmiFrlCheckFrlCapability(struct HdmiFrl *frl) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + uint8_t sinkScdcVerion; + uint8_t sinkMaxFrlRate; + + sinkScdcVerion = HdmiFrlGetSinkVersion(cntlr->scdc); + if (HdmiEdidSupportFrl(cntlr->hdmi) != true || + cntlr->cap.baseCap.bits.hdmi21 == 0 || + cntlr->cap.baseCap.bits.frl == 0 || + sinkScdcVerion == 0) { + frl->info.maxFrlRate = 0; + return HDF_ERR_NOT_SUPPORT; + } + sinkMaxFrlRate = HdmiEdidGetMaxFrlRate(cntlr->hdmi); + frl->info.maxFrlRate = (sinkMaxFrlRate > cntlr->cap.maxFrlRate) ? cntlr->cap.maxFrlRate : sinkMaxFrlRate; + return HDF_SUCCESS; +} + +static bool HdmiFrlCheckFrlStrategy(enum HdmiFrlStrategyMode strategy, uint32_t pixelClock, + uint32_t tmdsClock, enum HdmiVideoFormatType formatType) +{ + bool support = true; + + switch (strategy) { + case HDMI_FRL_STRATEGY_MODE_1: + if (pixelClock <= HDMI_HDMI20_MAX_TMDS_RATE && tmdsClock <= HDMI_HDMI20_MAX_TMDS_RATE) { + support = false; + } + break; + case HDMI_FRL_STRATEGY_MODE_2: + if (tmdsClock <= HDMI_HDMI14_MAX_TMDS_RATE) { + support = false; + } + break; + case HDMI_FRL_STRATEGY_MODE_3: + if (formatType == HDMI_VIDEO_FORMA_INTERLACE) { + support = false; + } + break; + default: + HDF_LOGE("strategy %d is not support", strategy); + break; + } + return support; +} + +static void HdmiFrlFillRateInfo(uint32_t *frlBitRate, uint32_t *frlLaneNum, uint32_t frlRate) +{ + *frlLaneNum = HDMI_FRL_4_LANES; + if (frlRate <= HDMI_FRL_WORK_MODE_3L6G) { + *frlLaneNum = HDMI_FRL_3_LANES; + } + + switch (frlRate) { + case HDMI_FRL_WORK_MODE_3L3G: + *frlBitRate = HDMI_FRL_BIT_RATE_3; + break; + case HDMI_FRL_WORK_MODE_3L6G: + case HDMI_FRL_WORK_MODE_4L6G: + *frlBitRate = HDMI_FRL_BIT_RATE_6; + break; + case HDMI_FRL_WORK_MODE_4L8G: + *frlBitRate = HDMI_FRL_BIT_RATE_8; + break; + case HDMI_FRL_WORK_MODE_4L10G: + *frlBitRate = HDMI_FRL_BIT_RATE_10; + break; + case HDMI_FRL_WORK_MODE_4L12G: + *frlBitRate = HDMI_FRL_BIT_RATE_12; + break; + default: + break; + } +} + +static bool HdnmiFrlCheckFrlMode(struct HdmiFrl *frl) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + struct HdmiVideoDefInfo *videoInfo = NULL; + struct HdmiDfmParam param = {0}; + bool enable3d; + uint32_t i; + + enable3d = (cntlr->attr.videoAttr._3dStruct >= HDMI_VS_VIDEO_3D_BUTT) ? false : true; + videoInfo = HdmiCommonGetVideoDefInfo(cntlr->attr.videoAttr.timing, cntlr->attr.videoAttr.aspect, enable3d); + if (videoInfo == NULL) { + HDF_LOGD("have no this video param, use tmds to transmit."); + return false; + } + HDF_LOGD("use frl to transmit, vic is %d.", videoInfo->vic); + + frl->info.tmdsClock = cntlr->attr.videoAttr.tmdsClock; + if (HdmiFrlCheckFrlStrategy(frl->info.strategy, cntlr->attr.videoAttr.pixelClock, + frl->info.tmdsClock, videoInfo->formatType) == false) { + return false; + } + + if (frl->info.maxFrlRate > HDMI_FRL_WORK_MODE_4L12G) { + HDF_LOGD("max frl rate is wrong(%u)", frl->info.maxFrlRate); + frl->info.maxFrlRate = HDMI_FRL_WORK_MODE_4L12G; + return true; + } + + /* Check whether a particular video format can be transmitted in a particular FRL configuration. */ + HdmiDfmFillParam(¶m, videoInfo, &(cntlr->attr.audioAttr), cntlr->attr.commAttr.colorSpace, + cntlr->attr.commAttr.deepColor); + for (i = frl->info.maxFrlRate; i > 0; i--) { + HdmiFrlFillRateInfo(&(param.bitRate), &(param.laneNum), i); + if (HdmiDfmFormatSupport(¶m) == true) { + frl->info.minFrlRate = i; + HDF_LOGD("min_rate: %d", i); + } else { + break; + } + } + if (i == frl->info.maxFrlRate) { + return false; + } + return true; +} + +static bool HdmiFrlIsCtsMode(struct HdmiFrl *frl) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + union HdmiScdcsTestConfig1 cfg = {0}; + + cfg.data = HdmiFrlGetTestConfig1(cntlr->scdc); + if ((cfg.bits.frlMax > 0 && cfg.bits.dscFrlMax == 0) || + (cfg.bits.frlMax == 0 && cfg.bits.dscFrlMax > 0)) { + return true; + } + return false; +} + +static int32_t HdmiFrlGetCurRate(struct HdmiFrl *frl) +{ + uint8_t curFrlrate = frl->info.curFrlRate; + + if (frl->info.ctsMode == true) { + frl->info.preFrlRate = curFrlrate; + curFrlrate = frl->info.maxFrlRate; + } else { + if (frl->info.preFrlRate != 0) { + curFrlrate = frl->info.preFrlRate; + frl->info.preFrlRate = 0; + } else { + if (frl->info.rateSelect == HDMI_FRL_RATE_BIG) { + curFrlrate--; + } else { + curFrlrate++; + } + } + } + + if ((curFrlrate > frl->info.maxFrlRate) || + (curFrlrate < frl->info.minFrlRate)) { + return HDF_FAILURE; + } + frl->info.curFrlRate = curFrlrate; + return HDF_SUCCESS; +} + +static void HdmiFrlAudioNctsSet(struct HdmiFrl *frl) +{ + struct HdmiFrlAudioNctsConfig cfg = {0}; + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + + if (cntlr == NULL || cntlr->ops == NULL || cntlr->ops->audioNctsSet == NULL) { + HDF_LOGD("not support set frl audio ncts."); + return; + } + + cfg.mode = frl->info.mode; + cfg.sampleRate = cntlr->attr.audioAttr.sampleRate; + if (cfg.mode == HDMI_FRL_MODE_FRL) { + cfg.frlRate = frl->info.curFrlRate; + } else { + cfg.pixelClk = cntlr->attr.videoAttr.pixelClock; + cfg.n = HdmiGetN(cfg.sampleRate, cfg.pixelClk); + cfg.cts = HdmiGetCts(cfg.sampleRate, cfg.pixelClk); + } + HdmiCntlrLock(cntlr); + cntlr->ops->audioNctsSet(cntlr, &cfg); + HdmiCntlrUnlock(cntlr); +} + +static void HdmiFrlTxffeSet(struct HdmiFrl *frl) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + struct HdmiPhyCfg cfg = {0}; + + if (cntlr == NULL || cntlr->ops == NULL || cntlr->ops->phyOutputSet == NULL) { + HDF_LOGD("not support phy output set."); + return; + } + + cfg.modeCfg = HDMI_PHY_MODE_TXFFE; + cfg.rate = (enum HdmiFrlWorkMode)frl->info.curFrlRate; + HdmiCntlrLock(cntlr); + cntlr->ops->phyOutputSet(cntlr, &cfg); + HdmiCntlrUnlock(cntlr); +} + +static void HdmiFrlphyConfigSet(struct HdmiFrl *frl) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + struct HdmiPhyCfg cfg = {0}; + + if (cntlr == NULL || cntlr->ops == NULL) { + return; + } + + cfg.tmdsClk = cntlr->attr.videoAttr.tmdsClock; + cfg.pixelClk = cntlr->attr.videoAttr.pixelClock; + cfg.deepColor = cntlr->attr.videoAttr.deepColor; + cfg.colorSpace = cntlr->attr.commAttr.colorSpace; + if (frl->info.mode == HDMI_FRL_MODE_FRL) { + cfg.modeCfg = HDMI_PHY_MODE_FRL; + cfg.rate = (enum HdmiFrlWorkMode)frl->info.curFrlRate; + } + + if (cntlr->ops->phyOutputEnable != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->phyOutputEnable(cntlr, false); + HdmiCntlrUnlock(cntlr); + } + if (cntlr->ops->phyOutputSet != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->phyOutputSet(cntlr, &cfg); + HdmiCntlrUnlock(cntlr); + } + if (cntlr->ops->phyOutputEnable != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->phyOutputEnable(cntlr, true); + HdmiCntlrUnlock(cntlr); + } +} + +static void HdmiFrlStateMachineChangeState(struct HdmiFrl *frl, enum HdmiFrlTrainStep state) +{ + /* change state machine's state */ + frl->info.machineInfo.trainingState = state; + /* restart timer */ + frl->info.machineInfo.startTime = OsalGetSysTimeMs(); +} + +static void HdmiFrlTrainingReadyCheck(struct HdmiFrl *frl) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + + if (HdmiFrlGetFltReady(cntlr->scdc) == true) { + HDF_LOGD("step, ready chack pass, start training."); + HdmiFrlphyConfigSet(frl); + HdmiFrlSetTrainRate(frl); + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_TRAIN_START); + } +} + +static void HdmiFrlConfigAndStartTraining(struct HdmiFrl *frl) +{ + struct HdmiFrlTrainConfig cfg = {0}; + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + union HdmiScdcsTestConfig1 testCfg = {0}; + + if (cntlr == NULL || cntlr->ops == NULL) { + return; + } + + cfg.frlRate = frl->info.curFrlRate; + cfg.txffe = HDMI_FRL_TXFFE_MODE_0; + testCfg.data = HdmiFrlGetTestConfig1(cntlr->scdc); + if (testCfg.bits.fltNoTimeout > 0) { + cfg.frlNoTimeout = true; + } + cfg.trainTimeout = frl->info.machineInfo.trainTimeout; + + if (cntlr->ops->frlTrainingConfigSet != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->frlTrainingConfigSet(cntlr, &cfg); + HdmiCntlrUnlock(cntlr); + } + if (cntlr->ops->frlEnable != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->frlEnable(cntlr, false); + HdmiCntlrUnlock(cntlr); + } + if (cntlr->ops->frlTrainingStart != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->frlTrainingStart(cntlr); + HdmiCntlrUnlock(cntlr); + } + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_RESULT_CHECK); + return; +} + +static void HdmiFrlTrainingResultCheck(struct HdmiFrl *frl) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + struct HdmiFrlTrainRslt rslt = {0}; + + if (cntlr != NULL && cntlr->ops != NULL && cntlr->ops->frlGetTriningRslt != NULL) { + cntlr->ops->frlGetTriningRslt(cntlr, &rslt); + } + + if (rslt.status == HDMI_FRL_TRAIN_STATUS_SUCC) { + frl->info.trainingFailCnt = 0; + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_RESULT_HANDLE); + } else if (rslt.failReason == HDMI_FRL_TRAIN_FAIL_FFE_CHANGE) { + frl->info.trainingFailCnt = 0; + HdmiFrlTxffeSet(frl); + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_TRAIN_START); + } else if (rslt.failReason == HDMI_FRL_TRAIN_FAIL_RATE_CHANGE) { + frl->info.trainingFailCnt = 0; + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_RATE_CHANGE); + } else { + (frl->info.trainingFailCnt)++; + } +} + +static void HdmiFrlTrainingException(struct HdmiFrl *frl) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + struct HdmiPhyCfg cfg = {0}; + + if (cntlr == NULL || cntlr->ops == NULL) { + return; + } + + if (cntlr->ops->phyOutputEnable != NULL) { + cntlr->ops->phyOutputEnable(cntlr, false); + } + + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_TRAIN_STOP); + frl->info.start = false; + /* TMDS config. */ + cfg.pixelClk = cntlr->attr.videoAttr.pixelClock; + cfg.tmdsClk = cntlr->attr.videoAttr.tmdsClock; + cfg.deepColor = cntlr->attr.videoAttr.deepColor; + cfg.modeCfg = HDMI_PHY_MODE_TMDS; + cfg.colorSpace = cntlr->attr.commAttr.colorSpace; + HDF_LOGD("FRL change to TMDS."); + if (cfg.tmdsClk > HDMI_HDMI20_MAX_TMDS_RATE) { + HDF_LOGE("TMDS clk > 600M. can't work TMDS mode."); + return; + } + frl->info.mode = HDMI_FRL_MODE_TMDS; + HdmiFrlSetTrainRate(frl); + HdmiFrlAudioNctsSet(frl); + + if (cntlr->ops->phyOutputSet != NULL) { + cntlr->ops->phyOutputSet(cntlr, &cfg); + } + if (cntlr->ops->phyOutputEnable != NULL) { + cntlr->ops->phyOutputEnable(cntlr, true); + } +} + +static void HdmiFrlTrainingRateChange(struct HdmiFrl *frl) +{ + frl->info.ctsMode = HdmiFrlIsCtsMode(frl); + if (HdmiFrlGetCurRate(frl) != HDF_SUCCESS) { + HDF_LOGE("FRL rate %u get failed!\n", frl->info.curFrlRate); + HdmiFrlTrainingException(frl); + return; + } + /* FRL rate change */ + HdmiFrlphyConfigSet(frl); + HdmiFrlSetTrainRate(frl); + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_TRAIN_START); +} + +static void HdmiFrlTrainingPassedCheck(struct HdmiFrl *frl) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + + if (cntlr == NULL || cntlr->ops == NULL) { + return; + } + + if (frl->info.start == false || + HdmiFrlGetFrlStart(cntlr->scdc) == false) { + return; + } + + HDF_LOGD("FRL training passed."); + frl->info.work = true; + /* n/cts config */ + HdmiFrlAudioNctsSet(frl); + OsalMSleep(1); + if (cntlr->ops->phyOutputEnable != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->phyOutputEnable(cntlr, frl->info.work); + HdmiCntlrUnlock(cntlr); + } + OsalMSleep(1); + HdmiFrlSetFrlStart(cntlr->scdc, true); + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_RETRAIN_CHECK); +} + +static void HdmiFrlRetrainingCheck(struct HdmiFrl *frl) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + + if (cntlr == NULL || cntlr->ops == NULL) { + return; + } + if (HdmiFrlGetFltUpdate(cntlr->scdc) == false) { + return; + } + + HDF_LOGD("FRL retraining flt_update get OK"); + HdmiFrlSetFltUpdate(cntlr->scdc, true); + frl->info.work = false; + if (cntlr->ops->phyOutputEnable != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->phyOutputEnable(cntlr, frl->info.work); + HdmiCntlrUnlock(cntlr); + } + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_TRAIN_START); +} + +static void HdmiFrlTrainingStop(struct HdmiFrl *frl) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + + if (cntlr == NULL || cntlr->ops == NULL) { + return; + } + + frl->info.work = false; + if (cntlr->ops->phyOutputEnable != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->phyOutputEnable(cntlr, frl->info.work); + HdmiCntlrUnlock(cntlr); + } + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_BUTT); +} + +void HdmiFrlTrainingStateMachineHandle(struct HdmiFrl *frl) +{ + if (frl == NULL) { + HDF_LOGE("FRL trining, not support FRL."); + return; + } + + switch (frl->info.machineInfo.trainingState) { + case HDMI_FRL_TRAIN_STEP_READR_CHECK: + HdmiFrlTrainingReadyCheck(frl); + break; + case HDMI_FRL_TRAIN_STEP_TRAIN_START: + HdmiFrlConfigAndStartTraining(frl); + break; + case HDMI_FRL_TRAIN_STEP_RESULT_CHECK: + HdmiFrlTrainingResultCheck(frl); + break; + case HDMI_FRL_TRAIN_STEP_RATE_CHANGE: + HdmiFrlTrainingRateChange(frl); + break; + case HDMI_FRL_TRAIN_STEP_RESULT_HANDLE: + HdmiFrlTrainingPassedCheck(frl); + break; + case HDMI_FRL_TRAIN_STEP_RETRAIN_CHECK: + HdmiFrlRetrainingCheck(frl); + break; + case HDMI_FRL_TRAIN_STEP_TRAIN_STOP: + HdmiFrlTrainingStop(frl); + break; + default: + break; + } +} + +static void HdmiFrlTrainingReadyCheckTimeout(struct HdmiFrl *frl) +{ + uint64_t curTime = OsalGetSysTimeMs(); + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + + if ((curTime - frl->info.machineInfo.startTime) > frl->info.machineInfo.waitReadyTime) { + if (HdmiFrlGetFltReady(cntlr->scdc) == true) { + HDF_LOGD("step, ready chack pass, start training."); + frl->info.machineInfo.timeoutCnt = 0; + HdmiFrlphyConfigSet(frl); + HdmiFrlSetTrainRate(frl); + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_TRAIN_START); + } else { + (frl->info.machineInfo.timeoutCnt)++; + /* */ + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_READR_CHECK); + } + } else { + /* wait for a maximum of 10 times, (wait_ready_ms * 10) ms */ + if (frl->info.machineInfo.timeoutCnt < 10) { + return; + } + HDF_LOGD("FRL training READY_CHECK exception."); + frl->info.machineInfo.timeoutCnt = 0; + HdmiFrlTrainingException(frl); + } +} + +static void HdmiFrlTrainingResultCheckTimeout(struct HdmiFrl *frl) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + struct HdmiFrlTrainRslt rslt = {0}; + + if (cntlr != NULL && cntlr->ops != NULL && cntlr->ops->frlGetTriningRslt != NULL) { + cntlr->ops->frlGetTriningRslt(cntlr, &rslt); + } + + if (rslt.status == HDMI_FRL_TRAIN_STATUS_SUCC) { + frl->info.trainingFailCnt = 0; + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_RESULT_HANDLE); + } else if (rslt.failReason == HDMI_FRL_TRAIN_FAIL_FFE_CHANGE) { + frl->info.trainingFailCnt = 0; + HdmiFrlTxffeSet(frl); + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_TRAIN_START); + } else if (rslt.failReason == HDMI_FRL_TRAIN_FAIL_RATE_CHANGE) { + frl->info.trainingFailCnt = 0; + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_RATE_CHANGE); + } else { + (frl->info.trainingFailCnt)++; + if (frl->info.trainingFailCnt > frl->info.trainingMaxFailTimes) { + frl->info.trainingFailCnt = 0; + HdmiFrlTrainingException(frl); + } else { + /* not reach max fail times, re-training. */ + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_TRAIN_START); + } + } +} + +static void HdmiFrlTrainingResultHandleTimeout(struct HdmiFrl *frl) +{ + uint64_t curTime; + bool frlStart = false; + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + + if (cntlr == NULL || cntlr->ops == NULL) { + return; + } + + do { + frlStart = HdmiFrlGetFrlStart(cntlr->scdc); + if (frlStart == true && frl->info.start == true) { + frl->info.work = true; + /* n/cts config */ + HdmiFrlAudioNctsSet(frl); + if (cntlr->ops->phyOutputEnable != NULL) { + cntlr->ops->phyOutputEnable(cntlr, frl->info.work); + } + HdmiFrlSetFrlStart(cntlr->scdc, true); + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_RETRAIN_CHECK); + break; + } else if (frlStart == false && HdmiFrlGetFltUpdate(cntlr->scdc) == true) { + HdmiFrlSetFltUpdate(cntlr->scdc, true); + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_TRAIN_START); + break; + } + + curTime = OsalGetSysTimeMs(); + if ((curTime - frl->info.machineInfo.startTime) > frl->info.machineInfo.waitHandleTime) { + (frl->info.machineInfo.timeoutCnt)++; + break; + } + /* check the sink's status every 2ms required by protocol */ + OsalUDelay(2000); + } while (true); + + if (frl->info.machineInfo.timeoutCnt >= 3) { + HDF_LOGE("FRL training timeout."); + frl->info.machineInfo.timeoutCnt = 0; + HdmiFrlTrainingException(frl); + } +} + +static void HdmiFrlRetrainingCheckTimeout(struct HdmiFrl *frl) +{ + uint64_t curTime = OsalGetSysTimeMs(); + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)frl->priv; + + if (cntlr == NULL || cntlr->ops == NULL) { + return; + } + if ((curTime - frl->info.machineInfo.startTime) <= frl->info.machineInfo.waitRetrainTime) { + return; + } + if (HdmiFrlGetFltUpdate(cntlr->scdc) != true) { + return; + } + + HdmiFrlSetFltUpdate(cntlr->scdc, true); + frl->info.work = true; + if (cntlr->ops->phyOutputEnable != NULL) { + cntlr->ops->phyOutputEnable(cntlr, frl->info.work); + } + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_TRAIN_START); +} + +void HdmiFrlTrainingStateMachineTimeoutHandle(struct HdmiFrl *frl) +{ + if (frl == NULL || frl->priv == NULL) { + HDF_LOGE("FRL trining, not support FRL."); + return; + } + + switch (frl->info.machineInfo.trainingState) { + case HDMI_FRL_TRAIN_STEP_READR_CHECK: + HdmiFrlTrainingReadyCheckTimeout(frl); + break; + case HDMI_FRL_TRAIN_STEP_TRAIN_START: + HdmiFrlConfigAndStartTraining(frl); + break; + case HDMI_FRL_TRAIN_STEP_RESULT_CHECK: + HdmiFrlTrainingResultCheckTimeout(frl); + break; + case HDMI_FRL_TRAIN_STEP_RATE_CHANGE: + HdmiFrlTrainingRateChange(frl); + break; + case HDMI_FRL_TRAIN_STEP_RESULT_HANDLE: + HdmiFrlTrainingResultHandleTimeout(frl); + break; + case HDMI_FRL_TRAIN_STEP_RETRAIN_CHECK: + HdmiFrlRetrainingCheckTimeout(frl); + break; + case HDMI_FRL_TRAIN_STEP_TRAIN_STOP: + HdmiFrlTrainingStop(frl); + break; + default: + break; + } +} + +void HdmiFrlEnable(struct HdmiFrl *frl, bool enable) +{ + if (frl == NULL || frl->priv == NULL) { + return; + } + + frl->info.start = enable; + frl->info.machineInfo.start = enable; + frl->info.machineInfo.machineState = (enable == true) ? HDMI_FRL_STATE_MACHINE_START : HDMI_FRL_STATE_MACHINE_STOP; + frl->info.ctsMode = HdmiFrlIsCtsMode(frl); + if (frl->info.ctsMode == true) { + HdmiFrlGetCurRate(frl); + HDF_LOGD("frl cur rate %d", frl->info.curFrlRate); + } + HdmiFrlStateMachineChangeState(frl, HDMI_FRL_TRAIN_STEP_READR_CHECK); +} + +int32_t HdmiFrlModeSelect(struct HdmiFrl *frl) +{ + int32_t ret; + struct HdmiCntlr *cntlr = NULL; + struct HdmiVideoAttr *videoAttr = NULL; + + if (frl == NULL || frl->priv == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + ret = HdmiFrlCheckFrlCapability(frl); + if (ret == HDF_FAILURE) { + return ret; + } else if (ret != HDF_SUCCESS) { + HDF_LOGD("frl check capability fail, change to TMDS."); + frl->info.mode = HDMI_FRL_MODE_TMDS; + } else { + if (HdnmiFrlCheckFrlMode(frl) == true) { + HDF_LOGD("frl check frl mode succ."); + frl->info.mode = HDMI_FRL_MODE_FRL; + } else { + HDF_LOGD("frl check frl mode fail, change to TMDS."); + frl->info.mode = HDMI_FRL_MODE_TMDS; + } + } + + cntlr = (struct HdmiCntlr *)frl->priv; + videoAttr = &(cntlr->attr.videoAttr); + if (frl->info.mode == HDMI_FRL_MODE_TMDS) { + if (videoAttr->tmdsClock > HDMI_HDMI20_MAX_TMDS_RATE) { + HDF_LOGE("FRL mode select, tmds Clock exceed max."); + return HDF_FAILURE; + } + if (HdmiEdidScdcSupport(cntlr->hdmi) == true) { + HdmiFrlSetTrainRate(frl); + } + return HDF_SUCCESS; + } + + /* FRL mode. */ + frl->info.curFrlRate = (frl->info.rateSelect == HDMI_FRL_RATE_BIG) ? + frl->info.maxFrlRate : frl->info.minFrlRate; + cntlr->tmdsMode = HDMI_TMDS_MODE_HDMI_2_0; + if (cntlr->ops != NULL && cntlr->ops->tmdsModeSet != NULL) { + HdmiCntlrLock(cntlr); + cntlr->ops->tmdsModeSet(cntlr, cntlr->tmdsMode); + HdmiCntlrUnlock(cntlr); + } + frl->info.ctsMode = false; + return HDF_SUCCESS; +} + +bool HdmiFrlModeChanged(struct HdmiFrl *frl) +{ + if (frl == NULL) { + return false; + } + + if (frl->info.perMode != frl->info.mode) { + frl->info.perMode = frl->info.mode; + return true; + } + return false; +} + +bool HdmiFrlSupport(struct HdmiFrl *frl) +{ + if (frl == NULL) { + return false; + } + + if (frl->info.mode == HDMI_FRL_MODE_FRL) { + return true; + } + return false; +} diff --git a/support/platform/src/hdmi/hdmi_hdcp.c b/support/platform/src/hdmi/hdmi_hdcp.c new file mode 100644 index 0000000000000000000000000000000000000000..eb4bc15d8a8dd68a25354b0e684f00aa8589f82c --- /dev/null +++ b/support/platform/src/hdmi/hdmi_hdcp.c @@ -0,0 +1,478 @@ +/* + * Copyright (c) 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_log.h" +#include "hdmi_core.h" + +#define HDF_LOG_TAG hdmi_hdcp_c + +static int32_t HdmiHdcpRead(struct HdmiHdcp *hdcp, enum HdmiHdcpPortOffset offset, uint8_t *buffer, uint32_t len) +{ + struct HdmiDdcCfg cfg = {0}; + struct HdmiCntlr *cntlr = NULL; + + if (hdcp == NULL || hdcp->priv == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + cntlr = (struct HdmiCntlr *)hdcp->priv; + cfg.type = HDMI_DDC_DEV_HDCP; + cfg.readFlag = true; + cfg.devAddr = HDMI_DDC_HDCP_DEV_ADDRESS; + cfg.data = buffer; + cfg.dataLen = len; + cfg.offset = offset; + cfg.mode = HDMI_DDC_MODE_READ_MUTIL_NO_ACK; + return HdmiDdcTransfer(&(cntlr->ddc), &cfg); +} + +static int32_t HdmiHdcpWrite(struct HdmiHdcp *hdcp, enum HdmiHdcpPortOffset offset, uint8_t *buffer, uint32_t len) +{ + struct HdmiDdcCfg cfg = {0}; + struct HdmiCntlr *cntlr = NULL; + + if (hdcp == NULL || hdcp->priv == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + cntlr = (struct HdmiCntlr *)hdcp->priv; + cfg.type = HDMI_DDC_DEV_HDCP; + cfg.readFlag = false; + cfg.devAddr = HDMI_DDC_HDCP_DEV_ADDRESS; + cfg.data = buffer; + cfg.dataLen = len; + cfg.offset = offset; + cfg.mode = HDMI_DDC_MODE_WRITE_MUTIL_ACK; + return HdmiDdcTransfer(&(cntlr->ddc), &cfg); +} + +static bool HdmiHdcpCheckKvs(uint8_t *ksv, uint32_t len) +{ + uint32_t i, j; + uint32_t cnt = 0; + + for (i = 0; i < len; i++) { + for (j = 0; j < HDMI_ONE_BYTE_SHIFT; j++) { + if (((ksv[i] >> j) & 0x01) > 0) { + cnt++; + } + } + } + /* KSV contains 20 ones and 20 zeros. */ + if (cnt != HDMI_HDCP_AKSV_ONE_NUM) { + HDF_LOGE("HdmiHdcpCheckKvs: cnt = %d.", cnt); + return false; + } + return true; +} + +static int32_t HdmiHdcpWriteMsgToReg(struct HdmiHdcp *hdcp, enum HdmiHdcpRegOptType type, uint8_t *data, uint32_t len) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)hdcp->priv; + + if (cntlr->ops == NULL || cntlr->ops->hdcpOptReg == NULL) { + HDF_LOGD("not support hdcp write reg."); + return HDF_ERR_INVALID_PARAM; + } + return cntlr->ops->hdcpOptReg(cntlr, type, data, len); +} + +static int32_t HdmiHdcpReadMsgBksv(struct HdmiHdcp *hdcp) +{ + int32_t ret; + + ret = HdmiHdcpRead(hdcp, HDMI_HDCP_BKSV, hdcp->bksv, sizeof(hdcp->bksv)); + if (ret != HDF_SUCCESS) { + return ret; + } + if (HdmiHdcpCheckKvs(hdcp->bksv, sizeof(hdcp->bksv)) == false) { + HDF_LOGE("auth part I: bksv check fail."); + return HDF_ERR_INVALID_PARAM; + } + return HdmiHdcpWriteMsgToReg(hdcp, HDMI_HDCP_OPT_WRITE_BKSV, hdcp->bksv, sizeof(hdcp->bksv)); +} + +static int32_t HdmiHdcpReadMsgRi(struct HdmiHdcp *hdcp) +{ + int32_t ret; + ret = HdmiHdcpRead(hdcp, HDMI_HDCP_RI, hdcp->ri, sizeof(hdcp->ri)); + if (ret != HDF_SUCCESS) { + return ret; + } + return HdmiHdcpWriteMsgToReg(hdcp, HDMI_HDCP_OPT_WRITE_RI, hdcp->ri, sizeof(hdcp->ri)); +} + +static int32_t HdmiHdcpWriteMsgAksv(struct HdmiHdcp *hdcp) +{ + if (HdmiHdcpCheckKvs(hdcp->aksv, sizeof(hdcp->aksv)) == false) { + HDF_LOGE("auth part I: aksv check fail."); + return HDF_ERR_INVALID_PARAM; + } + return HdmiHdcpWrite(hdcp, HDMI_HDCP_AN, hdcp->aksv, sizeof(hdcp->aksv)); +} + +static int32_t HdmiHdcpWriteMsgAn(struct HdmiHdcp *hdcp) +{ + return HdmiHdcpWrite(hdcp, HDMI_HDCP_AN, hdcp->an, sizeof(hdcp->an)); +} + +static int32_t HdmiHdcpReadMsgHv(struct HdmiHdcp *hdcp) +{ + uint8_t offset, i; + uint8_t vhNum = HDMI_HDCP_MSG_ALL_VH_LEN / HDMI_HDCP_MSG_PER_VH_LEN; + int32_t ret; + + if (hdcp == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + for (i = 0; i < vhNum; i++) { + offset = HDMI_HDCP_V_H0 + i * HDMI_HDCP_MSG_PER_VH_LEN; + ret = HdmiHdcpRead(hdcp, offset, &(hdcp->vh[i]), HDMI_HDCP_MSG_PER_VH_LEN); + if (ret != HDF_SUCCESS) { + return ret; + } + } + return HdmiHdcpWriteMsgToReg(hdcp, HDMI_HDCP_OPT_WRITE_V_H_ALL, hdcp->vh, sizeof(hdcp->vh)); +} + +static int32_t HdmiHdcpReadMsgBcaps(struct HdmiHdcp *hdcp) +{ + int32_t ret; + ret = HdmiHdcpRead(hdcp, HDMI_HDCP_BCAPS, &(hdcp->bcaps), sizeof(hdcp->bcaps)); + if (ret != HDF_SUCCESS) { + return ret; + } + return HdmiHdcpWriteMsgToReg(hdcp, HDMI_HDCP_OPT_WRITE_BCAPS, &(hdcp->bcaps), sizeof(hdcp->bcaps)); +} + +static int32_t HdmiHdcpAuthenticationGenerateAksvAn(struct HdmiHdcp *hdcp) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)hdcp->priv; + + if (cntlr->ops == NULL || cntlr->ops->hdcpGenerateAksvAndAn == NULL) { + return HDF_ERR_NOT_SUPPORT; + } + return cntlr->ops->hdcpGenerateAksvAndAn(cntlr); +} + +static void HdmiHdcpRegPrepare(struct HdmiHdcp *hdcp) +{ + struct HdmiCntlr *cntlr = (struct HdmiCntlr *)hdcp->priv; + + if (cntlr->ops == NULL || cntlr->ops->hdcpRegInit == NULL) { + return; + } + cntlr->ops->hdcpRegInit(cntlr); +} + +static int32_t HdmiHdcpAuthenticationPrepare(struct HdmiHdcp *hdcp) +{ + int32_t ret; + + HdmiHdcpRegPrepare(hdcp); + if (hdcp->aksvValid == false) { + ret = HdmiHdcpAuthenticationGenerateAksvAn(hdcp); + if (ret != HDF_SUCCESS) { + hdcp->state = HDMI_HDCP_AUTH_AKSV_INVALID; + return ret; + } + } + hdcp->aksvValid = true; + return HDF_SUCCESS; +} + +static int32_t HdmiHdcpAuthenticationFirstPart(struct HdmiHdcp *hdcp) +{ + int32_t ret; + + hdcp->state = HDMI_HDCP_AUTH_DOING; + /* + * Authentication is initiated by the HDCP Transmitter by sendind an initiation massage containing its KSV(aksv) + * and a 64-bit pseudo-random value(An) generated by the HDCP Cipher function hdcpRngCipher to the HDCP Reciever. + */ + ret = HdmiHdcpWriteMsgAksv(hdcp); + if (ret != HDF_SUCCESS) { + return ret; + } + ret = HdmiHdcpWriteMsgAn(hdcp); + if (ret != HDF_SUCCESS) { + return ret; + } + + /* + * The HDCP Reciever responds by sending a response message containing the receiver's KSV(bksv) and + * the REPEATER bit, which indicates if the reciever is an HDCP Repeater. + */ + ret = HdmiHdcpReadMsgBksv(hdcp); + if (ret != HDF_SUCCESS) { + return ret; + } + ret = HdmiHdcpReadMsgBcaps(hdcp); + if (ret != HDF_SUCCESS) { + return ret; + } + + /* + * The HDCP Transmitter must not read the R0' value sooner than 100ms after writing Aksv. + */ + OsalMSleep(120); + /* Read R0' */ + ret = HdmiHdcpReadMsgRi(hdcp); + if (ret != HDF_SUCCESS) { + return ret; + } + + /* Verify R0/R0' matched or not */ + ret = HdmiHdcpWriteMsgToReg(hdcp, HDMI_HDCP_OPT_CHECK_R, NULL, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("hdcp auth, check V fail."); + return ret; + } + return HDF_SUCCESS; +} + +static int32_t HdmiHdcpAuthenticationCheckBstatus(struct HdmiHdcp *hdcp) +{ + int32_t ret; + uint16_t bstatus; + + ret = HdmiHdcpRead(hdcp, HDMI_HDCP_BSTATUS, hdcp->bstatus, sizeof(hdcp->bstatus)); + if (ret != HDF_SUCCESS) { + return ret; + } + + /* phase bstatus. */ + bstatus = (hdcp->bstatus[1] << 8) | hdcp->bstatus[0]; + hdcp->deviceCount = bstatus & HDMI_HDCP_BSTATUS_DEVICE_COUNT_MARK; + if (hdcp->deviceCount == 0) { + HDF_LOGE("hdcp auth, check bstatus, no device attached to the repeater."); + return HDF_DEV_ERR_NO_DEVICE; + } + if ((bstatus & HDMI_HDCP_BSTATUS_MAX_DEVS_EXCEEDED_MARK) > 0) { + HDF_LOGE("hdcp auth, check bstatus, exceeds max allowed connected devices."); + return HDF_ERR_IO; + } + if ((bstatus & HDMI_HDCP_BSTATUS_MAX_CASCADE_EXCEEDED_MARK) > 0) { + HDF_LOGE("hdcp auth, check bstatus, exceeds max allowed cascade."); + return HDF_ERR_IO; + } + return HDF_SUCCESS; +} + +static int32_t HdmiHdcpAuthenticationWaitKsvListReady(struct HdmiHdcp *hdcp) +{ + uint32_t i; + int32_t ret; + bool ready = false; + + /* Set up 5s timer, poll for KSV list ready. Fail if timer expires prior to ready. */ + for (i = 0; i < HDMI_HDCP_WAIT_KSV_LIST_READ_REG_CNT; i++) { + ret = HdmiHdcpRead(hdcp, HDMI_HDCP_BCAPS, &(hdcp->bcaps), sizeof(hdcp->bcaps)); + if (ret != HDF_SUCCESS) { + return ret; + } + if ((hdcp->bcaps & HDMI_HDCP_BCAPS_KSV_FIFO_READY_MARK) > 0) { + ready = true; + break; + } + OsalMSleep(HDMI_HDCP_WAIT_KSV_LIST_READ_REG_INTERVAL); + } + if (ready == false) { + return HDF_ERR_TIMEOUT; + } + + ret = HdmiHdcpAuthenticationCheckBstatus(hdcp); + if (ret != HDF_SUCCESS) { + return ret; + } + ret = HdmiHdcpWriteMsgToReg(hdcp, HDMI_HDCP_OPT_WRITE_BCAPS, &(hdcp->bcaps), sizeof(hdcp->bcaps)); + if (ret != HDF_SUCCESS) { + HDF_LOGD("hdcp auth wait ksv list ready, WRITE_BCAPS fail"); + } + ret = HdmiHdcpWriteMsgToReg(hdcp, HDMI_HDCP_OPT_WRITE_BSTATUS, hdcp->bstatus, sizeof(hdcp->bstatus)); + if (ret != HDF_SUCCESS) { + HDF_LOGD("hdcp auth wait ksv list ready, WRITE_BSTATUS fail"); + } + return HDF_SUCCESS; +} + +static int32_t HdmiHdcpAuthenticationReadKsvList(struct HdmiHdcp *hdcp) +{ + int32_t ret; + uint32_t try = HDMI_HDCP_DEFAULT_READ_REG_TRY; + + hdcp->ksvLen = HDMI_HDCP_GET_KSV_LEN(hdcp->deviceCount); + do { + ret = HdmiHdcpRead(hdcp, HDMI_HDCP_KSV_FIFO, hdcp->ksvList, hdcp->ksvLen); + if (ret == HDF_SUCCESS) { + break; + } + OsalMSleep(HDMI_HDCP_WAIT_KSV_LIST_READ_REG_INTERVAL); + try--; + } while (try > 0); + + ret = HdmiHdcpReadMsgHv(hdcp); + if (ret != HDF_SUCCESS) { + return ret; + } + /* We may need to reset SHA before write ksv list. */ + ret = HdmiHdcpWriteMsgToReg(hdcp, HDMI_HDCP_OPT_RESET_SHA, NULL, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGD("hdcp auth read ksv list, RESET_SHA fail"); + } + ret = HdmiHdcpWriteMsgToReg(hdcp, HDMI_HDCP_OPT_WRITE_KSV_FIFO, hdcp->ksvList, hdcp->ksvLen); + if (ret != HDF_SUCCESS) { + HDF_LOGD("hdcp auth read ksv list, WRITE_KSV_FIFO fail"); + } + return HDF_SUCCESS; +} + +static int32_t HdmiHdcpAuthenticationSecondPart(struct HdmiHdcp *hdcp) +{ + int32_t ret; + + /* Poll: KSV list ready. */ + ret = HdmiHdcpAuthenticationWaitKsvListReady(hdcp); + if (ret != HDF_SUCCESS) { + HDF_LOGE("hdcp auth, wait ksv list ready fail."); + return ret; + } + + /* Read KSV list */ + ret = HdmiHdcpAuthenticationReadKsvList(hdcp); + if (ret != HDF_SUCCESS) { + HDF_LOGE("hdcp auth, read ksv list fail."); + return ret; + } + + /* Verify V/V' matched or not */ + ret = HdmiHdcpWriteMsgToReg(hdcp, HDMI_HDCP_OPT_CHECK_V, NULL, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("hdcp auth, check V fail."); + return ret; + } + return HDF_SUCCESS; +} + +static void HdmiHdcpAuthenticationSucc(struct HdmiHdcp *hdcp) +{ + if (HdmiHdcpWriteMsgToReg(hdcp, HDMI_HDCP_OPT_AUTH_DONE, NULL, 0) != HDF_SUCCESS) { + HDF_LOGE("hdcp auth succ, AUTH_DONE fail."); + } + hdcp->state = HDMI_HDCP_AUTH_DONE; + hdcp->authRetryCnt = 0; +} + +static void HdmiHdcpAuthenticationFail(struct HdmiHdcp *hdcp) +{ + if (HdmiHdcpWriteMsgToReg(hdcp, HDMI_HDCP_OPT_AUTH_FAIL, NULL, 0) != HDF_SUCCESS) { + HDF_LOGE("hdcp auth fail, AUTH_FAIL fail."); + } + hdcp->state = HDMI_HDCP_AUTH_FAIL; +} + +static int32_t HdmiHdcpAuthentication(struct HdmiHdcp *hdcp) +{ + int32_t ret; + + if (hdcp == NULL || hdcp->priv == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + /* auth prepare, get aksv and driver clear registers. */ + ret = HdmiHdcpAuthenticationPrepare(hdcp); + if (ret != HDF_SUCCESS) { + goto _END; + } + + /* + * First part of the authentication exchange. + */ + ret = HdmiHdcpAuthenticationFirstPart(hdcp); + if (ret != HDF_SUCCESS) { + goto _END; + } + HDF_LOGD("hdcp auth Part I success."); + /* receiver (0), repeater (1) */ + if ((hdcp->bcaps & HDMI_HDCP_BCAPS_REPEATER_MARK) == 0) { + goto _END; + } + + /* + * The second part of the authentication protocol is required if the HDCP Reciever is an HDCP Repeater. + */ + ret = HdmiHdcpAuthenticationSecondPart(hdcp); + if (ret != HDF_SUCCESS) { + goto _END; + } + +_END: + if (ret == HDF_SUCCESS) { + HdmiHdcpAuthenticationSucc(hdcp); + } else { + HdmiHdcpAuthenticationFail(hdcp); + } + return ret; +} + +static int32_t HdmiHdcpAuthenticationRetry(struct HdmiHdcp *hdcp) +{ + if (hdcp == NULL || hdcp->priv == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + if (hdcp->authRetryCnt > HDMI_HDCP_AUTH_MAX_RETRY_CNT) { + HDF_LOGE("hdcp auth reach to max cnt, auth fail"); + return HDF_FAILURE; + } + return HdmiHdcpAuthentication(hdcp); +} + +int32_t HdmiHdcpOpen(struct HdmiHdcp *hdcp) +{ + int32_t ret; + + (void)OsalMutexLock(&(hdcp->hdcpMutex)); + hdcp->state = HDMI_HDCP_AUTH_INACTIVE; + hdcp->authRetryCnt = 0; + ret = HdmiHdcpAuthentication(hdcp); + if (ret == HDF_SUCCESS) { + HDF_LOGD("hdcp Authentication success!"); + goto __END; + } + + while (hdcp->authRetryCnt <= HDMI_HDCP_AUTH_MAX_RETRY_CNT) { + ret = HdmiHdcpAuthenticationRetry(hdcp); + if (ret == HDF_SUCCESS) { + goto __END; + } + hdcp->authRetryCnt++; + } + __END : + (void)OsalMutexUnlock(&(hdcp->hdcpMutex)); + return ret; +} + +void HdmiHdcpClose(struct HdmiHdcp *hdcp) +{ + if (hdcp == NULL) { + return; + } + + if (hdcp->state == HDMI_HDCP_AUTH_INACTIVE || + hdcp->state == HDMI_HDCP_AUTH_AKSV_INVALID) { + return; + } + + if (HdmiHdcpWriteMsgToReg(hdcp, HDMI_HDCP_OPT_AUTH_CLOSE, NULL, 0) != HDF_SUCCESS) { + HDF_LOGD("hdcp close, AUTH_CLOSE fail"); + } + hdcp->state = HDMI_HDCP_AUTH_INACTIVE; + hdcp->authRetryCnt = 0; +} diff --git a/support/platform/src/hdmi/hdmi_hdr.c b/support/platform/src/hdmi/hdmi_hdr.c new file mode 100644 index 0000000000000000000000000000000000000000..ef6f7f01dd384e98598294762a8074f2d468f3e7 --- /dev/null +++ b/support/platform/src/hdmi/hdmi_hdr.c @@ -0,0 +1,274 @@ +/* + * Copyright (c) 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_log.h" +#include "hdmi_core.h" +#include "securec.h" + +#define HDF_LOG_TAG hdmi_hdr_c + +static bool HdmiHdrAttrChange(struct HdmiHdrAttr *curAttr, struct HdmiHdrAttr *oldAttr) +{ + if (memcmp(curAttr, oldAttr, sizeof(struct HdmiHdrAttr)) == 0) { + return false; + } + return true; +} + +static void HdmiHdrColorimetryUpdate(struct HdmiVideoAttr *videoAttr, enum HdmiHdrColormetry colorimetry) +{ + if (colorimetry >= HDMI_HDR_COLORIMETRY_EXTENDED) { + videoAttr->colorimetry = HDMI_COLORIMETRY_EXTENDED; + videoAttr->extColorimetry = (enum HdmiExtendedColorimetry)(colorimetry - + HDMI_HDR_EXTENDED_COLORIMETRY_XV_YCC_601); + } else { + videoAttr->colorimetry = (enum HdmiColorimetry)colorimetry; + videoAttr->extColorimetry = HDMI_EXTENDED_COLORIMETRY_XV_YCC_601; + } +} + +static void HdmiHdrZeroDrmInfoFrameTimerSet(struct HdmiCntlr *cntlr, bool start) +{ + struct HdmiHdrInfo *hdrInfo = &(cntlr->hdr->info); + struct HdmiHdrAttr *hdrAttr = &(cntlr->attr.hdrAttr); + + hdrInfo->zeroDrmIfTimer.start = false; + hdrInfo->zeroDrmIfTimer.timerType = HDMI_HDR_TIMER_ZERO_DRMIF; + hdrInfo->zeroDrmIfTimer.time = HDMI_ZERO_DRMIF_SEND_TIME; + HdmiCntlrHdrTimerSet(cntlr, &(hdrInfo->zeroDrmIfTimer)); + if (start == false) { + return; + } + + hdrAttr->eotfType = HDMI_EOTF_SDR_LUMIN; + hdrAttr->metadataType = HDMI_DRM_STATIC_METADATA_TYPE_1; + if (memset_s(&(hdrAttr->descriptor), sizeof(hdrAttr->descriptor), 0, sizeof(hdrAttr->descriptor)) != EOK) { + HDF_LOGE("memset_s fail"); + return; + } + (void)HdmiDrmInfoFrameSend(&(cntlr->infoFrame), true); + + hdrInfo->zeroDrmIfTimer.start = true; + HdmiCntlrHdrTimerSet(cntlr, &(hdrInfo->zeroDrmIfTimer)); +} + +static void HdmiHdrModeChangeTimerSet(struct HdmiCntlr *cntlr, bool start) +{ + struct HdmiHdrInfo *hdrInfo = &(cntlr->hdr->info); + + hdrInfo->stateChangeTimer.start = false; + hdrInfo->stateChangeTimer.timerType = HDMI_HDR_TIMER_SDR_TO_HDR10; + hdrInfo->stateChangeTimer.time = HDMI_HDR_STATE_CHANGE_TIME; + HdmiCntlrHdrTimerSet(cntlr, &(hdrInfo->stateChangeTimer)); + if (start == false) { + return; + } + + hdrInfo->stateChangeTimer.start = true; + HdmiCntlrHdrTimerSet(cntlr, &(hdrInfo->stateChangeTimer)); +} + +static int32_t HdmiDisableHdr(struct HdmiCntlr *cntlr, struct HdmiHdrAttr *curAttr) +{ + int32_t ret = HDF_SUCCESS; + struct HdmiHdrAttr *oldAttr = &(cntlr->attr.hdrAttr); + struct HdmiVideoAttr *videoAttr = &(cntlr->attr.videoAttr); + struct HdmiCommonAttr *commAttr = &(cntlr->attr.commAttr); + struct HdmiHdrInfo *hdrInfo = &(cntlr->hdr->info); + + switch (oldAttr->mode) { + case HDMI_HDR_MODE_DISABLE: + break; + case HDMI_HDR_MODE_CEA_861_3: + *oldAttr = *curAttr; + if (hdrInfo->state != HDMI_HDR_STATE_NONE) { + /* to solve the problem of some TV can not switch smoothly from HDR10 to non-HDR10. */ + if (hdrInfo->state == HDMI_HDR_STATE_OE) { + HdmiCntlrAudioMuteEnable(cntlr, false); + HdmiCntlrBlackDataSet(cntlr, true); + } + HdmiCntlrAvmuteSet(cntlr, true); + if (hdrInfo->state == HDMI_HDR_STATE_OE) { + HdmiCntlrPhyOutputEnablet(cntlr, false); + } + HdmiHdrModeChangeTimerSet(cntlr, true); + HdmiCntlrHdrTimerSet(cntlr, &(hdrInfo->stateChangeTimer)); + (void)HdmiDrmInfoFrameSend(&(cntlr->infoFrame), false); + } else { + /* start timer, send zero DRMIF and stop after 2 seconds. */ + HdmiHdrZeroDrmInfoFrameTimerSet(cntlr, true); + } + break; + case HDMI_HDR_MODE_CEA_861_3_AUTHEN: + case HDMI_HDR_MODE_DOLBY_NORMAL: + case HDMI_HDR_MODE_DOLBY_TUNNELING: + if (oldAttr->mode != HDMI_HDR_MODE_DOLBY_NORMAL) { + commAttr->colorSpace = HDMI_COLOR_SPACE_YCBCR444; + } + videoAttr->quantization = HDMI_QUANTIZATION_RANGE_DEFAULT; + videoAttr->yccQuantization = HDMI_YCC_QUANTIZATION_RANGE_LIMITED; + break; + default: + ret = HDF_FAILURE; + break; + } + return ret; +} + +static void HdmiChangeToHdr(struct HdmiCntlr *cntlr, struct HdmiCommonAttr *commAttr) +{ + struct HdmiHdrAttr *hdrAttr = &(cntlr->attr.hdrAttr); + struct HdmiHdrInfo *hdrInfo = &(cntlr->hdr->info); + + HdmiHdrZeroDrmInfoFrameTimerSet(cntlr, false); + if (hdrAttr->userMode != HDMI_HDR_USERMODE_HDR10) { + HDF_LOGE("usermode is not HDR10/HLG."); + return; + } + commAttr->drm = true; + + if (hdrInfo->state != HDMI_HDR_STATE_NONE) { + /* to solve the problem of some TV can not switch smoothly from non-HDR10 to HDR10. */ + if (hdrInfo->state == HDMI_HDR_STATE_OE) { + HdmiCntlrAudioMuteEnable(cntlr, false); + HdmiCntlrBlackDataSet(cntlr, true); + } + HdmiCntlrAvmuteSet(cntlr, true); + if (hdrInfo->state == HDMI_HDR_STATE_OE) { + HdmiCntlrPhyOutputEnablet(cntlr, false); + } + hdrInfo->stateChangeTimer.start = true; + hdrInfo->stateChangeTimer.timerType = HDMI_HDR_TIMER_SDR_TO_HDR10; + hdrInfo->stateChangeTimer.time = HDMI_HDR_STATE_CHANGE_TIME; + HdmiCntlrHdrTimerSet(cntlr, &(hdrInfo->stateChangeTimer)); + } +} + +static int32_t HdmiHdrModeSelect(struct HdmiCntlr *cntlr) +{ + struct HdmiHdrAttr *hdrAttr = &(cntlr->attr.hdrAttr); + struct HdmiCommonAttr *commAttr = &(cntlr->attr.commAttr); + + switch (hdrAttr->mode) { + case HDMI_HDR_MODE_CEA_861_3: + HdmiChangeToHdr(cntlr, commAttr); + commAttr->vsifDolby = false; + break; + case HDMI_HDR_MODE_CEA_861_3_AUTHEN: + /* HDR10 authen mode, HDMI must bypass. */ + if (hdrAttr->userMode != HDMI_HDR_USERMODE_DOLBY) { + HDF_LOGE("user mode is not dolby"); + return HDF_FAILURE; + } + commAttr->drm = true; + commAttr->vsifDolby = false; + break; + case HDMI_HDR_MODE_DOLBY_NORMAL: + case HDMI_HDR_MODE_DOLBY_TUNNELING: + if (hdrAttr->userMode != HDMI_HDR_USERMODE_DOLBY) { + HDF_LOGE("user mode is not dolby"); + return HDF_FAILURE; + } + commAttr->drm = false; + commAttr->vsifDolby = true; + break; + default: + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t HdmiHdrAttrHandle(struct HdmiHdr *hdr, struct HdmiHdrAttr *curAttr) +{ + struct HdmiHdrAttr *oldAttr = NULL; + struct HdmiCommonAttr *commAttr = NULL; + struct HdmiCntlr *cntlr = NULL; + int32_t ret = HDF_FAILURE; + + if (hdr == NULL || hdr->priv == NULL) { + HDF_LOGE("hdr attr handle, input param invalid."); + return HDF_ERR_INVALID_PARAM; + } + + cntlr = (struct HdmiCntlr *)hdr->priv; + oldAttr = &(cntlr->attr.hdrAttr); + commAttr = &(cntlr->attr.commAttr); + if (HdmiHdrAttrChange(curAttr, oldAttr) == false) { + HDF_LOGD("hdr attr not change"); + return HDF_SUCCESS; + } + + if (oldAttr->colorimetry != curAttr->colorimetry) { + HdmiHdrColorimetryUpdate(&(cntlr->attr.videoAttr), curAttr->colorimetry); + } + + /* change to SDR */ + if (curAttr->mode == HDMI_HDR_MODE_DISABLE) { + if (HdmiDisableHdr(cntlr, curAttr) == HDF_SUCCESS) { + commAttr->vsifDolby = false; + cntlr->attr.hdrAttr = *curAttr; + goto _SEND_INFOFRAME; + } else { + return HDF_FAILURE; + } + } + + /* change to HDR */ + cntlr->attr.hdrAttr = *curAttr; + ret = HdmiHdrModeSelect(cntlr); + if (ret != HDF_SUCCESS) { + return ret; + } + (void)HdmiDrmInfoFrameSend(&(cntlr->infoFrame), (commAttr->enableHdmi && commAttr->drm)); + +_SEND_INFOFRAME: + (void)HdmiAviInfoFrameSend(&(cntlr->infoFrame), (commAttr->enableHdmi && commAttr->avi)); + (void)HdmiVsInfoFrameSend(&(cntlr->infoFrame), commAttr->enableHdmi, commAttr->vsifDolby); + HdmiCntlrVideoPathSet(cntlr, &(cntlr->attr.videoAttr)); + return ret; +} + +int32_t HdmiHdrDrmInfoFrameStop(struct HdmiHdr *hdr) +{ + struct HdmiCntlr *cntlr = NULL; + + HDF_LOGD("zero DRM infoFrame send timeout."); + if (hdr == NULL || hdr->priv == NULL) { + HDF_LOGE("hdr stop drm, input param invalid."); + return HDF_ERR_INVALID_PARAM; + } + cntlr = (struct HdmiCntlr *)hdr->priv; + + if (cntlr->attr.hdrAttr.mode != HDMI_HDR_MODE_CEA_861_3) { + return HdmiDrmInfoFrameSend(&(cntlr->infoFrame), false); + } + return HDF_SUCCESS; +} + +int32_t HdmiHdrModeChangeTimeout(struct HdmiHdr *hdr) +{ + struct HdmiCntlr *cntlr = NULL; + + HDF_LOGD("hdr mode change timeout."); + if (hdr == NULL || hdr->priv == NULL) { + HDF_LOGE("hdr mode change timeout, input param invalid."); + return HDF_ERR_INVALID_PARAM; + } + cntlr = (struct HdmiCntlr *)hdr->priv; + + if (hdr->info.state == HDMI_HDR_STATE_OE) { + HdmiCntlrPhyOutputEnablet(cntlr, true); + } + HdmiCntlrAvmuteSet(cntlr, false); + if (hdr->info.state == HDMI_HDR_STATE_OE) { + HdmiCntlrBlackDataSet(cntlr, false); + HdmiCntlrAudioMuteEnable(cntlr, true); + } + return HDF_SUCCESS; +} diff --git a/support/platform/src/hdmi/hdmi_if.c b/support/platform/src/hdmi/hdmi_if.c new file mode 100644 index 0000000000000000000000000000000000000000..9a3d7a7f3a2e6ff722c04c7b0ae13e37d62c12cc --- /dev/null +++ b/support/platform/src/hdmi/hdmi_if.c @@ -0,0 +1,566 @@ +/* + * Copyright (c) 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 "hdmi_if.h" +#ifndef __USER__ +#include "hdmi_core.h" +#endif +#include "hdf_base.h" +#include "hdf_log.h" +#include "osal_mem.h" +#ifdef __USER__ +#include "hdf_io_service_if.h" +#include "securec.h" +#endif + +#define HDF_LOG_TAG hdmi_if_c + +#define HDMI_SERVICE_NAME_LEN 32 + +#ifdef __USER__ + +enum HdmiIoCmd { + HDMI_CMD_OPEN, + HDMI_CMD_CLOSE, + HDMI_CMD_START, + HDMI_CMD_STOP, + HDMI_CMD_AVMUTE_SET, + HDMI_CMD_DEEP_COLOR_SET, + HDMI_CMD_DEEP_COLOR_GET, + HDMI_CMD_VIDEO_ATTR_SET, + HDMI_CMD_AUDIO_ATTR_SET, + HDMI_CMD_HDR_ATTR_SET, + HDMI_CMD_READ_SINK_EDID, + HDMI_CMD_INFOFRAME_SET, + HDMI_CMD_INFOFRAME_GET, + HDMI_CMD_REGISTER_HPD_CALLBACK_FUNC, + HDMI_CMD_UNREGISTER_HPD_CALLBACK_FUNC, + HDMI_CMD_BUTT, +}; + +static int32_t HdmiGetDataFromReply(struct HdfSBuf *reply, uint8_t *data, uint32_t size) +{ + uint32_t rLen; + const void *rBuf = NULL; + + if (HdfSbufReadBuffer(reply, &rBuf, &rLen) == false) { + HDF_LOGE("HdmiGetDataFromReply: read rBuf fail!"); + return HDF_ERR_IO; + } + if (size != rLen) { + HDF_LOGE("HdmiGetDataFromReply: err len:%u, rLen:%u", size, rLen); + if (rLen > size) { + rLen = size; + } + } + + if (memcpy_s(data, size, rBuf, rLen) != EOK) { + HDF_LOGE("HdmiGetDataFromReply: memcpy rBuf fail!"); + return HDF_ERR_IO; + } + return HDF_SUCCESS; +} + +static void HdmiUserClose(DevHandle handle) +{ + struct HdfIoService *service = (struct HdfIoService *)handle; + int32_t ret; + + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + HDF_LOGE("HdmiUserClose: service is invalid"); + return; + } + + ret = service->dispatcher->Dispatch(&service->object, HDMI_CMD_CLOSE, NULL, NULL); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiUserClose: failed to send service call:%d", ret); + } +} + +static int32_t HdmiUserStart(DevHandle handle) +{ + struct HdfIoService *service = (struct HdfIoService *)handle; + int32_t ret; + + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + HDF_LOGE("HdmiUserStart: service is invalid"); + return HDF_ERR_INVALID_PARAM; + } + + ret = service->dispatcher->Dispatch(&service->object, HDMI_CMD_START, NULL, NULL); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiUserStart: failed to send service call:%d", ret); + return ret; + } + return HDF_SUCCESS; +} + +static int32_t HdmiUserStop(DevHandle handle) +{ + struct HdfIoService *service = (struct HdfIoService *)handle; + int32_t ret; + + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + HDF_LOGE("HdmiUserStop: service is invalid"); + return HDF_ERR_INVALID_PARAM; + } + + ret = service->dispatcher->Dispatch(&service->object, HDMI_CMD_STOP, NULL, NULL); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiUserStop: failed to send service call:%d", ret); + return ret; + } + return HDF_SUCCESS; +} + +static int32_t HdmiUserAvmuteSet(DevHandle handle, bool enable) +{ + int32_t ret; + struct HdfSBuf *buf = NULL; + struct HdfIoService *service = (struct HdfIoService *)handle; + + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + HDF_LOGE("HdmiUserAvmuteSet: service is invalid"); + return HDF_ERR_INVALID_PARAM; + } + + buf = HdfSBufObtain(sizeof(enable)); + if (buf == NULL) { + HDF_LOGE("HdmiUserAvmuteSet: failed to obtain buf"); + return HDF_ERR_MALLOC_FAIL; + } + if (!HdfSbufWriteBuffer(buf, &enable, sizeof(enable))) { + HDF_LOGE("HdmiUserAvmuteSet: sbuf write buffer failed"); + HdfSBufRecycle(buf); + return HDF_ERR_IO; + } + + ret = service->dispatcher->Dispatch(&service->object, HDMI_CMD_AVMUTE_SET, buf, NULL); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiUserAvmuteSet: failed to write, ret %d", ret); + } + HdfSBufRecycle(buf); + return ret; +} + +static int32_t HdmiUserDeepColorSet(DevHandle handle, enum HdmiDeepColor color) +{ + int32_t ret; + struct HdfSBuf *buf = NULL; + struct HdfIoService *service = (struct HdfIoService *)handle; + + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + HDF_LOGE("HdmiUserDeepColorSet: service is invalid"); + return HDF_ERR_INVALID_PARAM; + } + + buf = HdfSBufObtain(sizeof(color)); + if (buf == NULL) { + HDF_LOGE("HdmiUserDeepColorSet: failed to obtain buf"); + return HDF_ERR_MALLOC_FAIL; + } + if (!HdfSbufWriteBuffer(buf, &color, sizeof(color))) { + HDF_LOGE("HdmiUserDeepColorSet: sbuf write color failed"); + HdfSBufRecycle(buf); + return HDF_ERR_IO; + } + + ret = service->dispatcher->Dispatch(&service->object, HDMI_CMD_DEEP_COLOR_SET, buf, NULL); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiUserDeepColorSet: failed to write, ret %d", ret); + } + HdfSBufRecycle(buf); + return ret; +} + +static int32_t HdmiUserSetVideoAttribute(DevHandle handle, struct HdmiVideoAttr *attr) +{ + int32_t ret; + struct HdfSBuf *buf = NULL; + struct HdfIoService *service = (struct HdfIoService *)handle; + + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + HDF_LOGE("HdmiUserSetVideoAttribute: service is invalid"); + return HDF_ERR_INVALID_PARAM; + } + if (attr == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + buf = HdfSBufObtain(sizeof(struct HdmiVideoAttr)); + if (buf == NULL) { + HDF_LOGE("HdmiUserSetVideoAttribute: failed to obtain buf"); + return HDF_ERR_MALLOC_FAIL; + } + if (!HdfSbufWriteBuffer(buf, attr, sizeof(struct HdmiVideoAttr))) { + HDF_LOGE("HdmiUserSetVideoAttribute: sbuf write attr failed"); + HdfSBufRecycle(buf); + return HDF_ERR_IO; + } + + ret = service->dispatcher->Dispatch(&service->object, HDMI_CMD_VIDEO_ATTR_SET, buf, NULL); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiUserSetVideoAttribute: failed to write, ret %d", ret); + } + HdfSBufRecycle(buf); + return ret; +} + +static int32_t HdmiUserSetAudioAttribute(DevHandle handle, struct HdmiAudioAttr *attr) +{ + int32_t ret; + struct HdfSBuf *buf = NULL; + struct HdfIoService *service = (struct HdfIoService *)handle; + + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + HDF_LOGE("HdmiUserSetAudioAttribute: service is invalid"); + return HDF_ERR_INVALID_PARAM; + } + if (attr == NULL) { + HDF_LOGE("HdmiUserSetAudioAttribute: attr is NULL"); + return HDF_ERR_INVALID_PARAM; + } + + buf = HdfSBufObtain(sizeof(struct HdmiAudioAttr)); + if (buf == NULL) { + HDF_LOGE("HdmiUserSetAudioAttribute: failed to obtain buf"); + return HDF_ERR_MALLOC_FAIL; + } + if (!HdfSbufWriteBuffer(buf, attr, sizeof(struct HdmiAudioAttr))) { + HDF_LOGE("HdmiUserSetAudioAttribute: sbuf write attr failed"); + HdfSBufRecycle(buf); + return HDF_ERR_IO; + } + + ret = service->dispatcher->Dispatch(&service->object, HDMI_CMD_AUDIO_ATTR_SET, buf, NULL); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiUserSetAudioAttribute: failed to write, ret %d", ret); + } + HdfSBufRecycle(buf); + return ret; +} + +static int32_t HdmiUserSetHdrAttribute(DevHandle handle, struct HdmiHdrAttr *attr) +{ + int32_t ret; + struct HdfSBuf *buf = NULL; + struct HdfIoService *service = (struct HdfIoService *)handle; + + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + HDF_LOGE("HdmiUserSetHdrAttribute: service is invalid"); + return HDF_ERR_INVALID_PARAM; + } + if (attr == NULL) { + HDF_LOGE("HdmiUserSetHdrAttribute: attr is NULL"); + return HDF_ERR_INVALID_PARAM; + } + + buf = HdfSBufObtain(sizeof(struct HdmiHdrAttr)); + if (buf == NULL) { + HDF_LOGE("HdmiUserSetHdrAttribute: failed to obtain buf"); + return HDF_ERR_MALLOC_FAIL; + } + if (!HdfSbufWriteBuffer(buf, attr, sizeof(struct HdmiHdrAttr))) { + HDF_LOGE("HdmiUserSetHdrAttribute: sbuf write attr failed"); + HdfSBufRecycle(buf); + return HDF_ERR_IO; + } + + ret = service->dispatcher->Dispatch(&service->object, HDMI_CMD_HDR_ATTR_SET, buf, NULL); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiUserSetAudioAttribute: failed to write, ret %d", ret); + } + HdfSBufRecycle(buf); + return ret; +} + +static int32_t HdmiUserDeepColorGet(DevHandle handle, enum HdmiDeepColor *color) +{ + int32_t ret; + struct HdfSBuf *reply = NULL; + struct HdfIoService *service = (struct HdfIoService *)handle; + + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + HDF_LOGE("HdmiUserDeepColorGet: service is invalid"); + return HDF_ERR_INVALID_PARAM; + } + if (color == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + /* Four bytes are used to store the buffer length, and four bytes are used to align the memory. */ + reply = HdfSBufObtain(sizeof(*color) + sizeof(uint64_t)); + if (reply == NULL) { + HDF_LOGE("HdmiUserDeepColorGet: failed to obtain reply"); + ret = HDF_ERR_MALLOC_FAIL; + goto __EXIT; + } + + ret = service->dispatcher->Dispatch(&service->object, HDMI_CMD_DEEP_COLOR_GET, NULL, reply); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiUserDeepColorGet: failed to write, ret %d", ret); + } else { + ret = HdmiGetDataFromReply(reply, (uint8_t *)color, sizeof(*color)); + } + +__EXIT : + if (reply != NULL) { + HdfSBufRecycle(reply); + } + return ret; +} + +static int32_t HdmiUserGetSinkEdid(DevHandle handle, uint8_t *buffer, uint32_t len) +{ + int32_t ret; + struct HdfSBuf *reply = NULL; + struct HdfIoService *service = (struct HdfIoService *)handle; + + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + HDF_LOGE("HdmiUserGetSinkEdid: service is invalid"); + return HDF_ERR_INVALID_PARAM; + } + if (buffer == NULL || len == 0) { + return HDF_ERR_INVALID_PARAM; + } + + reply = HdfSBufObtain(len); + if (reply == NULL) { + HDF_LOGE("HdmiUserGetSinkEdid: failed to obtain reply"); + ret = HDF_ERR_MALLOC_FAIL; + goto __EXIT; + } + + ret = service->dispatcher->Dispatch(&service->object, HDMI_CMD_READ_SINK_EDID, NULL, reply); + if (ret <= 0) { + HDF_LOGE("HdmiUserGetSinkEdid: failed to write, ret %d", ret); + } else { + ret = HdmiGetDataFromReply(reply, buffer, len); + } + +__EXIT : + if (reply != NULL) { + HdfSBufRecycle(reply); + } + return ret; +} + +static int32_t HdmiUserRegisterHpdCallbackFunc(DevHandle handle, struct HdmiHpdCallbackInfo *callback) +{ + int32_t ret; + struct HdfSBuf *buf = NULL; + struct HdfIoService *service = (struct HdfIoService *)handle; + uint32_t addr = (uint32_t)(uintptr_t)callback; + + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + HDF_LOGE("HdmiUserRegisterHpdCallbackFunc: service is invalid"); + return HDF_ERR_INVALID_PARAM; + } + if (callback == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + buf = HdfSBufObtain(sizeof(uint32_t)); + if (buf == NULL) { + HDF_LOGE("HdmiUserRegisterHpdCallbackFunc: failed to obtain buf"); + return HDF_ERR_MALLOC_FAIL; + } + if (!HdfSbufWriteBuffer(buf, (void *)&addr, sizeof(uint32_t))) { + HDF_LOGE("HdmiUserRegisterHpdCallbackFunc: sbuf write attr failed"); + HdfSBufRecycle(buf); + return HDF_ERR_IO; + } + + ret = service->dispatcher->Dispatch(&service->object, HDMI_CMD_REGISTER_HPD_CALLBACK_FUNC, buf, NULL); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiUserRegisterHpdCallbackFunc: failed to write, ret %d", ret); + } + HdfSBufRecycle(buf); + return ret; +} + +static int32_t HdmiUserUnregisterHpdCallbackFunc(DevHandle handle) +{ + struct HdfIoService *service = (struct HdfIoService *)handle; + int32_t ret; + + if (service == NULL || service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + HDF_LOGE("HdmiUserUnregisterHpdCallbackFunc: service is invalid"); + return HDF_ERR_INVALID_PARAM; + } + + ret = service->dispatcher->Dispatch(&service->object, HDMI_CMD_UNREGISTER_HPD_CALLBACK_FUNC, NULL, NULL); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiUserUnregisterHpdCallbackFunc: failed to send service call:%d", ret); + return ret; + } + return HDF_SUCCESS; +} +#endif + +static void *HdmiCntlrObjGet(uint16_t busNum) +{ + char *serviceName = NULL; + void *obj = NULL; + + serviceName = (char *)OsalMemCalloc(HDMI_SERVICE_NAME_LEN + 1); + if (serviceName == NULL) { + HDF_LOGE("HDMI service name malloc fail."); + return NULL; + } + if (snprintf_s(serviceName, (HDMI_SERVICE_NAME_LEN + 1), + HDMI_SERVICE_NAME_LEN, "HDF_PLATFORM_HDMI_%d", busNum) < 0) { + HDF_LOGE("get HDMI service name fail."); + goto __ERR; + } +#ifdef __USER__ + obj = (void *)HdfIoServiceBind(serviceName); +#else + obj = (void *)HdmiCntlrGetByBusNum(busNum); +#endif +__ERR: + OsalMemFree(serviceName); + return obj; +} + +DevHandle HdmiOpen(uint16_t busNum) +{ + DevHandle *obj = (DevHandle *)HdmiCntlrObjGet(busNum); + int32_t ret; + + if (obj == NULL) { + return NULL; + } +#ifdef __USER__ + struct HdfIoService *service = (struct HdfIoService *)obj; + if (service->dispatcher == NULL || service->dispatcher->Dispatch == NULL) { + HDF_LOGE("HdmiOpen: dispatcher or Dispatch is NULL!"); + return NULL; + } + ret = service->dispatcher->Dispatch(&service->object, HDMI_CMD_OPEN, NULL, NULL); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdmiOpen: failed to send service call:%d", ret); + return NULL; + } +#else + ret = HdmiCntlrOpen((struct HdmiCntlr *)obj); + if (ret != HDF_SUCCESS) { + return NULL; + } +#endif + return obj; +} + +int32_t HdmiStart(DevHandle handle) +{ +#ifdef __USER__ + return HdmiUserStart(handle); +#else + return HdmiCntlrStart((struct HdmiCntlr *)handle); +#endif +} + +int32_t HdmiStop(DevHandle handle) +{ +#ifdef __USER__ + return HdmiUserStop(handle); +#else + return HdmiCntlrStop((struct HdmiCntlr *)handle); +#endif +} + +int32_t HdmiAvmuteSet(DevHandle handle, bool enable) +{ +#ifdef __USER__ + return HdmiUserAvmuteSet(handle, enable); +#else + HdmiCntlrAvmuteSet((struct HdmiCntlr *)handle, enable); + return HDF_SUCCESS; +#endif +} + +int32_t HdmiDeepColorSet(DevHandle handle, enum HdmiDeepColor color) +{ +#ifdef __USER__ + return HdmiUserDeepColorSet(handle, color); +#else + return HdmiCntlrDeepColorSet((struct HdmiCntlr *)handle, color); +#endif +} + +int32_t HdmiDeepColorGet(DevHandle handle, enum HdmiDeepColor *color) +{ +#ifdef __USER__ + return HdmiUserDeepColorGet(handle, color); +#else + return HdmiCntlrDeepColorGet((struct HdmiCntlr *)handle, color); +#endif +} + +int32_t HdmiSetVideoAttribute(DevHandle handle, struct HdmiVideoAttr *attr) +{ +#ifdef __USER__ + return HdmiUserSetVideoAttribute(handle, attr); +#else + return HdmiCntlrSetVideoAttribute((struct HdmiCntlr *)handle, attr); +#endif +} + +int32_t HdmiSetAudioAttribute(DevHandle handle, struct HdmiAudioAttr *attr) +{ +#ifdef __USER__ + return HdmiUserSetAudioAttribute(handle, attr); +#else + return HdmiCntlrSetAudioAttribute((struct HdmiCntlr *)handle, attr); +#endif +} + +int32_t HdmiSetHdrAttribute(DevHandle handle, struct HdmiHdrAttr *attr) +{ +#ifdef __USER__ + return HdmiUserSetHdrAttribute(handle, attr); +#else + return HdmiCntlrSetHdrAttribute((struct HdmiCntlr *)handle, attr); +#endif +} + +int32_t HdmiReadSinkEdid(DevHandle handle, uint8_t *buffer, uint32_t len) +{ +#ifdef __USER__ + return HdmiUserGetSinkEdid(handle, buffer, len); +#else + return HdmiCntlrGetSinkEdid((struct HdmiCntlr *)handle, buffer, len); +#endif +} + +int32_t HdmiRegisterHpdCallbackFunc(DevHandle handle, struct HdmiHpdCallbackInfo *callback) +{ +#ifdef __USER__ + return HdmiUserRegisterHpdCallbackFunc(handle, callback); +#else + return HdmiCntlrRegisterHpdCallbackFunc((struct HdmiCntlr *)handle, callback); +#endif +} + +int32_t HdmiUnregisterHpdCallbackFunc(DevHandle handle) +{ +#ifdef __USER__ + return HdmiUserUnregisterHpdCallbackFunc(handle); +#else + return HdmiCntlrUnregisterHpdCallbackFunc((struct HdmiCntlr *)handle); +#endif +} + +void HdmiClose(DevHandle handle) +{ +#ifdef __USER__ + HdmiUserClose(handle); +#else + HdmiCntlrClose((struct HdmiCntlr *)handle); +#endif +} diff --git a/support/platform/src/hdmi/hdmi_infoframe.c b/support/platform/src/hdmi/hdmi_infoframe.c new file mode 100644 index 0000000000000000000000000000000000000000..f6207f944a4b1df94dd5d5d92d2aff8a7b258498 --- /dev/null +++ b/support/platform/src/hdmi/hdmi_infoframe.c @@ -0,0 +1,832 @@ +/* + * Copyright (c) 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_log.h" +#include "hdmi_core.h" +#include "securec.h" + +#define HDF_LOG_TAG hdmi_infoframe_c + +#define HDMI_IEEE_OUI_1_4_1ST 0x03 +#define HDMI_IEEE_OUI_1_4_2ND 0x0C +#define HDMI_IEEE_OUI_1_4_3RD 0x00 + +static void HdmiInfoFrameFillCheckSum(uint8_t *data, uint32_t len) +{ + uint32_t i; + uint8_t checkSum = 0; + + for (i = 0; i < len; i++) { + checkSum += data[i]; + } + if (checkSum > 0) { + /* + * The checksum shall be calculated such that a byte-wide sum of all three bytes of the Packet Header and + * all valid bytes of the InfoFrame Packet contents(determined by InfoFrame_length), plus the checksum itself, + * equals zero. + */ + data[UINT8_ARRAY_TElEMENT_3] = HDMI_INFOFRAME_CHECKSUM - checkSum; + } +} + +static void HdmiInfoFrameFillHeader(struct HdmiInfoFrameHeader *header, uint8_t *data, uint32_t len) +{ + if (len < HDMI_INFOFRAME_PACKET_HEADER_LEN) { + HDF_LOGE("len = %d, val is too small.", len); + return; + } + data[UINT8_ARRAY_TElEMENT_0] = header->type; + data[UINT8_ARRAY_TElEMENT_1] = header->verNum; + data[UINT8_ARRAY_TElEMENT_2] = header->len; +} + +static int32_t HdmiInfoFramePacketVsEncoding(union HdmiInfoFrameInfo *infoFrame, uint8_t *data, uint32_t len) +{ + uint32_t lenght; + struct HdmiVs14VsifContent *vsifContent = NULL; + struct HdmiVsUserVsifContent *userContent = NULL; + struct HdmiVsInfoFrame *vs = &(infoFrame->vs); + + lenght = HDMI_INFOFRAME_PACKET_HEADER_LEN + vs->len; + if (len < lenght) { + HDF_LOGE("len = %d, val is too small.", len); + return HDF_ERR_INVALID_PARAM; + } + if (memset_s(data, len, 0, len) != EOK) { + HDF_LOGE("memset_s fail."); + return HDF_ERR_IO; + } + + HdmiInfoFrameFillHeader(&(infoFrame->header), data, len); + if (vs->vsifContent.vsif.oui == HDMI_IEEE_OUI_1_4) { + data[UINT8_ARRAY_TElEMENT_4] = HDMI_IEEE_OUI_1_4_1ST; + data[UINT8_ARRAY_TElEMENT_5] = HDMI_IEEE_OUI_1_4_2ND; + data[UINT8_ARRAY_TElEMENT_6] = HDMI_IEEE_OUI_1_4_3RD; + vsifContent = &(vs->vsifContent.vsif); + userContent = &(vs->vsifContent.userVsif); + data[UINT8_ARRAY_TElEMENT_7] = ((uint8_t)vsifContent->format & HDMI_VENDOR_1_4_FORMAT_MARK) << + HDMI_VENDOR_1_4_FORMAT_SHIFT; + if (vsifContent->format == HDMI_VS_VIDEO_FORMAT_4K) { + data[UINT8_ARRAY_TElEMENT_8] = vsifContent->vic; + return HDF_SUCCESS; + } else if (vsifContent->format == HDMI_VS_VIDEO_FORMAT_3D) { + data[UINT8_ARRAY_TElEMENT_8] = ((uint8_t)vsifContent->_3dStruct & HDMI_VENDOR_3D_STRUCTURE_MARK) << + HDMI_VENDOR_3D_STRUCTURE_SHIFT; + } + data[UINT8_ARRAY_TElEMENT_9] = ((uint8_t)vsifContent->_3dExtData & HDMI_VENDOR_3D_EXT_DATA_MARK) << + HDMI_VENDOR_3D_EXT_DATA_SHIFT; + if (vsifContent->_3dMetaPresent == false) { + if (userContent->len == 0 || (userContent->len + lenght) > len) { + return HDF_SUCCESS; + } + if (memcpy_s(&data[lenght], (len - lenght), userContent->data, userContent->len) != EOK) { + HDF_LOGE("memcpy_s fail."); + return HDF_ERR_IO; + } + lenght += userContent->len; + } + } + HdmiInfoFrameFillCheckSum(data, lenght); + return HDF_SUCCESS; +} + +static int32_t HdmiInfoFramePacketAviEncoding(union HdmiInfoFrameInfo *infoFrame, uint8_t *data, uint32_t len) +{ + uint32_t lenght; + uint8_t *buff = data; + struct HdmiAviInfoFrame *avi = &(infoFrame->avi); + + lenght = HDMI_INFOFRAME_PACKET_HEADER_LEN + avi->len; + if (len < lenght) { + HDF_LOGE("len = %d, val is too small.", len); + return HDF_ERR_INVALID_PARAM; + } + if (memset_s(buff, len, 0, len) != EOK) { + HDF_LOGE("memset_s fail."); + return HDF_ERR_IO; + } + + HdmiInfoFrameFillHeader(&(infoFrame->header), data, len); + buff += HDMI_INFOFRAME_PACKET_HEADER_LEN; + /* PB1 */ + buff[UINT8_ARRAY_TElEMENT_0] |= (avi->colorSpace & HDMI_AVI_COLOR_SPACE_MARK) << HDMI_AVI_COLOR_SPACE_SHIFT; + buff[UINT8_ARRAY_TElEMENT_0] |= ((uint8_t)avi->scanMode & HDMI_AVI_SCAN_MODE_MARK); + if (avi->activeFormatInformationPresent == true) { + buff[UINT8_ARRAY_TElEMENT_0] |= (1 << HDMI_AVI_ACTIVE_INFORMATION_SHIFT); + } + if (avi->horizBarInfoPresent == true) { + buff[UINT8_ARRAY_TElEMENT_0] |= (1 << HDMI_AVI_HORIZONTAL_BAR_SHIFT); + } + if (avi->vertBarInfoPresent == true) { + buff[UINT8_ARRAY_TElEMENT_0] |= (1 << HDMI_AVI_VERTICAL_BAR_SHIFT); + } + /* PB2 */ + buff[UINT8_ARRAY_TElEMENT_1] |= ((uint8_t)avi->colorimetry & HDMI_AVI_COLORIMETRY_MARK) << HDMI_AVI_COLORIMETRY_SHIFT; + buff[UINT8_ARRAY_TElEMENT_1] |= ((uint8_t)avi->pictureAspect & HDMI_AVI_PICTURE_ASPECT_RATE_MARK) << + HDMI_AVI_PICTURE_ASPECT_RATE_SHIFT; + buff[UINT8_ARRAY_TElEMENT_1] |= ((uint8_t)avi->activeAspect & HDMI_AVI_ACTIVE_FORMAT_ASPECT_RATE_MARK); + /* PB3 */ + buff[UINT8_ARRAY_TElEMENT_2] |= ((uint8_t)avi->extColorimetry & HDMI_AVI_EXT_COLORIMETRY_MARK) << + HDMI_AVI_EXT_COLORIMETRY_SHIFT; + buff[UINT8_ARRAY_TElEMENT_2] |= ((uint8_t)avi->range & HDMI_AVI_EXT_QUANTIZATION_RANGE_MARK) << + HDMI_AVI_EXT_QUANTIZATION_RANGE_SHIFT; + buff[UINT8_ARRAY_TElEMENT_2] |= ((uint8_t)avi->nups & HDMI_AVI_NUPS_RANGE_MARK); + if (avi->itc == true) { + buff[UINT8_ARRAY_TElEMENT_2] |= (1 << HDMI_AVI_IT_CONTENT_SHIFT); + } + /* PB4 */ + buff[UINT8_ARRAY_TElEMENT_3] = avi->vic; + /* PB5 */ + buff[UINT8_ARRAY_TElEMENT_4] |= ((uint8_t)avi->yccRange & HDMI_AVI_YCC_QUANTIZATION_RANGE_MARK) << + HDMI_AVI_YCC_QUANTIZATION_RANGE_SHIFT; + buff[UINT8_ARRAY_TElEMENT_4] |= ((uint8_t)avi->itcType & HDMI_AVI_IT_CONTENT_TYPE_MARK) << + HDMI_AVI_IT_CONTENT_TYPE_SHIFT; + buff[UINT8_ARRAY_TElEMENT_4] |= (avi->pixelRepetitionFactor & HDMI_AVI_PIXEL_REPETION_FACTOR_MARK); + /* PB6 */ + buff[UINT8_ARRAY_TElEMENT_5] = (uint8_t)(avi->topBar & HDMI_AVI_BAR_MODE_MARK); + /* PB7 */ + buff[UINT8_ARRAY_TElEMENT_6] = (uint8_t)((avi->topBar >> HDMI_AVI_BAR_MODE_SHIFT) & HDMI_AVI_BAR_MODE_MARK); + /* PB8 */ + buff[UINT8_ARRAY_TElEMENT_7] = (uint8_t)(avi->bottomBar & HDMI_AVI_BAR_MODE_MARK); + /* PB9 */ + buff[UINT8_ARRAY_TElEMENT_8] = (uint8_t)((avi->bottomBar >> HDMI_AVI_BAR_MODE_SHIFT) & HDMI_AVI_BAR_MODE_MARK); + /* PB10 */ + buff[UINT8_ARRAY_TElEMENT_9] = (uint8_t)(avi->leftBar & HDMI_AVI_BAR_MODE_MARK); + /* PB11 */ + buff[UINT8_ARRAY_TElEMENT_10] = (uint8_t)((avi->leftBar >> HDMI_AVI_BAR_MODE_SHIFT) & HDMI_AVI_BAR_MODE_MARK); + /* PB12 */ + buff[UINT8_ARRAY_TElEMENT_11] = (uint8_t)(avi->rightBar & HDMI_AVI_BAR_MODE_MARK); + /* PB13 */ + buff[UINT8_ARRAY_TElEMENT_12] = (uint8_t)((avi->rightBar >> HDMI_AVI_BAR_MODE_SHIFT) & HDMI_AVI_BAR_MODE_MARK); + HdmiInfoFrameFillCheckSum(data, lenght); + return HDF_SUCCESS; +} + +static int32_t HdmiInfoFramePacketSpdEncoding(union HdmiInfoFrameInfo *infoFrame, uint8_t *data, uint32_t len) +{ + uint32_t lenght; + uint8_t *buff = data; + struct HdmiSpdInfoFrame *spd = &(infoFrame->spd); + + lenght = HDMI_INFOFRAME_PACKET_HEADER_LEN + spd->len; + if (len < lenght) { + HDF_LOGE("len = %d, val is too small.", len); + return HDF_ERR_INVALID_PARAM; + } + if (memset_s(buff, len, 0, len) != EOK) { + HDF_LOGE("memset_s fail."); + return HDF_ERR_IO; + } + + buff += HDMI_INFOFRAME_PACKET_HEADER_LEN; + /* PB1~PB8 */ + if (memcpy_s(buff, (len - HDMI_INFOFRAME_PACKET_HEADER_LEN), spd->vendorName, sizeof(spd->vendorName)) != EOK) { + HDF_LOGE("memcpy_s fail."); + return HDF_ERR_IO; + } + buff += HDMI_SPD_VENDOR_NAME_LEN; + /* PB9~PB24 */ + if (memcpy_s(buff, (len - HDMI_INFOFRAME_PACKET_HEADER_LEN - HDMI_SPD_VENDOR_NAME_LEN), + spd->productDescription, sizeof(spd->productDescription)) != EOK) { + HDF_LOGE("memcpy_s fail."); + return HDF_ERR_IO; + } + buff += HDMI_SPD_PRODUCT_DESCRIPTION_LEN; + /* PB25 */ + buff[UINT8_ARRAY_TElEMENT_0] = spd->sdi; + HdmiInfoFrameFillCheckSum(data, lenght); + return HDF_SUCCESS; +} + +static int32_t HdmiInfoFramePacketAudioEncoding(union HdmiInfoFrameInfo *infoFrame, uint8_t *data, uint32_t len) +{ + uint32_t lenght; + uint8_t *buff = data; + struct HdmiAudioInfoFrame *audio = &(infoFrame->audio); + + lenght = HDMI_INFOFRAME_PACKET_HEADER_LEN + audio->len; + if (len < lenght) { + HDF_LOGE("len = %d, val is too small.", len); + return HDF_ERR_INVALID_PARAM; + } + if (memset_s(buff, len, 0, len) != EOK) { + HDF_LOGE("memset_s fail."); + return HDF_ERR_IO; + } + + HdmiInfoFrameFillHeader(&(infoFrame->header), data, len); + buff += HDMI_INFOFRAME_PACKET_HEADER_LEN; + /* PB1 */ + buff[UINT8_ARRAY_TElEMENT_0] |= ((uint8_t)audio->codingType & HDMI_AUDIO_CODING_TYPE_MARK) << + HDMI_AUDIO_CODING_TYPE_SHIFT; + buff[UINT8_ARRAY_TElEMENT_0] |= ((uint8_t)audio->channelCount & HDMI_AUDIO_CHANNEL_COUNT_MARK); + /* PB2 */ + buff[UINT8_ARRAY_TElEMENT_1] |= ((uint8_t)audio->sampleFreq & HDMI_AUDIO_SAMPLE_FREQUENCY_MARK) << + HDMI_AUDIO_SAMPLE_FREQUENCY_SHIFT; + buff[UINT8_ARRAY_TElEMENT_1] |= ((uint8_t)audio->sampleSize & HDMI_AUDIO_SAMPLE_SIZE_MARK); + /* PB3 */ + buff[UINT8_ARRAY_TElEMENT_2] |= ((uint8_t)audio->codingExtType & HDMI_AUDIO_CXT_MARK); + /* PB4 */ + buff[UINT8_ARRAY_TElEMENT_3] |= audio->channelAllocation; + /* PB5 */ + buff[UINT8_ARRAY_TElEMENT_4] |= ((uint8_t)audio->levelShiftValue & HDMI_AUDIO_LEVEL_SHIFT_VALUE_MARK) << + HDMI_AUDIO_LEVEL_SHIFT_VALUE_SHIFT; + buff[UINT8_ARRAY_TElEMENT_4] |= ((uint8_t)audio->playBackLevel & HDMI_AUDIO_LEF_PLAYBACK_LEVEL_MARK); + if (audio->dmInh == true) { + buff[UINT8_ARRAY_TElEMENT_4] |= (1 << HDMI_AUDIO_DM_INH_SHIFT); + } + HdmiInfoFrameFillCheckSum(data, lenght); + return HDF_SUCCESS; +} + +static int32_t HdmiInfoFramePacketDrmEncoding(union HdmiInfoFrameInfo *infoFrame, uint8_t *data, uint32_t len) +{ + uint32_t lenght; + uint8_t *buff = data; + struct HdmiDrmInfoFrame *drm = &(infoFrame->drm); + struct HdmiStaticMetadataDescriptor1st *des = &(drm->des.type1); + + lenght = HDMI_INFOFRAME_PACKET_HEADER_LEN + drm->len; + if (len < lenght) { + HDF_LOGE("len = %d, val is too small.", len); + return HDF_ERR_INVALID_PARAM; + } + if (memset_s(buff, len, 0, len) != EOK) { + HDF_LOGE("memset_s fail."); + return HDF_ERR_IO; + } + + HdmiInfoFrameFillHeader(&(infoFrame->header), data, len); + buff += HDMI_INFOFRAME_PACKET_HEADER_LEN; + /* PB1 */ + buff[UINT8_ARRAY_TElEMENT_0] = drm->eotfType; + /* PB2 */ + buff[UINT8_ARRAY_TElEMENT_1] = drm->metadataType; + /* PB3 */ + buff[UINT8_ARRAY_TElEMENT_2] = (uint8_t)(des->displayPrimaries0X & HDMI_DRM_METADATA_MARK); + /* PB4 */ + buff[UINT8_ARRAY_TElEMENT_3] = (uint8_t)((des->displayPrimaries0X >> HDMI_DRM_METADATA_SHIFT) & + HDMI_DRM_METADATA_MARK); + /* PB5 */ + buff[UINT8_ARRAY_TElEMENT_4] = (uint8_t)(des->displayPrimaries0Y & HDMI_DRM_METADATA_MARK); + /* PB6 */ + buff[UINT8_ARRAY_TElEMENT_5] = (uint8_t)((des->displayPrimaries0Y & HDMI_DRM_METADATA_MARK) & + HDMI_DRM_METADATA_MARK); + /* PB7 */ + buff[UINT8_ARRAY_TElEMENT_6] = (uint8_t)(des->displayPrimaries1X & HDMI_DRM_METADATA_MARK); + /* PB8 */ + buff[UINT8_ARRAY_TElEMENT_7] = (uint8_t)((des->displayPrimaries1X & HDMI_DRM_METADATA_MARK) & + HDMI_DRM_METADATA_MARK); + /* PB9 */ + buff[UINT8_ARRAY_TElEMENT_8] = (uint8_t)(des->displayPrimaries1Y & HDMI_DRM_METADATA_MARK); + /* PB10 */ + buff[UINT8_ARRAY_TElEMENT_9] = (uint8_t)((des->displayPrimaries1Y & HDMI_DRM_METADATA_MARK) & + HDMI_DRM_METADATA_MARK); + /* PB11 */ + buff[UINT8_ARRAY_TElEMENT_10] = (uint8_t)(des->displayPrimaries2X & HDMI_DRM_METADATA_MARK); + /* PB12 */ + buff[UINT8_ARRAY_TElEMENT_11] = (uint8_t)((des->displayPrimaries2X & HDMI_DRM_METADATA_MARK) & + HDMI_DRM_METADATA_MARK); + /* PB13 */ + buff[UINT8_ARRAY_TElEMENT_12] = (uint8_t)(des->displayPrimaries2Y & HDMI_DRM_METADATA_MARK); + /* PB14 */ + buff[UINT8_ARRAY_TElEMENT_13] = (uint8_t)((des->displayPrimaries2Y & HDMI_DRM_METADATA_MARK) & + HDMI_DRM_METADATA_MARK); + /* PB15 */ + buff[UINT8_ARRAY_TElEMENT_14] = (uint8_t)(des->whitePointX & HDMI_DRM_METADATA_MARK); + /* PB16 */ + buff[UINT8_ARRAY_TElEMENT_15] = (uint8_t)((des->whitePointX & HDMI_DRM_METADATA_MARK) & HDMI_DRM_METADATA_MARK); + /* PB17 */ + buff[UINT8_ARRAY_TElEMENT_16] = (uint8_t)(des->whitePointY & HDMI_DRM_METADATA_MARK); + /* PB18 */ + buff[UINT8_ARRAY_TElEMENT_17] = (uint8_t)((des->whitePointY & HDMI_DRM_METADATA_MARK) & HDMI_DRM_METADATA_MARK); + /* PB19 */ + buff[UINT8_ARRAY_TElEMENT_18] = (uint8_t)(des->maxDisplayMasteringLuminance & HDMI_DRM_METADATA_MARK); + /* PB20 */ + buff[UINT8_ARRAY_TElEMENT_19] = (uint8_t)((des->maxDisplayMasteringLuminance & HDMI_DRM_METADATA_MARK) & + HDMI_DRM_METADATA_MARK); + /* PB21 */ + buff[UINT8_ARRAY_TElEMENT_20] = (uint8_t)(des->minDisplayMasteringLuminance & HDMI_DRM_METADATA_MARK); + /* PB22 */ + buff[UINT8_ARRAY_TElEMENT_21] = (uint8_t)((des->minDisplayMasteringLuminance & HDMI_DRM_METADATA_MARK) & + HDMI_DRM_METADATA_MARK); + /* PB23 */ + buff[UINT8_ARRAY_TElEMENT_22] = (uint8_t)(des->maxContentLightLevel & HDMI_DRM_METADATA_MARK); + /* PB24 */ + buff[UINT8_ARRAY_TElEMENT_23] = (uint8_t)((des->maxContentLightLevel & HDMI_DRM_METADATA_MARK) & + HDMI_DRM_METADATA_MARK); + /* PB25 */ + buff[UINT8_ARRAY_TElEMENT_24] = (uint8_t)(des->maxFrameAverageLightLevel & HDMI_DRM_METADATA_MARK); + /* PB26 */ + buff[UINT8_ARRAY_TElEMENT_25] = (uint8_t)((des->maxFrameAverageLightLevel & HDMI_DRM_METADATA_MARK) & + HDMI_DRM_METADATA_MARK); + HdmiInfoFrameFillCheckSum(data, lenght); + return HDF_SUCCESS; +} + +static int32_t HdmiInfoFramePacketEncoding(union HdmiInfoFrameInfo *infoFrame, + enum HdmiPacketType type, uint8_t *data, uint32_t len) +{ + int32_t ret; + + if (infoFrame == NULL || data == NULL) { + HDF_LOGE("input param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + + switch (type) { + case HDMI_INFOFRAME_PACKET_TYPE_VS: + ret = HdmiInfoFramePacketVsEncoding(infoFrame, data, len); + break; + case HDMI_INFOFRAME_PACKET_TYPE_AVI: + ret = HdmiInfoFramePacketAviEncoding(infoFrame, data, len); + break; + case HDMI_INFOFRAME_PACKET_TYPE_SPD: + ret = HdmiInfoFramePacketSpdEncoding(infoFrame, data, len); + break; + case HDMI_INFOFRAME_PACKET_TYPE_AUDIO: + ret = HdmiInfoFramePacketAudioEncoding(infoFrame, data, len); + break; + case HDMI_INFOFRAME_PACKET_TYPE_DRM: + ret = HdmiInfoFramePacketDrmEncoding(infoFrame, data, len); + break; + default: + HDF_LOGD("type %d not support.", type); + ret = HDF_ERR_NOT_SUPPORT; + } + return ret; +} + +static int32_t HdmiInfoFrameSend(struct HdmiInfoFrame *frame, union HdmiInfoFrameInfo *infoFrame) +{ + uint8_t buffer[HDMI_INFOFRAME_LEN] = {0}; + struct HdmiCntlr *cntlr = NULL; + int32_t ret; + + if (frame == NULL || frame->priv == NULL || infoFrame == NULL) { + HDF_LOGE("HdmiInfoFrameSend: input param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + cntlr = (struct HdmiCntlr *)frame->priv; + if (cntlr->ops == NULL || cntlr->ops->infoFrameSend == NULL || cntlr->ops->infoFrameEnable == NULL) { + HDF_LOGD("HdmiInfoFrameSend not support."); + return HDF_ERR_NOT_SUPPORT; + } + + ret = HdmiInfoFramePacketEncoding(infoFrame, infoFrame->header.type, buffer, HDMI_INFOFRAME_LEN); + if (ret != HDF_SUCCESS) { + HDF_LOGE("encding infoFrame %d fail", infoFrame->header.type); + return ret; + } + + HdmiCntlrLock(cntlr); + cntlr->ops->infoFrameEnable(cntlr, infoFrame->header.type, false); + ret = cntlr->ops->infoFrameSend(cntlr, infoFrame->header.type, buffer, HDMI_INFOFRAME_LEN); + if (ret != HDF_SUCCESS) { + HDF_LOGE("send infoFrame %d fail", infoFrame->header.type); + HdmiCntlrUnlock(cntlr); + return ret; + } + cntlr->ops->infoFrameEnable(cntlr, infoFrame->header.type, true); + HdmiCntlrUnlock(cntlr); + return HDF_SUCCESS; +} + +static void HdmiFillAviHdrInfoFrame(struct HdmiAviInfoFrame *avi, + struct HdmiVideoAttr *videoAttr, struct HdmiHdrAttr *hdrAttr, struct HdmiCommonAttr *commAttr) +{ + switch (hdrAttr->mode) { + case HDMI_HDR_MODE_CEA_861_3: + case HDMI_HDR_MODE_CEA_861_3_AUTHEN: + avi->colorimetry = videoAttr->colorimetry; + avi->extColorimetry = videoAttr->extColorimetry; + avi->colorSpace = commAttr->colorSpace; + if (hdrAttr->mode == HDMI_HDR_MODE_CEA_861_3_AUTHEN) { + avi->colorSpace = HDMI_COLOR_SPACE_YCBCR422; + } + avi->range = videoAttr->quantization; + avi->yccRange = videoAttr->yccQuantization; + break; + case HDMI_HDR_MODE_DOLBY_NORMAL: + avi->colorSpace = HDMI_COLOR_SPACE_YCBCR422; + avi->colorimetry = (videoAttr->xvycc == true) ? HDMI_COLORIMETRY_EXTENDED : videoAttr->colorimetry; + avi->extColorimetry = videoAttr->extColorimetry; + avi->range = videoAttr->quantization; + avi->yccRange = HDMI_YCC_QUANTIZATION_RANGE_FULL; + break; + case HDMI_HDR_MODE_DOLBY_TUNNELING: + avi->colorSpace = HDMI_COLOR_SPACE_RGB; + avi->colorimetry = (videoAttr->xvycc == true) ? HDMI_COLORIMETRY_EXTENDED : videoAttr->colorimetry; + avi->extColorimetry = videoAttr->extColorimetry; + avi->range = HDMI_QUANTIZATION_RANGE_FULL; + avi->yccRange = videoAttr->yccQuantization; + break; + default: + avi->colorSpace = commAttr->colorSpace; + avi->colorimetry = (videoAttr->xvycc == true) ? HDMI_COLORIMETRY_EXTENDED : videoAttr->colorimetry; + avi->extColorimetry = videoAttr->extColorimetry; + avi->range = videoAttr->quantization; + avi->yccRange = videoAttr->yccQuantization; + break; + } +} + +static void HdmiFillAviInfoFrameVersion(struct HdmiAviInfoFrame *avi) +{ + /* + * see hdmi spec2.0 10.1. + * The Y2 and VIC7 bits are simply set to zero in a Version 2 AVI InfoFrame and might not be decoded by + * some Sinks. A Version 3 AVI InfoFrame shall be used and the Version field set to 0x03 (indicating that + * the Sink shall decode the additional most-significant bits) whenever either of the most-significant bits + * Y2 or VIC7 are set to '1'. If both Y2 and VIC7 are set to '0', then a Version 2 AVI InfoFrame shall be used + * and the Version field shall be set to 0x02 (indicating that the Sink does not have to decode the additional + * most-significant bits). + */ + avi->verNum = HDMI_AVI_VERSION2; + if (((uint32_t)avi->colorSpace & HDMI_AVI_Y2_MASK) > 0 || + (avi->vic > HDMI_VIC_5120X2160P100_64_27)) { + avi->verNum = HDMI_AVI_VERSION3; + } else if (avi->colorimetry == HDMI_COLORIMETRY_EXTENDED && + avi->extColorimetry == HDMI_EXTENDED_COLORIMETRY_ADDITIONAL) { + /* + * (C1,C0) is (1,1) and (EC2,EC1,EC0) is (1,1,1), version shall be 4. + * All fields of the Version 4 AVI InfoFrame are the same as Version 3 AVI InfoFrame, + * except for the InfoFrame Version Number, Length of AVI InfoFrame, and additional Data Byte 14. + */ + avi->verNum = HDMI_AVI_VERSION4; + (avi->len)++; + } +} + +static void HdmiFillAviInfoFrame(struct HdmiAviInfoFrame *avi, + struct HdmiVideoAttr *videoAttr, struct HdmiHdrAttr *hdrAttr, struct HdmiCommonAttr *commAttr) +{ + bool enable3d = true; + + if (memset_s(avi, sizeof(struct HdmiAviInfoFrame), 0, sizeof(struct HdmiAviInfoFrame)) != EOK) { + HDF_LOGE("fill vsif, memset_s fail."); + return; + } + avi->type = HDMI_INFOFRAME_PACKET_TYPE_AVI; + avi->len = HDMI_AVI_INFOFRAME_LEN; + + avi->activeFormatInformationPresent = true; + avi->colorSpace = commAttr->colorSpace; + avi->activeAspect = videoAttr->activeAspect; + avi->pictureAspect = videoAttr->aspect; + avi->colorimetry = (videoAttr->xvycc == true) ? HDMI_COLORIMETRY_EXTENDED : videoAttr->colorimetry; + avi->nups = videoAttr->nups; + + avi->range = videoAttr->quantization; + avi->extColorimetry = videoAttr->extColorimetry; + if (videoAttr->_3dStruct >= HDMI_VS_VIDEO_3D_BUTT) { + enable3d = false; + } + avi->vic = HdmiCommonGetVic(videoAttr->timing, videoAttr->aspect, enable3d); + avi->pixelRepetitionFactor = (uint8_t)videoAttr->pixelRepeat; + avi->yccRange = videoAttr->yccQuantization; + HdmiFillAviHdrInfoFrame(avi, videoAttr, hdrAttr, commAttr); + HdmiFillAviInfoFrameVersion(avi); +} + +int32_t HdmiAviInfoFrameSend(struct HdmiInfoFrame *frame, bool enable) +{ + struct HdmiCntlr *cntlr = NULL; + union HdmiInfoFrameInfo infoFrame = {0}; + + if (frame == NULL || frame->priv == NULL) { + HDF_LOGE("HdmiAviInfoFrameSend: input param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + cntlr = (struct HdmiCntlr *)frame->priv; + if (cntlr->ops == NULL || cntlr->ops->infoFrameEnable == NULL || cntlr->ops->infoFrameSend == NULL) { + HDF_LOGD("HdmiAviInfoFrameSend not support."); + return HDF_ERR_NOT_SUPPORT; + } + + if (enable == false) { + cntlr->ops->infoFrameEnable(cntlr, HDMI_INFOFRAME_PACKET_TYPE_AVI, false); + return HDF_SUCCESS; + } + HdmiFillAviInfoFrame(&(frame->avi), &(cntlr->attr.videoAttr), &(cntlr->attr.hdrAttr), &(cntlr->attr.commAttr)); + infoFrame.avi = frame->avi; + return HdmiInfoFrameSend(frame, &infoFrame); +} + +void HdmiFillAudioInfoFrame(struct HdmiAudioInfoFrame *audio, struct HdmiAudioAttr *audioAttr) +{ + if (memset_s(audio, sizeof(struct HdmiAudioInfoFrame), 0, sizeof(struct HdmiAudioInfoFrame)) != EOK) { + HDF_LOGE("fill vsif, memset_s fail."); + return; + } + audio->type = HDMI_INFOFRAME_PACKET_TYPE_AUDIO; + audio->len = HDMI_AUDIO_INFOFRAME_LEN; + audio->verNum = HDMI_AUDIO_INFOFRAME_VERSION; + + /* fill channels. */ + if (audioAttr->ifType != HDMI_AUDIO_IF_TYPE_I2S) { + HDF_LOGI("audio channel refer to stream."); + } else { + HDF_LOGI("audio channel %u \n", audioAttr->channels); + audio->channelCount = (audioAttr->channels >= 2) ? (audioAttr->channels - 1) : 0; + } + + /* fill coding type. */ + if (audioAttr->codingType == HDMI_AUDIO_CODING_TYPE_AC3 || + audioAttr->codingType == HDMI_AUDIO_CODING_TYPE_DTS || + audioAttr->codingType == HDMI_AUDIO_CODING_TYPE_EAC3 || + audioAttr->codingType == HDMI_AUDIO_CODING_TYPE_DTS_HD) { + audio->codingType = audioAttr->codingType; + } else { + audio->codingType = HDMI_AUDIO_CODING_TYPE_STREAM; + } + + /* fill CA field. see CEA-861-D table 20. */ + switch (audioAttr->channels) { + case HDMI_AUDIO_FORMAT_CHANNEL_3: + audio->channelAllocation = 0x01; /* 1 channel */ + break; + case HDMI_AUDIO_FORMAT_CHANNEL_6: + audio->channelAllocation = 0x0b; /* 3, 4 channel */ + break; + case HDMI_AUDIO_FORMAT_CHANNEL_8: + audio->channelAllocation = 0x13; /* 1, 2, 5 channel */ + break; + default: + audio->channelAllocation = 0x00; /* 0 channel */ + break; + } +} + +int32_t HdmiAudioInfoFrameSend(struct HdmiInfoFrame *frame, bool enable) +{ + struct HdmiCntlr *cntlr = NULL; + union HdmiInfoFrameInfo infoFrame = {0}; + + if (frame == NULL || frame->priv == NULL) { + HDF_LOGE("HdmiAudioInfoFrameSend: input param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + cntlr = (struct HdmiCntlr *)frame->priv; + if (cntlr->ops == NULL || cntlr->ops->infoFrameEnable == NULL) { + HDF_LOGD("HdmiAudioInfoFrameSend not support."); + return HDF_ERR_NOT_SUPPORT; + } + + if (enable == false) { + HdmiCntlrLock(cntlr); + cntlr->ops->infoFrameEnable(cntlr, HDMI_INFOFRAME_PACKET_TYPE_AUDIO, false); + HdmiCntlrUnlock(cntlr); + return HDF_SUCCESS; + } + HdmiFillAudioInfoFrame(&(frame->audio), &(cntlr->attr.audioAttr)); + infoFrame.audio = frame->audio; + return HdmiInfoFrameSend(frame, &infoFrame); +} + +static void HdmiFillDrmInfoFrame(struct HdmiDrmInfoFrame *drm, struct HdmiHdrAttr *hdrAttr) +{ + if (memset_s(drm, sizeof(struct HdmiDrmInfoFrame), 0, sizeof(struct HdmiDrmInfoFrame)) != EOK) { + HDF_LOGE("fill vsif, memset_s fail."); + return; + } + drm->type = HDMI_INFOFRAME_PACKET_TYPE_DRM; + drm->len = HDMI_DRM_INFOFRAME_LEN; + drm->verNum = HDMI_DRM_INFOFRAME_VERSION; + drm->eotfType = hdrAttr->eotfType; + drm->metadataType = hdrAttr->metadataType; + drm->des = hdrAttr->descriptor; +} + +int32_t HdmiDrmInfoFrameSend(struct HdmiInfoFrame *frame, bool enable) +{ + struct HdmiCntlr *cntlr = NULL; + union HdmiInfoFrameInfo infoFrame = {0}; + + if (frame == NULL || frame->priv == NULL) { + HDF_LOGE("HdmiDrmInfoFrameSend: input param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + cntlr = (struct HdmiCntlr *)frame->priv; + if (cntlr->ops == NULL || cntlr->ops->infoFrameEnable == NULL) { + HDF_LOGD("HdmiDrmInfoFrameSend not support."); + return HDF_ERR_NOT_SUPPORT; + } + + if (enable == false) { + cntlr->ops->infoFrameEnable(cntlr, HDMI_INFOFRAME_PACKET_TYPE_DRM, false); + return HDF_SUCCESS; + } + HdmiFillDrmInfoFrame(&(frame->drm), &(cntlr->attr.hdrAttr)); + infoFrame.drm = frame->drm; + return HdmiInfoFrameSend(frame, &infoFrame); +} + +static uint8_t HdmiGetVsifLength(struct HdmiVs14VsifContent *_14Vsif, bool dolbyEnable, bool hdrSupport) +{ + uint8_t length = 0x07; + + if (hdrSupport == true) { + if (dolbyEnable == true) { + length = 0x18; + } else if (_14Vsif->format == HDMI_VS_VIDEO_FORMAT_4K) { + length = 0x05; + } else if (_14Vsif->format == HDMI_VS_VIDEO_FORMAT_3D) { + length = 0x07; + } else { + length = 0x04; + } + } + return length; +} + +static void HdmiFill14Vsif(struct HdmiVsInfoFrame *vs, struct HdmiVideoAttr *videoAttr) +{ + struct HdmiVideo4kInfo *info = NULL; + struct HdmiVs14VsifContent *vsif = &(vs->vsifContent.vsif); + enum HdmiVic vic; + uint32_t cnt; + + vsif->oui = HDMI_IEEE_OUI_1_4; + vic = HdmiCommonGetVic(videoAttr->timing, videoAttr->aspect, false); + if ((vic == HDMI_VIC_3840X2160P24_16_9 || vic == HDMI_VIC_3840X2160P25_16_9 || + vic == HDMI_VIC_3840X2160P30_16_9 || vic == HDMI_VIC_4096X2160P24_256_135) && + videoAttr->_3dStruct == HDMI_VS_VIDEO_3D_BUTT) { + vsif->format = HDMI_VS_VIDEO_FORMAT_4K; + for (cnt = 0; cnt <= HDMI_VIDEO_4K_CODES_MAX; cnt++) { + info = HdmiCommonGetVideo4kInfo(cnt); + if (info != NULL && info->timing == videoAttr->timing) { + vsif->vic = info->_4kVic; + break; + } + } + } else if (videoAttr->_3dStruct < HDMI_VS_VIDEO_3D_BUTT) { // common 3D + vsif->format = HDMI_VS_VIDEO_FORMAT_3D; + vsif->_3dStruct = videoAttr->_3dStruct; + } else { + vsif->format = HDMI_VS_VIDEO_FORMAT_NULL; + vsif->_3dStruct = videoAttr->_3dStruct; + } +} + +static void HdmiFillVsInfoFrame(struct HdmiInfoFrame *frame, struct HdmiVideoAttr *videoAttr, + bool dolbyEnable, bool hdrSupport) +{ + struct HdmiVsInfoFrame *vs = &(frame->vs); + int32_t ret; + + ret = memset_s(vs, sizeof(struct HdmiVsInfoFrame), 0, sizeof(struct HdmiVsInfoFrame)); + if (ret != EOK) { + HDF_LOGE("fill vsif, memset_s fail."); + return; + } + vs->type = HDMI_INFOFRAME_PACKET_TYPE_VS; + vs->verNum = HDMI_VSIF_VERSION; + HdmiFill14Vsif(vs, videoAttr); + vs->len = HdmiGetVsifLength(&(vs->vsifContent.vsif), dolbyEnable, hdrSupport); + /* fill user vendor data */ + vs->vsifContent.userVsif.len = frame->userVsif.len; + ret = memcpy_s(vs->vsifContent.userVsif.data, HDMI_VENDOR_USER_DATA_MAX_LEN, + frame->userVsif.data, frame->userVsif.len); + if (ret != EOK) { + HDF_LOGE("fill vsif, memcpy_s fail."); + } +} + +int32_t HdmiVsInfoFrameSend(struct HdmiInfoFrame *frame, bool enable, bool dolbyEnable) +{ + struct HdmiCntlr *cntlr = NULL; + union HdmiInfoFrameInfo infoFrame = {0}; + + if (frame == NULL || frame->priv == NULL) { + HDF_LOGE("HdmiVsInfoFrameSend: input param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + cntlr = (struct HdmiCntlr *)frame->priv; + if (cntlr->ops == NULL || cntlr->ops->infoFrameEnable == NULL) { + HDF_LOGD("HdmiVsInfoFrameSend not support."); + return HDF_ERR_NOT_SUPPORT; + } + + if (enable == false) { + cntlr->ops->infoFrameEnable(cntlr, HDMI_INFOFRAME_PACKET_TYPE_VS, false); + return HDF_SUCCESS; + } + HdmiFillVsInfoFrame(frame, &(cntlr->attr.videoAttr), dolbyEnable, frame->hdrSupport); + infoFrame.vs = frame->vs; + return HdmiInfoFrameSend(frame, &infoFrame); +} + +static void HdmiFillSpdInfoFrame(struct HdmiSpdInfoFrame *spd, + const char *vendorName, const char *productName, + enum HdmiSpdSdi sdi) +{ + uint32_t len, length; + + if (memset_s(spd, sizeof(struct HdmiSpdInfoFrame), 0, sizeof(struct HdmiSpdInfoFrame)) != EOK) { + HDF_LOGE("fill spd infoFrame, memset_s fail."); + return; + } + spd->type = HDMI_INFOFRAME_PACKET_TYPE_SPD; + spd->len = HDMI_SPD_INFOFRAME_LEN; + spd->verNum = HDMI_SPD_VERSION; + spd->sdi = sdi; + + len = (uint32_t)strlen(vendorName); + length = (uint32_t)sizeof(spd->vendorName); + length = (length > len) ? len : length; + if (memcpy_s(spd->vendorName, length, vendorName, length) != EOK) { + HDF_LOGE("fill spd infoFrame vendor name, memcpy_s fail."); + } + + len = (uint32_t)strlen(productName); + length = (uint32_t)sizeof(spd->productDescription); + length = (length > len) ? len : length; + if (memcpy_s(spd->productDescription, length, productName, length) != EOK) { + HDF_LOGE("fill spd infoFrame product name, memcpy_s fail."); + } +} + +int32_t HdmiSpdInfoFrameSend(struct HdmiInfoFrame *frame, bool enable, + const char *vendorName, const char *productName, enum HdmiSpdSdi sdi) +{ + struct HdmiCntlr *cntlr = NULL; + union HdmiInfoFrameInfo infoFrame = {0}; + + if (frame == NULL || frame->priv == NULL) { + HDF_LOGE("HdmiSpdInfoFrameSend: input param is invalid."); + return HDF_ERR_INVALID_PARAM; + } + cntlr = (struct HdmiCntlr *)frame->priv; + if (cntlr->ops == NULL || cntlr->ops->infoFrameEnable == NULL) { + HDF_LOGD("HdmiSpdInfoFrameSend not support."); + return HDF_ERR_NOT_SUPPORT; + } + + if (enable == false) { + cntlr->ops->infoFrameEnable(cntlr, HDMI_INFOFRAME_PACKET_TYPE_SPD, false); + return HDF_SUCCESS; + } + HdmiFillSpdInfoFrame(&(frame->spd), vendorName, productName, sdi); + infoFrame.spd = frame->spd; + return HdmiInfoFrameSend(frame, &infoFrame); +} + +int32_t HdmiInfoFrameGetInfo(struct HdmiInfoFrame *frame, enum HdmiPacketType type, + union HdmiInfoFrameInfo *infoFrame) +{ + if (frame == NULL || infoFrame == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + switch (type) { + case HDMI_INFOFRAME_PACKET_TYPE_VS: + infoFrame->vs = frame->vs; + break; + case HDMI_INFOFRAME_PACKET_TYPE_AVI: + infoFrame->avi = frame->avi; + break; + case HDMI_INFOFRAME_PACKET_TYPE_AUDIO: + infoFrame->audio = frame->audio; + break; + case HDMI_INFOFRAME_PACKET_TYPE_DRM: + infoFrame->drm = frame->drm; + break; + default: + HDF_LOGD("infoFrame %d not support get", type); + return HDF_ERR_INVALID_PARAM; + } + return HDF_SUCCESS; +} + +int32_t HdmiInfoFrameSetInfo(struct HdmiInfoFrame *frame, enum HdmiPacketType type, + union HdmiInfoFrameInfo *infoFrame) +{ + if (frame == NULL || infoFrame == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + switch (type) { + case HDMI_INFOFRAME_PACKET_TYPE_VS: + frame->vs = infoFrame->vs; + break; + case HDMI_INFOFRAME_PACKET_TYPE_AVI: + frame->avi = infoFrame->avi; + break; + case HDMI_INFOFRAME_PACKET_TYPE_AUDIO: + frame->audio = infoFrame->audio; + break; + case HDMI_INFOFRAME_PACKET_TYPE_DRM: + frame->drm = infoFrame->drm; + break; + default: + HDF_LOGD("infoFrame %d not support set", type); + return HDF_ERR_INVALID_PARAM; + } + return HDF_SUCCESS; +} diff --git a/support/platform/src/hdmi/hdmi_ncts.c b/support/platform/src/hdmi/hdmi_ncts.c new file mode 100644 index 0000000000000000000000000000000000000000..aff34dbad24ae9810d9e3085b8d2236ac14c402d --- /dev/null +++ b/support/platform/src/hdmi/hdmi_ncts.c @@ -0,0 +1,123 @@ +/* + * Copyright (c) 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 "hdmi_ncts.h" + +#define HDF_LOG_TAG hdmi_ncts_c + +#define HDMI_NCTS_INVALID_VALUE 0xffffffff + +/* + * see hdmi1.4 table 7-1¡¢7-2¡¢7-3. + * The exact relationship: 128 * fs = tmdsClock * N / CTS. + */ +static struct HdmiAudioNCts g_audioNctsMap[] = { + { 32000, 25174, 4576, 28125 }, + { 32000, 25200, 4096, 25200 }, + { 32000, 27000, 4096, 27000 }, + { 32000, 27027, 4096, 27027 }, + { 32000, 54000, 4096, 54000 }, + { 32000, 54054, 4096, 54054 }, + { 32000, 74175, 11648, 210937}, + { 32000, 74250, 4096, 74250 }, + { 32000, 148351, 11648, 421875 }, + { 32000, 148500, 4096, 148500 }, + { 32000, 296703, 5824, 421875 }, + { 32000, 297000, 3072, 222750 }, + { 32000, 593406, 5824, 843750 }, + { 32000, 594000, 3072, 445500 }, + { 32000, 0, 4096, 0 }, + { 44100, 25174, 7007, 31250 }, + { 44100, 25200, 6272, 28000 }, + { 44100, 27000, 6272, 30000 }, + { 44100, 27027, 6272, 30030 }, + { 44100, 54000, 6272, 60000 }, + { 44100, 54054, 6272, 60060 }, + { 44100, 74175, 17836, 234375 }, + { 44100, 74250, 6272, 82500 }, + { 44100, 148351, 8918, 234375 }, + { 44100, 148500, 6272, 165000 }, + { 44100, 296703, 4459, 234375 }, + { 44100, 297000, 4704, 247500 }, + { 44100, 593406, 8918, 937500 }, + { 44100, 594000, 9408, 990000 }, + { 44100, 0, 6272, 0 }, + { 48000, 25174, 6864, 28125 }, + { 48000, 25200, 6144, 25200 }, + { 48000, 27000, 6144, 27000 }, + { 48000, 27027, 6144, 27027 }, + { 48000, 54000, 6144, 54000 }, + { 48000, 54054, 6144, 54054 }, + { 48000, 74175, 11648, 140625 }, + { 48000, 74250, 6144, 74250 }, + { 48000, 148351, 5824, 140625 }, + { 48000, 148500, 6144, 148500 }, + { 48000, 296703, 5824, 281250 }, + { 48000, 297000, 5120, 247500 }, + { 48000, 593406, 5824, 562500 }, + { 48000, 594000, 6144, 594000 }, + { 48000, 0, 6144, 0 } + }; + +uint32_t HdmiGetN(uint32_t sampleRate, uint32_t tmdsClock) +{ + uint32_t i; + + for (i = 0; i < sizeof(g_audioNctsMap) / sizeof(g_audioNctsMap[0]); i++) { + if (g_audioNctsMap[i].sampleRate == sampleRate && + g_audioNctsMap[i].tmdsClock == tmdsClock) { + return g_audioNctsMap[i].n; + } + if (g_audioNctsMap[i].sampleRate == sampleRate && + g_audioNctsMap[i].tmdsClock >= (tmdsClock - HDMI_NCTS_TMDS_DEVIATION) && + g_audioNctsMap[i].tmdsClock <= (tmdsClock + HDMI_NCTS_TMDS_DEVIATION)) { + return g_audioNctsMap[i].n; + } + if (g_audioNctsMap[i].sampleRate == sampleRate && + g_audioNctsMap[i].tmdsClock == 0) { + return g_audioNctsMap[i].n; + } + } + return HDMI_NCTS_N_DEFAULT; +} + +uint32_t HdmiGetCts(uint32_t sampleRate, uint32_t tmdsClock) +{ + uint32_t i; + uint32_t tmpN = HDMI_NCTS_INVALID_VALUE; + uint32_t tmpCts = HDMI_NCTS_INVALID_VALUE; + + for (i = 0; i < sizeof(g_audioNctsMap) / sizeof(g_audioNctsMap[0]); i++) { + if (g_audioNctsMap[i].sampleRate == sampleRate && + g_audioNctsMap[i].tmdsClock == tmdsClock) { + tmpN = g_audioNctsMap[i].n; + tmpCts = g_audioNctsMap[i].cts; + break; + } + if (g_audioNctsMap[i].sampleRate == sampleRate && + g_audioNctsMap[i].tmdsClock >= (tmdsClock - HDMI_NCTS_TMDS_DEVIATION) && + g_audioNctsMap[i].tmdsClock <= (tmdsClock + HDMI_NCTS_TMDS_DEVIATION)) { + tmpN = g_audioNctsMap[i].n; + tmpCts = g_audioNctsMap[i].cts; + break; + } + if (g_audioNctsMap[i].sampleRate == sampleRate && + g_audioNctsMap[i].tmdsClock == 0) { + tmpN = g_audioNctsMap[i].n; + tmpCts = g_audioNctsMap[i].cts; + break; + } + } + + if (tmpCts == 0 && sampleRate >= 1000) { + tmpCts = (tmpN / HDMI_NCTS_FACTOR) * tmdsClock * 10 / (sampleRate / 1000); + } else if (tmpCts == HDMI_NCTS_INVALID_VALUE && sampleRate >= 1000) { + tmpCts = (HDMI_NCTS_N_DEFAULT / HDMI_NCTS_FACTOR) * tmdsClock * 10 / (sampleRate / 1000); + } + return tmpCts; +} diff --git a/support/platform/src/hdmi/hdmi_scdc.c b/support/platform/src/hdmi/hdmi_scdc.c new file mode 100644 index 0000000000000000000000000000000000000000..81fa46ba90989fc666ac00beb2cb1326ba82f289 --- /dev/null +++ b/support/platform/src/hdmi/hdmi_scdc.c @@ -0,0 +1,384 @@ +/* + * Copyright (c) 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_log.h" +#include "hdmi_core.h" + +#define HDF_LOG_TAG hdmi_scdc_c + +#define HDMI_SCDC_READ_SOURCE_VERSION_TIMES 2 + +int32_t HdmiScdcRead(struct HdmiScdc *scdc, enum HdmiScdcsOffset offset, uint8_t *buffer, uint32_t len) +{ + struct HdmiDdcCfg cfg = {0}; + struct HdmiCntlr *cntlr = NULL; + + if (scdc == NULL || scdc->priv == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + cntlr = (struct HdmiCntlr *)scdc->priv; + cfg.type = HDMI_DDC_DEV_SCDC; + cfg.readFlag = true; + cfg.devAddr = HDMI_DDC_SCDC_DEV_ADDRESS; + cfg.data = buffer; + cfg.dataLen = len; + cfg.offset = offset; + cfg.mode = HDMI_DDC_MODE_READ_MUTIL_NO_ACK; + return HdmiDdcTransfer(&(cntlr->ddc), &cfg); +} + +int32_t HdmiScdcWrite(struct HdmiScdc *scdc, enum HdmiScdcsOffset offset, uint8_t *buffer, uint32_t len) +{ + struct HdmiDdcCfg cfg = {0}; + struct HdmiCntlr *cntlr = NULL; + + if (scdc == NULL || scdc->priv == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + cntlr = (struct HdmiCntlr *)scdc->priv; + cfg.type = HDMI_DDC_DEV_SCDC; + cfg.readFlag = false; + cfg.devAddr = HDMI_DDC_SCDC_DEV_ADDRESS; + cfg.data = buffer; + cfg.dataLen = len; + cfg.offset = offset; + cfg.mode = HDMI_DDC_MODE_WRITE_MUTIL_ACK; + return HdmiDdcTransfer(&(cntlr->ddc), &cfg); +} + +int32_t HdmiScdcReadByte(struct HdmiScdc *scdc, enum HdmiScdcsOffset offset, uint8_t *byte) +{ + return HdmiScdcRead(scdc, offset, byte, sizeof(*byte)); +} + +int32_t HdmiScdcWriteByte(struct HdmiScdc *scdc, enum HdmiScdcsOffset offset, uint8_t *byte) +{ + return HdmiScdcWrite(scdc, offset, byte, sizeof(*byte)); +} + +/* read opt */ +int32_t HdmiScdcReadSinkVersion(struct HdmiScdc *scdc, uint8_t *sinkVer) +{ + return HdmiScdcReadByte(scdc, HDMI_SCDCS_OFFSET_SINK_VERSION, sinkVer); +} + +int32_t HdmiScdcReadSourceVersion(struct HdmiScdc *scdc, uint8_t *srcVer) +{ + return HdmiScdcReadByte(scdc, HDMI_SCDCS_OFFSET_SOURCE_VERSION, srcVer); +} + +int32_t HdmiScdcReadUpdate0(struct HdmiScdc *scdc, uint8_t *flag) +{ + return HdmiScdcReadByte(scdc, HDMI_SCDCS_OFFSET_UPDATE_0, flag); +} + +int32_t HdmiScdcReadScramblerStatus(struct HdmiScdc *scdc, uint8_t *status) +{ + return HdmiScdcReadByte(scdc, HDMI_SCDCS_OFFSET_SCRAMBLER_STATUS, status); +} + +int32_t HdmiScdcReadTmdsConfig(struct HdmiScdc *scdc, uint8_t *tmdsCfg) +{ + return HdmiScdcReadByte(scdc, HDMI_SCDCS_OFFSET_TMDS_CONFIG, tmdsCfg); +} + +int32_t HdmiScdcReadConfig0(struct HdmiScdc *scdc, uint8_t *cfg) +{ + return HdmiScdcReadByte(scdc, HDMI_SCDCS_OFFSET_CONFIG_0, cfg); +} + +int32_t HdmiScdcReadConfig1(struct HdmiScdc *scdc, uint8_t *cfg) +{ + return HdmiScdcReadByte(scdc, HDMI_SCDCS_OFFSET_CONFIG_1, cfg); +} + +int32_t HdmiScdcReadTestConfig0(struct HdmiScdc *scdc, uint8_t *testCfg) +{ + return HdmiScdcReadByte(scdc, HDMI_SCDCS_OFFSET_TEST_CONFIG_0, testCfg); +} + +int32_t HdmiScdcReadTestConfig1(struct HdmiScdc *scdc, uint8_t *testCfg) +{ + return HdmiScdcReadByte(scdc, HDMI_SCDCS_OFFSET_TEST_CONFIG_1, testCfg); +} + +int32_t HdmiScdcReadStatusFlag0(struct HdmiScdc *scdc, uint8_t *flag) +{ + return HdmiScdcReadByte(scdc, HDMI_SCDCS_OFFSET_STASTUS_FLAG_0, flag); +} + +int32_t HdmiScdcReadStatusFlag1(struct HdmiScdc *scdc, uint8_t *flag) +{ + return HdmiScdcReadByte(scdc, HDMI_SCDCS_OFFSET_STASTUS_FLAG_1, flag); +} + +int32_t HdmiScdcReadStatusFlag2(struct HdmiScdc *scdc, uint8_t *flag) +{ + return HdmiScdcReadByte(scdc, HDMI_SCDCS_OFFSET_STASTUS_FLAG_2, flag); +} + +/* write opt */ +int32_t HdmiScdcWriteSourceVersion(struct HdmiScdc *scdc, uint8_t *srcVer) +{ + return HdmiScdcWriteByte(scdc, HDMI_SCDCS_OFFSET_SOURCE_VERSION, srcVer); +} + +int32_t HdmiScdcWriteUpdate0(struct HdmiScdc *scdc, uint8_t *flag) +{ + return HdmiScdcWriteByte(scdc, HDMI_SCDCS_OFFSET_UPDATE_0, flag); +} + +int32_t HdmiScdcWriteTmdsConfig(struct HdmiScdc *scdc, uint8_t *tmdsCfg) +{ + return HdmiScdcWriteByte(scdc, HDMI_SCDCS_OFFSET_TMDS_CONFIG, tmdsCfg); +} + +int32_t HdmiScdcWriteConfig0(struct HdmiScdc *scdc, uint8_t *cfg) +{ + return HdmiScdcWriteByte(scdc, HDMI_SCDCS_OFFSET_CONFIG_0, cfg); +} + +int32_t HdmiScdcWriteConfig1(struct HdmiScdc *scdc, uint8_t *cfg) +{ + return HdmiScdcWriteByte(scdc, HDMI_SCDCS_OFFSET_CONFIG_1, cfg); +} + +int32_t HdmiScdcWriteTestConfig0(struct HdmiScdc *scdc, uint8_t *testCfg) +{ + return HdmiScdcWriteByte(scdc, HDMI_SCDCS_OFFSET_TEST_CONFIG_0, testCfg); +} + +/* cntlr ops */ +bool HdmiCntlrScdcSourceScrambleGet(struct HdmiCntlr *cntlr) +{ + bool ret = false; + + if (cntlr == NULL || cntlr->ops == NULL || cntlr->ops->scdcSourceScrambleGet == NULL) { + return ret; + } + HdmiCntlrLock(cntlr); + ret = cntlr->ops->scdcSourceScrambleGet(cntlr); + HdmiCntlrUnlock(cntlr); + return ret; +} + +int32_t HdmiCntlrScdcSourceScrambleSet(struct HdmiCntlr *cntlr, bool enable) +{ + int32_t ret; + + if (cntlr == NULL || cntlr->ops == NULL || cntlr->ops->scdcSourceScrambleSet == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + HdmiCntlrLock(cntlr); + ret = cntlr->ops->scdcSourceScrambleSet(cntlr, enable); + HdmiCntlrUnlock(cntlr); + return ret; +} + +/* scdc opt */ +int32_t HdmiScdcRrDisable(struct HdmiScdc *scdc) +{ + union HdmiScdcsConfig0 cfg = {0}; + union HdmiScdcsTestConfig0 testCfg = {0}; + int32_t ret; + + if (scdc == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + ret = HdmiScdcWriteConfig0(scdc, &(cfg.data)); + if (ret != HDF_SUCCESS) { + HDF_LOGE("scdc write config0 fail"); + return ret; + } + scdc->status.cfg0 = cfg; + + ret = HdmiScdcWriteTestConfig0(scdc, &(testCfg.data)); + if (ret != HDF_SUCCESS) { + HDF_LOGE("scdc write test config0 fail"); + return ret; + } + scdc->status.testCfg0 = testCfg; + return HDF_SUCCESS; +} + +int32_t HdmiScdcScrambleSet(struct HdmiScdc *scdc, struct HdmiScdcScrambleCap *scramble) +{ + union HdmiScdcsTmdsConfig cfg = {0}; + int32_t ret; + + if (scdc == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + ret = HdmiCntlrScdcSourceScrambleSet((struct HdmiCntlr *)scdc->priv, scramble->sourceScramble); + if (ret != HDF_SUCCESS) { + HDF_LOGE("scdc source scrambler set fail"); + return ret; + } + + if (scramble->sinkScramble == true) { + cfg.bits.scramblingEnable = 1; + } + if (scramble->tmdsBitClockRatio40 == true) { + cfg.bits.tmdsBitClockRatio = 1; + } + ret = HdmiScdcWriteTmdsConfig(scdc, &(cfg.data)); + if (ret != HDF_SUCCESS) { + HDF_LOGE("scdc write tmds config fail"); + return ret; + } + return HDF_SUCCESS; +} + +int32_t HdmiScdcScrambleGet(struct HdmiScdc *scdc, struct HdmiScdcScrambleCap *scramble) +{ + union HdmiScdcsScramblerStatus status = {0}; + union HdmiScdcsTmdsConfig cfg = {0}; + int32_t ret; + + if (scdc == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + ret = HdmiScdcReadScramblerStatus(scdc, &(status.data)); + if (ret != HDF_SUCCESS) { + HDF_LOGE("scdc read scrambler status fail"); + return ret; + } + scramble->sinkScramble = (status.bits.scramblingStatus ? true : false); + + ret = HdmiScdcReadTmdsConfig(scdc, &(cfg.data)); + if (ret != HDF_SUCCESS) { + HDF_LOGE("scdc read tmds config fail"); + return ret; + } + scramble->tmdsBitClockRatio40 = (cfg.bits.tmdsBitClockRatio ? true : false); + scramble->sourceScramble = HdmiCntlrScdcSourceScrambleGet(scdc->priv); + + scdc->status.tmdsCfg = cfg; + scdc->status.scramblerStatus = status; + return HDF_SUCCESS; +} + +bool HdmiScdcSinkSupport(struct HdmiScdc *scdc) +{ + uint8_t srcVer, i; + int32_t ret; + + if (scdc == NULL) { + return HDF_ERR_INVALID_PARAM; + } + + for (i = 0; i < HDMI_SCDC_READ_SOURCE_VERSION_TIMES; i++) { + srcVer = HDMI_SCDC_HDMI20_VERSION; + ret = HdmiScdcWriteSourceVersion(scdc, &srcVer); + if (ret != HDF_SUCCESS) { + HDF_LOGE("scdc write source version fail"); + return false; + } + ret = HdmiScdcReadSourceVersion(scdc, &srcVer); + if (ret != HDF_SUCCESS) { + HDF_LOGE("scdc read source version fail"); + return false; + } + } + scdc->status.sourceVersion = HDMI_SCDC_HDMI20_VERSION; + return true; +} + +int32_t HdmiScdcOptMsgHandle(struct HdmiScdc *scdc, enum HdmiScdcOptMsg msg, uint8_t *buffer, uint32_t len) +{ + int32_t ret; + + if (scdc == NULL || buffer == NULL || len == 0) { + return HDF_ERR_INVALID_PARAM; + } + + switch (msg) { + case HDMI_SCDC_OPT_SET_SOURCE_VER: + ret = HdmiScdcWriteSourceVersion(scdc, buffer); + break; + case HDMI_SCDC_OPT_GET_SOURCE_VER: + ret = HdmiScdcReadSourceVersion(scdc, buffer); + break; + case HDMI_SCDC_OPT_GET_SINK_VER: + ret = HdmiScdcReadSinkVersion(scdc, buffer); + break; + case HDMI_SCDC_OPT_SET_FLT_UPDATE: + case HDMI_SCDC_OPT_SET_FRL_START: + ret = HdmiScdcWriteUpdate0(scdc, buffer); + break; + case HDMI_SCDC_OPT_GET_FLT_UPDATE: + case HDMI_SCDC_OPT_GET_FRL_START: + ret = HdmiScdcReadUpdate0(scdc, buffer); + break; + case HDMI_SCDC_OPT_SET_CONFIG1: + ret = HdmiScdcWriteConfig1(scdc, buffer); + break; + case HDMI_SCDC_OPT_GET_CONFIG1: + ret = HdmiScdcReadConfig1(scdc, buffer); + break; + case HDMI_SCDC_OPT_GET_TEST_CONFIG_1: + ret = HdmiScdcReadTestConfig1(scdc, buffer); + break; + case HDMI_SCDC_OPT_GET_FLT_READY: + ret = HdmiScdcReadStatusFlag0(scdc, buffer); + break; + case HDMI_SCDC_OPT_GET_LTP_REQ: + ret = HdmiScdcRead(scdc, HDMI_SCDCS_OFFSET_STASTUS_FLAG_1, buffer, len); + break; + default: + HDF_LOGE("scdc msg handle, msg %d not support.", msg); + ret = HDF_ERR_NOT_SUPPORT; + break; + } + + return ret; +} + +int32_t HdmiScdcFillScrambleCap(struct HdmiScdc *scdc, struct HdmiScdcScrambleCap *scramble, + enum HdmiTmdsModeType *tmdsMode) +{ + struct HdmiCntlr *cntlr = NULL; + struct HdmiCommonAttr *commAttr = NULL; + struct HdmiVideoAttr *videoAttr = NULL; + + if (scdc == NULL || scdc->priv == NULL || scramble == NULL || tmdsMode == NULL) { + HDF_LOGD("scdc fill scramble cap: param is null"); + return HDF_ERR_INVALID_PARAM; + } + + cntlr = (struct HdmiCntlr *)scdc->priv; + commAttr = &(cntlr->attr.commAttr); + videoAttr = &(cntlr->attr.videoAttr); + if (commAttr->enableHdmi == false) { + /* DVI mode */ + *tmdsMode = HDMI_TMDS_MODE_DVI; + scramble->sinkScramble = false; + scramble->sourceScramble = false; + scramble->tmdsBitClockRatio40 = false; + if (videoAttr->tmdsClock > HDMI_HDMI14_MAX_TMDS_RATE) { + HDF_LOGE("tmds clock %u can't support in DVI mode.", videoAttr->tmdsClock); + return HDF_ERR_INVALID_PARAM; + } + } else if (videoAttr->tmdsClock > HDMI_HDMI14_MAX_TMDS_RATE) { + *tmdsMode = HDMI_TMDS_MODE_HDMI_2_0; + scramble->sinkScramble = true; + scramble->sourceScramble = true; + scramble->tmdsBitClockRatio40 = true; + } else { + *tmdsMode = HDMI_TMDS_MODE_HDMI_1_4; + scramble->sinkScramble = false; + scramble->sourceScramble = false; + scramble->tmdsBitClockRatio40 = false; + } + return HDF_SUCCESS; +} diff --git a/support/platform/src/i2c_core.c b/support/platform/src/i2c/i2c_core.c similarity index 99% rename from support/platform/src/i2c_core.c rename to support/platform/src/i2c/i2c_core.c index 7a2aa86c8502e91081f5d10877d70b2d6d8b3024..357ba7bdc84ad5a4727fcd7817ec34752a3b68b0 100644 --- a/support/platform/src/i2c_core.c +++ b/support/platform/src/i2c/i2c_core.c @@ -12,7 +12,6 @@ #include "osal_mem.h" #include "osal_time.h" #include "platform_core.h" -#include "plat_log.h" #define HDF_LOG_TAG i2c_core #define LOCK_WAIT_SECONDS_M 1 diff --git a/support/platform/src/i2c_if.c b/support/platform/src/i2c/i2c_if.c similarity index 100% rename from support/platform/src/i2c_if.c rename to support/platform/src/i2c/i2c_if.c diff --git a/support/platform/src/i2s_core.c b/support/platform/src/i2s/i2s_core.c similarity index 100% rename from support/platform/src/i2s_core.c rename to support/platform/src/i2s/i2s_core.c diff --git a/support/platform/src/i2s_if.c b/support/platform/src/i2s/i2s_if.c similarity index 100% rename from support/platform/src/i2s_if.c rename to support/platform/src/i2s/i2s_if.c diff --git a/support/platform/src/i3c/i3c_core.c b/support/platform/src/i3c/i3c_core.c new file mode 100755 index 0000000000000000000000000000000000000000..e7ea2f7845be1c0cc8a54c757ca38c3cece865bd --- /dev/null +++ b/support/platform/src/i3c/i3c_core.c @@ -0,0 +1,746 @@ +/* + * Copyright (c) 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 "i3c_core.h" +#include "hdf_device_desc.h" +#include "hdf_log.h" +#include "i3c_ccc.h" +#include "osal_mem.h" +#include "osal_mutex.h" + +#define I3C_SERVICE_NAME "HDF_PLATFORM_I3C_MANAGER" + +struct I3cManager { + struct IDeviceIoService service; + struct HdfDeviceObject *device; + struct I3cCntlr *cntlrs[I3C_CNTLR_MAX]; + struct OsalMutex lock; +}; + +static struct I3cManager *g_i3cManager = NULL; +static struct DListHead g_i3cDeviceList; +static OsalSpinlock g_listLock; + +static inline int32_t I3cCntlrLockDefault(struct I3cCntlr *cntlr) +{ + if (cntlr == NULL) { + return HDF_ERR_DEVICE_BUSY; + } + return OsalSpinLock(&cntlr->lock); +} + +static inline void I3cCntlrUnlockDefault(struct I3cCntlr *cntlr) +{ + if (cntlr == NULL) { + return; + } + (void)OsalSpinUnlock(&cntlr->lock); +} + +static const struct I3cLockMethod g_i3cLockOpsDefault = { + .lock = I3cCntlrLockDefault, + .unlock = I3cCntlrUnlockDefault, +}; + +static inline int32_t I3cCntlrLock(struct I3cCntlr *cntlr) +{ + if (cntlr->lockOps == NULL || cntlr->lockOps->lock == NULL) { + return HDF_ERR_NOT_SUPPORT; + } + return cntlr->lockOps->lock(cntlr); +} + +static inline void I3cCntlrUnlock(struct I3cCntlr *cntlr) +{ + if (cntlr->lockOps != NULL && cntlr->lockOps->unlock != NULL) { + cntlr->lockOps->unlock(cntlr); + } +} + +static struct DListHead *I3cDeviceListGet(void) +{ + static struct DListHead *head = NULL; + + head = &g_i3cDeviceList; + while (OsalSpinLock(&g_listLock)); + + return head; +} + +static void I3cDeviceListPut(void) +{ + (void)OsalSpinUnlock(&g_listLock); +} + +static int32_t GetAddrStatus(struct I3cCntlr *cntlr, uint16_t addr) +{ + int32_t status; + + if (addr > I3C_ADDR_MAX) { + HDF_LOGE("%s: The address 0x%x exceeds the maximum address", __func__, addr); + return HDF_ERR_INVALID_PARAM; + } + + status = ADDR_STATUS_MASK & ((cntlr->addrSlot[addr / ADDRS_PER_UINT16]) \ + >> ((addr % ADDRS_PER_UINT16) * ADDRS_STATUS_BITS)); + + return status; +} + +static int32_t SetAddrStatus(struct I3cCntlr *cntlr, uint16_t addr, enum I3cAddrStatus status) +{ + uint16_t temp; + uint32_t ret; + uint16_t statusMask; + + if (addr > I3C_ADDR_MAX) { + HDF_LOGE("%s: The address 0x%x exceeds the maximum address", __func__, addr); + return HDF_ERR_INVALID_PARAM; + } + + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + ret = I3cCntlrLock(cntlr); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Lock cntlr failed!", __func__); + return ret; + } + + statusMask = ADDR_STATUS_MASK << ((addr % ADDRS_PER_UINT16) * ADDRS_STATUS_BITS); + temp = (cntlr->addrSlot[addr / ADDRS_PER_UINT16]) & ~statusMask; + temp |= ((uint16_t)status) << ((addr % ADDRS_PER_UINT16) * ADDRS_STATUS_BITS); + cntlr->addrSlot[addr / ADDRS_PER_UINT16] = temp; + + I3cCntlrUnlock(cntlr); + + return HDF_SUCCESS; +} + +static void inline I3cInitAddrStatus(struct I3cCntlr *cntlr) +{ + uint16_t addr; + + for (addr = 0; addr <= I3C_ADDR_MAX; addr++) { + if (CHECK_RESERVED_ADDR(addr) == I3C_ADDR_RESERVED) { + (void)SetAddrStatus(cntlr, addr, I3C_ADDR_RESERVED); + } + } +} + +static int32_t GetFreeAddr(struct I3cCntlr *cntlr) +{ + enum I3cAddrStatus status; + int16_t count; + int32_t ret; + + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + ret = I3cCntlrLock(cntlr); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Lock cntlr failed!", __func__); + return ret; + } + + for (count = 0; count <= I3C_ADDR_MAX; count++) { + status = (enum I3cAddrStatus)GetAddrStatus(cntlr, count); + if (status == I3C_ADDR_FREE) { + return (int32_t)count; + } + } + I3cCntlrUnlock(cntlr); + HDF_LOGE("%s: No free addresses left!", __func__); + + return HDF_FAILURE; +} + +int32_t I3cCntlrSendCccCmd(struct I3cCntlr *cntlr, struct I3cCccCmd *ccc) +{ + int32_t ret; + + if (ccc == NULL) { + HDF_LOGE("%s: ccc is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + if (cntlr->ops == NULL || cntlr->ops->sendCccCmd == NULL) { + HDF_LOGE("%s: ops or sendCccCmd is null", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (I3cCntlrLock(cntlr) != HDF_SUCCESS) { + HDF_LOGE("%s: lock controller fail!", __func__); + return HDF_ERR_DEVICE_BUSY; + } + + ret = cntlr->ops->sendCccCmd(cntlr, ccc); + I3cCntlrUnlock(cntlr); + + return ret; +} + +struct I3cDevice *GetDeviceByAddr(struct I3cCntlr *cntlr, uint16_t addr) +{ + struct DListHead *head = NULL; + struct I3cDevice *pos = NULL; + struct I3cDevice *tmp = NULL; + enum I3cAddrStatus addrStatus; + + if (addr > I3C_ADDR_MAX) { + HDF_LOGE("%s: The address 0x%x exceeds the maximum address", __func__, addr); + return NULL; + } + addrStatus = GetAddrStatus(cntlr, addr); + if (addrStatus == I3C_ADDR_FREE) { + HDF_LOGE("%s: The addr 0x%x is unavailable", __func__, addr); + return NULL; + } + if (addrStatus == I3C_ADDR_RESERVED) { + HDF_LOGE("%s: The addr 0x%x is reserved", __func__, addr); + return NULL; + } + + if (addrStatus == I3C_ADDR_I2C_DEVICE || addrStatus == I3C_ADDR_I3C_DEVICE) { + head = I3cDeviceListGet(); + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, head, struct I3cDevice, list) { + if ((pos->dynaAddr == addr) && (pos->cntlr == cntlr)) { + I3cDeviceListPut(); + HDF_LOGI("%s: found by dynaAddr,done!", __func__); + return pos; + } else if ((!pos->dynaAddr) && (pos->addr == addr) && (pos->cntlr == cntlr)) { + HDF_LOGI("%s: found by Addr,done!", __func__); + I3cDeviceListPut(); + return pos; + } + } + } + HDF_LOGE("%s: No such device found! addr: 0x%x", __func__, addr); + + return NULL; +} + +static int32_t I3cDeviceDefineI3cDevices(struct I3cDevice *device) +{ + int32_t ret, addr; + + ret = SetAddrStatus(device->cntlr, device->addr, I3C_ADDR_I3C_DEVICE); + if (ret != HDF_SUCCESS) { + addr = GetFreeAddr(device->cntlr); + if (addr <= 0) { + HDF_LOGE("%s: No free addresses left!", __func__); + return HDF_ERR_DEVICE_BUSY; + } + ret = SetAddrStatus(device->cntlr, (uint16_t)addr, I3C_ADDR_I3C_DEVICE); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Add I3C device failed!", __func__); + return ret; + } + } + + return HDF_SUCCESS; +} + +int32_t I3cDeviceAdd(struct I3cDevice *device) +{ + struct DListHead *head = NULL; + struct I3cDevice *pos = NULL; + struct I3cDevice *tmp = NULL; + int32_t ret; + + if ((device == NULL) || (GetAddrStatus(device->cntlr, device->addr) != I3C_ADDR_FREE)) { + HDF_LOGE("%s: device or addr is unavailable", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (device->type == I3C_CNTLR_I2C_DEVICE || device->type == I3C_CNTLR_I2C_LEGACY_DEVICE) { + ret = SetAddrStatus(device->cntlr, device->addr, I3C_ADDR_I2C_DEVICE); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Add I2C device failed!", __func__); + return ret; + } + } else { + ret = I3cDeviceDefineI3cDevices(device); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: I3c DEFSLVS error!", __func__); + return ret; + } + } + head = I3cDeviceListGet(); + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, head, struct I3cDevice, list) { + if (pos == NULL) { // empty list + break; + } + if ((pos->pid == device->pid) && (pos->cntlr == device->cntlr)) { + I3cDeviceListPut(); + HDF_LOGE("%s: device already existed!: 0x%llx", __func__, device->pid); + (void)SetAddrStatus(device->cntlr, device->addr, I3C_ADDR_RESERVED); + return HDF_ERR_IO; + } + } + DListHeadInit(&device->list); + DListInsertTail(&device->list, head); + I3cDeviceListPut(); + HDF_LOGI("%s: done!", __func__); + + return HDF_SUCCESS; +} + +void I3cDeviceRemove(struct I3cDevice *device) +{ + int32_t ret; + if (device == NULL) { + return; + } + + ret = SetAddrStatus(device->cntlr, device->addr, I3C_ADDR_RESERVED); + if (ret != HDF_SUCCESS) { + return; + } + (void)I3cDeviceListGet(); + DListRemove(&device->list); + I3cDeviceListPut(); +} + +static int32_t I3cManagerAddCntlr(struct I3cCntlr *cntlr) +{ + int32_t ret; + struct I3cManager *manager = g_i3cManager; + + if (cntlr->busId >= I3C_CNTLR_MAX) { + HDF_LOGE("%s: busId:%d exceed!", __func__, cntlr->busId); + return HDF_ERR_INVALID_PARAM; + } + + if (manager == NULL) { + HDF_LOGE("%s: get i3c manager fail!", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("%s: lock i3c manager fail!", __func__); + return HDF_ERR_DEVICE_BUSY; + } + + if (manager->cntlrs[cntlr->busId] != NULL) { + HDF_LOGE("%s: cntlr of bus:%d already exits!", __func__, cntlr->busId); + ret = HDF_FAILURE; + } else { + manager->cntlrs[cntlr->busId] = cntlr; + ret = HDF_SUCCESS; + } + (void)OsalMutexUnlock(&manager->lock); + + return ret; +} + +static void I3cManagerRemoveCntlr(struct I3cCntlr *cntlr) +{ + struct I3cManager *manager = g_i3cManager; + + if (cntlr->busId < 0 || cntlr->busId >= I3C_CNTLR_MAX) { + HDF_LOGE("%s: invalid busId:%d!", __func__, cntlr->busId); + return; + } + + if (manager == NULL) { + HDF_LOGE("%s: get i3c manager fail!", __func__); + return; + } + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("%s: lock i3c manager fail!", __func__); + return; + } + + if (manager->cntlrs[cntlr->busId] != cntlr) { + HDF_LOGE("%s: cntlr(%d) not in manager!", __func__, cntlr->busId); + } else { + manager->cntlrs[cntlr->busId] = NULL; + } + + (void)OsalMutexUnlock(&manager->lock); +} + +struct I3cCntlr *I3cCntlrGet(int16_t number) +{ + struct I3cCntlr *cntlr = NULL; + struct I3cManager *manager = g_i3cManager; + + if (number < 0 || number >= I3C_CNTLR_MAX) { + HDF_LOGE("%s: invalid busId:%d!", __func__, number); + return NULL; + } + + if (manager == NULL) { + HDF_LOGE("%s: get i3c manager fail!", __func__); + return NULL; + } + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("%s: lock i3c manager fail!", __func__); + return NULL; + } + cntlr = manager->cntlrs[number]; + (void)OsalMutexUnlock(&manager->lock); + + return cntlr; +} + +void I3cCntlrPut(struct I3cCntlr *cntlr) +{ + (void)cntlr; +} + +int32_t I3cCntlrAdd(struct I3cCntlr *cntlr) +{ + int32_t ret; + + if (cntlr == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->ops == NULL) { + HDF_LOGE("%s: no ops supplied!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->lockOps == NULL) { + HDF_LOGI("%s: use default lock methods!", __func__); + cntlr->lockOps = &g_i3cLockOpsDefault; + } + + if (OsalSpinInit(&cntlr->lock) != HDF_SUCCESS) { + HDF_LOGE("%s: init lock fail!", __func__); + return HDF_FAILURE; + } + + I3cInitAddrStatus(cntlr); + ret = I3cManagerAddCntlr(cntlr); + if (ret != HDF_SUCCESS) { + (void)OsalSpinDestroy(&cntlr->lock); + return ret; + } + + return HDF_SUCCESS; +} + +void I3cCntlrRemove(struct I3cCntlr *cntlr) +{ + if (cntlr == NULL) { + return; + } + I3cManagerRemoveCntlr(cntlr); + (void)OsalSpinDestroy(&cntlr->lock); +} + +int32_t I3cCntlrTransfer(struct I3cCntlr *cntlr, struct I3cMsg *msgs, int16_t count) +{ + int32_t ret; + + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->ops == NULL || cntlr->ops->Transfer == NULL) { + HDF_LOGE("%s: ops or i3transfer is null", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (I3cCntlrLock(cntlr) != HDF_SUCCESS) { + HDF_LOGE("%s: lock controller fail!", __func__); + return HDF_ERR_DEVICE_BUSY; + } + + ret = cntlr->ops->Transfer(cntlr, msgs, count); + I3cCntlrUnlock(cntlr); + + return ret; +} + +int32_t I3cCntlrI2cTransfer(struct I3cCntlr *cntlr, struct I3cMsg *msgs, int16_t count) +{ + int32_t ret; + + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->ops == NULL || cntlr->ops->i2cTransfer == NULL) { + HDF_LOGE("%s: ops or i2ctransfer is null", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (I3cCntlrLock(cntlr) != HDF_SUCCESS) { + HDF_LOGE("%s: lock controller fail!", __func__); + return HDF_ERR_DEVICE_BUSY; + } + ret = cntlr->ops->i2cTransfer(cntlr, msgs, count); + I3cCntlrUnlock(cntlr); + + return ret; +} + +int32_t I3cCntlrSetConfig(struct I3cCntlr *cntlr, struct I3cConfig *config) +{ + int32_t ret; + + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (config == NULL) { + HDF_LOGE("%s: config is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + if (cntlr->ops == NULL || cntlr->ops->setConfig == NULL) { + HDF_LOGE("%s: ops or setConfig is NULL!", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (I3cCntlrLock(cntlr) != HDF_SUCCESS) { + HDF_LOGE("%s: lock controller fail!", __func__); + return HDF_ERR_DEVICE_BUSY; + } + + ret = cntlr->ops->setConfig(cntlr, config); + cntlr->config = *config; + I3cCntlrUnlock(cntlr); + + return ret; +} + +int32_t I3cCntlrGetConfig(struct I3cCntlr *cntlr, struct I3cConfig *config) +{ + int32_t ret; + + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (config == NULL) { + HDF_LOGE("%s: config is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + if (cntlr->ops == NULL || cntlr->ops->getConfig == NULL) { + HDF_LOGE("%s: ops or getConfig is NULL!", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (I3cCntlrLock(cntlr) != HDF_SUCCESS) { + HDF_LOGE("%s: lock controller fail!", __func__); + return HDF_ERR_DEVICE_BUSY; + } + + ret = cntlr->ops->getConfig(cntlr, config); + config = &cntlr->config; + I3cCntlrUnlock(cntlr); + + return ret; +} + +int32_t I3cCntlrRequestIbi(struct I3cCntlr *cntlr, uint16_t addr, I3cIbiFunc func, uint32_t payload) +{ + struct I3cDevice *device = NULL; + struct I3cIbiInfo *ibi = NULL; + uint16_t ptr; + int32_t ret; + + if (cntlr == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->ops == NULL || cntlr->ops->requestIbi == NULL) { + HDF_LOGE("%s: Not support!", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if ((func == NULL) || (addr >= I3C_ADDR_MAX)) { + HDF_LOGE("%s: invalid func or addr!", __func__); + return HDF_ERR_INVALID_PARAM; + } + device = GetDeviceByAddr(cntlr, addr); + if (device == NULL) { + HDF_LOGE("%s: Get device failed!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (device->supportIbi != I3C_DEVICE_SUPPORT_IBI) { + HDF_LOGE("%s: not support!", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (I3cCntlrLock(cntlr) != HDF_SUCCESS) { + HDF_LOGE("%s: lock controller fail!", __func__); + return HDF_ERR_DEVICE_BUSY; + } + + for (ptr = 0; ptr < I3C_IBI_MAX; ptr++) { + if (cntlr->ibiSlot[ptr] != NULL) { + continue; + } + ibi = (struct I3cIbiInfo *)OsalMemCalloc(sizeof(*ibi)); + if (ibi == NULL) { + HDF_LOGE("func:%s ibi is NULL!", __func__); + return HDF_ERR_MALLOC_FAIL; + } + ibi->ibiFunc = func; + ibi->payload = payload; + ibi->data = (uint8_t *)OsalMemCalloc(sizeof(uint8_t) * payload); + device->ibi = ibi; + cntlr->ibiSlot[ptr] = device->ibi; + ret = cntlr->ops->requestIbi(device); + I3cCntlrUnlock(cntlr); + return ret; + } + I3cCntlrUnlock(cntlr); + + return HDF_ERR_DEVICE_BUSY; +} + +int32_t I3cCntlrFreeIbi(struct I3cCntlr *cntlr, uint16_t addr) +{ + struct I3cDevice *device = NULL; + uint16_t ptr; + + if (cntlr == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + if (addr >= I3C_ADDR_MAX) { + HDF_LOGE("%s: Invalid addr: %x", __func__, addr); + return HDF_ERR_INVALID_PARAM; + } + + device = GetDeviceByAddr(cntlr, addr); + if (device == NULL) { + HDF_LOGE("%s: Get device failed!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + for (ptr = 0; ptr < I3C_IBI_MAX; ptr++) { + if (cntlr->ibiSlot[ptr] == NULL || device->ibi == NULL) { + break; + } + if (cntlr->ibiSlot[ptr] != device->ibi) { + break; + } + cntlr->ibiSlot[ptr] = NULL; + if (device->ibi->data != NULL) { + OsalMemFree(device->ibi->data); + } + OsalMemFree(device->ibi); + device->ibi = NULL; + break; + } + + return HDF_SUCCESS; +} + +int32_t I3cCntlrIbiCallback(struct I3cDevice *device) +{ + struct I3cIbiData *ibiData = NULL; + + if (device == NULL) { + HDF_LOGW("%s: invalid device!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + ibiData = (struct I3cIbiData *)OsalMemCalloc(sizeof(*ibiData)); + if (ibiData == NULL) { + HDF_LOGE("%s: Memcalloc failed", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + ibiData->buf = device->ibi->data; + ibiData->payload = device->ibi->payload; + + if (device->ibi->ibiFunc == NULL) { + HDF_LOGW("%s: device->ibi or ibiFunc is NULL!", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (device->dynaAddr != 0) { + (void)device->ibi->ibiFunc(device->cntlr, device->dynaAddr, *ibiData); + OsalMemFree(ibiData); + } else { + (void)device->ibi->ibiFunc(device->cntlr, device->addr, *ibiData); + OsalMemFree(ibiData); + } + + return HDF_SUCCESS; +} + +static int32_t I3cManagerBind(struct HdfDeviceObject *device) +{ + (void)device; + HDF_LOGI("%s:Enter!", __func__); + return HDF_SUCCESS; +} + +static int32_t I3cManagerInit(struct HdfDeviceObject *device) +{ + int32_t ret; + struct I3cManager *manager = NULL; + + HDF_LOGI("%s: Enter!", __func__); + if (device == NULL) { + HDF_LOGE("%s: device is NULL", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + manager = (struct I3cManager *)OsalMemCalloc(sizeof(*manager)); + if (manager == NULL) { + HDF_LOGE("%s: malloc manager fail!", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + ret = OsalMutexInit(&manager->lock); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: mutex init fail:%d", __func__, ret); + OsalMemFree(manager); + return HDF_FAILURE; + } + manager->device = device; + g_i3cManager = manager; + DListHeadInit(&g_i3cDeviceList); + OsalSpinInit(&g_listLock); + + return HDF_SUCCESS; +} + +static void I3cManagerRelease(struct HdfDeviceObject *device) +{ + struct I3cManager *manager = NULL; + + HDF_LOGI("%s: enter", __func__); + if (device == NULL) { + HDF_LOGI("%s: device is null", __func__); + return; + } + manager = (struct I3cManager *)device->service; + if (manager == NULL) { + HDF_LOGI("%s: no service binded!", __func__); + return; + } + g_i3cManager = NULL; + OsalMemFree(manager); +} + +struct HdfDriverEntry g_i3cManagerEntry = { + .moduleVersion = 1, + .Bind = I3cManagerBind, + .Init = I3cManagerInit, + .Release = I3cManagerRelease, + .moduleName = "HDF_PLATFORM_I3C_MANAGER", +}; +HDF_INIT(g_i3cManagerEntry); diff --git a/support/platform/src/i3c/i3c_if.c b/support/platform/src/i3c/i3c_if.c new file mode 100755 index 0000000000000000000000000000000000000000..14ecb7b984a6d0fbe04f4f9ed4a4845bdedafa69 --- /dev/null +++ b/support/platform/src/i3c/i3c_if.c @@ -0,0 +1,74 @@ +/* + * Copyright (c) 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 "i3c_if.h" +#include "i3c_core.h" +#include "hdf_log.h" + +#define HDF_LOG_TAG i3c_if_c + +DevHandle I3cOpen(int16_t number) +{ + return (DevHandle)I3cCntlrGet(number); +} + +void I3cClose(DevHandle handle) +{ + I3cCntlrPut((struct I3cCntlr *)handle); +} + +int32_t I3cTransfer(DevHandle handle, struct I3cMsg *msgs, int16_t count, enum TransMode mode) +{ + int32_t ret = HDF_SUCCESS; + + if (handle == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + + if (msgs == NULL || count <= 0) { + HDF_LOGE("I3cTransfer: err params! msgs:%s, count:%d", + (msgs == NULL) ? "0" : "x", count); + return HDF_ERR_INVALID_PARAM; + } + + switch (mode) { + case I2C_MODE: + ret = I3cCntlrI2cTransfer((struct I3cCntlr *)handle, msgs, count); + break; + case I3C_MODE: + ret = I3cCntlrTransfer((struct I3cCntlr *)handle, msgs, count); + break; + case CCC_CMD_MODE: + ret = I3cCntlrSendCccCmd((struct I3cCntlr *)handle, msgs->ccc); + break; + default: + break; + } + + return ret; +} + +int32_t I3cSetConfig(DevHandle handle, struct I3cConfig *config) +{ + return I3cCntlrSetConfig((struct I3cCntlr *)handle, config); +} + +int32_t I3cGetConfig(DevHandle handle, struct I3cConfig *config) +{ + return I3cCntlrGetConfig((struct I3cCntlr *)handle, config); +} + +int32_t I3cRequestIbi(DevHandle handle, uint16_t addr, I3cIbiFunc func, uint32_t payload) +{ + return I3cCntlrRequestIbi((struct I3cCntlr *)handle, addr, func, payload); +} + +int32_t I3cFreeIbi(DevHandle handle, uint16_t addr) +{ + return I3cCntlrFreeIbi((struct I3cCntlr *)handle, addr); +} diff --git a/support/platform/src/mipi/mipi_csi_core.c b/support/platform/src/mipi/mipi_csi_core.c new file mode 100755 index 0000000000000000000000000000000000000000..f78e07a44cddedbfb8842fd35effe797567b7ff1 --- /dev/null +++ b/support/platform/src/mipi/mipi_csi_core.c @@ -0,0 +1,769 @@ +/* + * Copyright (c) 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 "mipi_csi_core.h" +#include "hdf_log.h" + +#define HDF_LOG_TAG mipi_csi_core + +struct MipiCsiHandle { + struct MipiCsiCntlr *cntlr; + struct OsalMutex lock; + void *priv; +}; + +static struct MipiCsiHandle g_mipiCsihandle[MAX_CNTLR_CNT]; + +int32_t MipiCsiRegisterCntlr(struct MipiCsiCntlr *cntlr, struct HdfDeviceObject *device) +{ + HDF_LOGI("%s: enter!", __func__); + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->devNo >= MAX_CNTLR_CNT) { + HDF_LOGE("%s: cntlr->devNo is error.", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (device == NULL) { + HDF_LOGE("%s: device is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (g_mipiCsihandle[cntlr->devNo].cntlr == NULL) { + (void)OsalMutexInit(&g_mipiCsihandle[cntlr->devNo].lock); + (void)OsalMutexInit(&(cntlr->lock)); + + g_mipiCsihandle[cntlr->devNo].cntlr = cntlr; + g_mipiCsihandle[cntlr->devNo].priv = NULL; + cntlr->device = device; + device->service = &(cntlr->service); + cntlr->priv = NULL; + HDF_LOGI("%s: success.", __func__); + + return HDF_SUCCESS; + } + + HDF_LOGE("%s: cntlr already exists.", __func__); + return HDF_FAILURE; +} + +void MipiCsiUnregisterCntlr(struct MipiCsiCntlr *cntlr) +{ + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL.", __func__); + return; + } + + (void)OsalMutexDestroy(&(cntlr->lock)); + (void)OsalMutexDestroy(&(g_mipiCsihandle[cntlr->devNo].lock)); + + HDF_LOGI("%s: success.", __func__); + return; +} + +struct MipiCsiCntlr *MipiCsiCntlrFromDevice(const struct HdfDeviceObject *device) +{ + return (device == NULL) ? NULL : (struct MipiCsiCntlr *)device->service; +} + +struct MipiCsiCntlr *MipiCsiCntlrGet(uint8_t number) +{ + struct MipiCsiCntlr *cntlr = NULL; + HDF_LOGI("%s: enter!", __func__); + + if (number >= MAX_CNTLR_CNT) { + HDF_LOGE("%s: invalid number.", __func__); + return NULL; + } + if (g_mipiCsihandle[number].cntlr == NULL) { + HDF_LOGE("%s: g_mipiCsihandle[number].cntlr is NULL.", __func__); + return NULL; + } + + (void)OsalMutexLock(&(g_mipiCsihandle[number].lock)); + g_mipiCsihandle[number].cntlr->devNo = number; + cntlr = g_mipiCsihandle[number].cntlr; + (void)OsalMutexUnlock(&(g_mipiCsihandle[number].lock)); + + return cntlr; +} + +void MipiCsiCntlrPut(const struct MipiCsiCntlr *cntlr) +{ + uint8_t number; + + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL.", __func__); + return; + } + + number = cntlr->devNo; + if (number >= MAX_CNTLR_CNT) { + HDF_LOGE("%s: invalid number.", __func__); + return; + } + + HDF_LOGI("%s: success!", __func__); +} + +int32_t MipiCsiCntlrSetComboDevAttr(struct MipiCsiCntlr *cntlr, ComboDevAttr *pAttr) +{ + int32_t ret; + HDF_LOGI("%s: enter!", __func__); + + if ((cntlr == NULL) || (cntlr->ops == NULL)) { + HDF_LOGE("%s: cntlr or ops is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (pAttr == NULL) { + HDF_LOGE("%s: pAttr is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->ops->setComboDevAttr == NULL) { + HDF_LOGE("%s: setComboDevAttr is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + ret = cntlr->ops->setComboDevAttr(cntlr, pAttr); + (void)OsalMutexUnlock(&(cntlr->lock)); + + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success!", __func__); + } else { + HDF_LOGE("%s: failed!", __func__); + } + + return ret; +} + +int32_t MipiCsiCntlrSetPhyCmvmode(struct MipiCsiCntlr *cntlr, uint8_t devno, PhyCmvMode cmvMode) +{ + int32_t ret; + HDF_LOGI("%s: enter!", __func__); + + if ((cntlr == NULL) || (cntlr->ops == NULL)) { + HDF_LOGE("%s: cntlr or ops is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->ops->setPhyCmvmode == NULL) { + HDF_LOGE("%s: setPhyCmvmode is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + ret = cntlr->ops->setPhyCmvmode(cntlr, devno, cmvMode); + (void)OsalMutexUnlock(&(cntlr->lock)); + + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success!", __func__); + } else { + HDF_LOGE("%s: failed!", __func__); + } + + return ret; +} + +int32_t MipiCsiCntlrSetExtDataType(struct MipiCsiCntlr *cntlr, ExtDataType* dataType) +{ + int32_t ret; + HDF_LOGI("%s: enter!", __func__); + + if ((cntlr == NULL) || (cntlr->ops == NULL)) { + HDF_LOGE("%s: cntlr or ops is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (dataType == NULL) { + HDF_LOGE("%s: dataType is NULL.", __func__); + return HDF_FAILURE; + } + if (cntlr->ops->setExtDataType == NULL) { + HDF_LOGE("%s: setExtDataType is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + ret = cntlr->ops->setExtDataType(cntlr, dataType); + (void)OsalMutexUnlock(&(cntlr->lock)); + + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success!", __func__); + } else { + HDF_LOGE("%s: failed!", __func__); + } + + return ret; +} + +int32_t MipiCsiCntlrSetHsMode(struct MipiCsiCntlr *cntlr, LaneDivideMode laneDivideMode) +{ + int32_t ret; + HDF_LOGI("%s: enter!", __func__); + + if ((cntlr == NULL) || (cntlr->ops == NULL)) { + HDF_LOGE("%s: cntlr or ops is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->ops->setHsMode == NULL) { + HDF_LOGE("%s: setHsMode is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + ret = cntlr->ops->setHsMode(cntlr, laneDivideMode); + (void)OsalMutexUnlock(&(cntlr->lock)); + + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success!", __func__); + } else { + HDF_LOGE("%s: failed!", __func__); + } + + return ret; +} + +int32_t MipiCsiCntlrEnableClock(struct MipiCsiCntlr *cntlr, uint8_t comboDev) +{ + int32_t ret; + HDF_LOGI("%s: enter!", __func__); + + if ((cntlr == NULL) || (cntlr->ops == NULL)) { + HDF_LOGE("%s: cntlr or ops is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->ops->enableClock == NULL) { + HDF_LOGE("%s: enableClock is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + ret = cntlr->ops->enableClock(cntlr, comboDev); + (void)OsalMutexUnlock(&(cntlr->lock)); + + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success!", __func__); + } else { + HDF_LOGE("%s: failed!", __func__); + } + + return ret; +} + +int32_t MipiCsiCntlrDisableClock(struct MipiCsiCntlr *cntlr, uint8_t comboDev) +{ + int32_t ret; + HDF_LOGI("%s: enter!", __func__); + + if ((cntlr == NULL) || (cntlr->ops == NULL)) { + HDF_LOGE("%s: cntlr or ops is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->ops->disableClock == NULL) { + HDF_LOGE("%s: disableClock is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + ret = cntlr->ops->disableClock(cntlr, comboDev); + (void)OsalMutexUnlock(&(cntlr->lock)); + + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success!", __func__); + } else { + HDF_LOGE("%s: failed!", __func__); + } + + return ret; +} + +int32_t MipiCsiCntlrResetRx(struct MipiCsiCntlr *cntlr, uint8_t comboDev) +{ + int32_t ret; + HDF_LOGI("%s: enter!", __func__); + + if ((cntlr == NULL) || (cntlr->ops == NULL)) { + HDF_LOGE("%s: cntlr or ops is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->ops->resetRx == NULL) { + HDF_LOGE("%s: resetRx is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + ret = cntlr->ops->resetRx(cntlr, comboDev); + (void)OsalMutexUnlock(&(cntlr->lock)); + + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success!", __func__); + } else { + HDF_LOGE("%s: failed!", __func__); + } + + return ret; +} + +int32_t MipiCsiCntlrUnresetRx(struct MipiCsiCntlr *cntlr, uint8_t comboDev) +{ + int32_t ret; + HDF_LOGI("%s: enter!", __func__); + + if ((cntlr == NULL) || (cntlr->ops == NULL)) { + HDF_LOGE("%s: cntlr or ops is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->ops->unresetRx == NULL) { + HDF_LOGE("%s: unresetRx is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + ret = cntlr->ops->unresetRx(cntlr, comboDev); + (void)OsalMutexUnlock(&(cntlr->lock)); + + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success!", __func__); + } else { + HDF_LOGE("%s: failed!", __func__); + } + + return ret; +} + +int32_t MipiCsiCntlrEnableSensorClock(struct MipiCsiCntlr *cntlr, uint8_t snsClkSource) +{ + int32_t ret; + HDF_LOGI("%s: enter!", __func__); + + if ((cntlr == NULL) || (cntlr->ops == NULL)) { + HDF_LOGE("%s: cntlr or ops is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->ops->enableSensorClock == NULL) { + HDF_LOGE("%s: enableSensorClock is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + ret = cntlr->ops->enableSensorClock(cntlr, snsClkSource); + (void)OsalMutexUnlock(&(cntlr->lock)); + + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success!", __func__); + } else { + HDF_LOGE("%s: failed!", __func__); + } + + return ret; +} + +int32_t MipiCsiCntlrDisableSensorClock(struct MipiCsiCntlr *cntlr, uint8_t snsClkSource) +{ + int32_t ret; + HDF_LOGI("%s: enter!", __func__); + + if ((cntlr == NULL) || (cntlr->ops == NULL)) { + HDF_LOGE("%s: cntlr or ops is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->ops->disableSensorClock == NULL) { + HDF_LOGE("%s: disableSensorClock is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + ret = cntlr->ops->disableSensorClock(cntlr, snsClkSource); + (void)OsalMutexUnlock(&(cntlr->lock)); + + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success!", __func__); + } else { + HDF_LOGE("%s: failed!", __func__); + } + + return ret; +} + +int32_t MipiCsiCntlrResetSensor(struct MipiCsiCntlr *cntlr, uint8_t snsResetSource) +{ + int32_t ret; + HDF_LOGI("%s: enter!", __func__); + + if ((cntlr == NULL) || (cntlr->ops == NULL)) { + HDF_LOGE("%s: cntlr or ops is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->ops->resetSensor == NULL) { + HDF_LOGE("%s: resetSensor is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + ret = cntlr->ops->resetSensor(cntlr, snsResetSource); + (void)OsalMutexUnlock(&(cntlr->lock)); + + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success!", __func__); + } else { + HDF_LOGE("%s: failed!", __func__); + } + + return ret; +} + +int32_t MipiCsiCntlrUnresetSensor(struct MipiCsiCntlr *cntlr, uint8_t snsResetSource) +{ + int32_t ret; + HDF_LOGI("%s: enter!", __func__); + + if ((cntlr == NULL) || (cntlr->ops == NULL)) { + HDF_LOGE("%s: cntlr or ops is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->ops->unresetSensor == NULL) { + HDF_LOGE("%s: unresetSensor is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + ret = cntlr->ops->unresetSensor(cntlr, snsResetSource); + (void)OsalMutexUnlock(&(cntlr->lock)); + + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success!", __func__); + } else { + HDF_LOGE("%s: failed!", __func__); + } + + return ret; +} + +int32_t MipiCsiCntlrSetDrvData(struct MipiCsiCntlr *cntlr, void *drvData) +{ + int32_t ret; + + if ((cntlr == NULL) || (cntlr->ops == NULL)) { + HDF_LOGE("%s: cntlr or ops is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->ops->setDrvData == NULL) { + HDF_LOGE("%s: setDrvData is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + ret = cntlr->ops->setDrvData(cntlr, drvData); + (void)OsalMutexUnlock(&(cntlr->lock)); + + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success!", __func__); + } else { + HDF_LOGE("%s: failed!", __func__); + } + + return ret; +} + +int32_t MipiCsiDebugGetMipiDevCtx(struct MipiCsiCntlr *cntlr, MipiDevCtx *ctx) +{ + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->debugs == NULL) { + HDF_LOGE("%s: debugs is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (cntlr->debugs->getMipiDevCtx == NULL) { + HDF_LOGE("%s: getMipiDevCtx is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (ctx == NULL) { + HDF_LOGE("%s: ctx is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + cntlr->debugs->getMipiDevCtx(cntlr, ctx); + (void)OsalMutexUnlock(&(cntlr->lock)); + HDF_LOGI("%s: success!", __func__); + + return HDF_SUCCESS; +} + +int32_t MipiCsiDebugGetPhyErrIntCnt(struct MipiCsiCntlr *cntlr, unsigned int phyId, PhyErrIntCnt *errInfo) +{ + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->debugs == NULL) { + HDF_LOGE("%s: debugs is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (cntlr->debugs->getPhyErrIntCnt == NULL) { + HDF_LOGE("%s: getPhyErrIntCnt is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (errInfo == NULL) { + HDF_LOGE("%s: errInfo is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + cntlr->debugs->getPhyErrIntCnt(cntlr, phyId, errInfo); + (void)OsalMutexUnlock(&(cntlr->lock)); + HDF_LOGI("%s: success!", __func__); + + return HDF_SUCCESS; +} + +int32_t MipiCsiDebugGetMipiErrInt(struct MipiCsiCntlr *cntlr, unsigned int phyId, MipiErrIntCnt *errInfo) +{ + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->debugs == NULL) { + HDF_LOGE("%s: debugs is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (cntlr->debugs->getMipiErrInt == NULL) { + HDF_LOGE("%s: getMipiErrInt is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (errInfo == NULL) { + HDF_LOGE("%s: errInfo is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + cntlr->debugs->getMipiErrInt(cntlr, phyId, errInfo); + (void)OsalMutexUnlock(&(cntlr->lock)); + HDF_LOGI("%s: success!", __func__); + + return HDF_SUCCESS; +} + +int32_t MipiCsiDebugGetLvdsErrIntCnt(struct MipiCsiCntlr *cntlr, unsigned int phyId, LvdsErrIntCnt *errInfo) +{ + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->debugs == NULL) { + HDF_LOGE("%s: debugs is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (cntlr->debugs->getLvdsErrIntCnt == NULL) { + HDF_LOGE("%s: getLvdsErrIntCnt is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (errInfo == NULL) { + HDF_LOGE("%s: errInfo is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + cntlr->debugs->getLvdsErrIntCnt(cntlr, phyId, errInfo); + (void)OsalMutexUnlock(&(cntlr->lock)); + HDF_LOGI("%s: success!", __func__); + + return HDF_SUCCESS; +} + +int32_t MipiCsiDebugGetAlignErrIntCnt(struct MipiCsiCntlr *cntlr, unsigned int phyId, AlignErrIntCnt *errInfo) +{ + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->debugs == NULL) { + HDF_LOGE("%s: debugs is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (cntlr->debugs->getAlignErrIntCnt == NULL) { + HDF_LOGE("%s: getAlignErrIntCnt is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (errInfo == NULL) { + HDF_LOGE("%s: errInfo is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + cntlr->debugs->getAlignErrIntCnt(cntlr, phyId, errInfo); + (void)OsalMutexUnlock(&(cntlr->lock)); + HDF_LOGI("%s: success!", __func__); + + return HDF_SUCCESS; +} + +int32_t MipiCsiDebugGetPhyData(struct MipiCsiCntlr *cntlr, int phyId, int laneId, unsigned int *laneData) +{ + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->debugs == NULL) { + HDF_LOGE("%s: debugs is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (cntlr->debugs->getPhyData == NULL) { + HDF_LOGE("%s: getPhyData is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (laneData == NULL) { + HDF_LOGE("%s: laneData is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + cntlr->debugs->getPhyData(cntlr, phyId, laneId, laneData); + (void)OsalMutexUnlock(&(cntlr->lock)); + HDF_LOGI("%s: success!", __func__); + + return HDF_SUCCESS; +} + +int32_t MipiCsiDebugGetPhyMipiLinkData(struct MipiCsiCntlr *cntlr, int phyId, int laneId, unsigned int *laneData) +{ + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->debugs == NULL) { + HDF_LOGE("%s: debugs is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (cntlr->debugs->getPhyMipiLinkData == NULL) { + HDF_LOGE("%s: getPhyMipiLinkData is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (laneData == NULL) { + HDF_LOGE("%s: laneData is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + cntlr->debugs->getPhyMipiLinkData(cntlr, phyId, laneId, laneData); + (void)OsalMutexUnlock(&(cntlr->lock)); + HDF_LOGI("%s: success!", __func__); + + return HDF_SUCCESS; +} + +int32_t MipiCsiDebugGetPhyLvdsLinkData(struct MipiCsiCntlr *cntlr, int phyId, int laneId, unsigned int *laneData) +{ + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->debugs == NULL) { + HDF_LOGE("%s: debugs is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (cntlr->debugs->getPhyLvdsLinkData == NULL) { + HDF_LOGE("%s: getPhyLvdsLinkData is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (laneData == NULL) { + HDF_LOGE("%s: laneData is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + cntlr->debugs->getPhyLvdsLinkData(cntlr, phyId, laneId, laneData); + (void)OsalMutexUnlock(&(cntlr->lock)); + HDF_LOGI("%s: success!", __func__); + + return HDF_SUCCESS; +} + +int32_t MipiCsiDebugGetMipiImgsizeStatis(struct MipiCsiCntlr *cntlr, uint8_t devno, short vc, ImgSize *pSize) +{ + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->debugs == NULL) { + HDF_LOGE("%s: debugs is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (cntlr->debugs->getMipiImgsizeStatis == NULL) { + HDF_LOGE("%s: getMipiImgsizeStatis is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (pSize == NULL) { + HDF_LOGE("%s: pSize is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + cntlr->debugs->getMipiImgsizeStatis(cntlr, devno, vc, pSize); + (void)OsalMutexUnlock(&(cntlr->lock)); + HDF_LOGI("%s: success!", __func__); + + return HDF_SUCCESS; +} + +int32_t MipiCsiDebugGetLvdsImgsizeStatis(struct MipiCsiCntlr *cntlr, uint8_t devno, short vc, ImgSize *pSize) +{ + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->debugs == NULL) { + HDF_LOGE("%s: debugs is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (cntlr->debugs->getLvdsImgsizeStatis == NULL) { + HDF_LOGE("%s: getLvdsImgsizeStatis is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (pSize == NULL) { + HDF_LOGE("%s: pSize is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + cntlr->debugs->getLvdsImgsizeStatis(cntlr, devno, vc, pSize); + (void)OsalMutexUnlock(&(cntlr->lock)); + HDF_LOGI("%s: success!", __func__); + + return HDF_SUCCESS; +} + +int32_t MipiCsiDebugGetLvdsLaneImgsizeStatis(struct MipiCsiCntlr *cntlr, uint8_t devno, short lane, ImgSize *pSize) +{ + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (cntlr->debugs == NULL) { + HDF_LOGE("%s: debugs is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (cntlr->debugs->getLvdsLaneImgsizeStatis == NULL) { + HDF_LOGE("%s: getLvdsLaneImgsizeStatis is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + if (pSize == NULL) { + HDF_LOGE("%s: pSize is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + cntlr->debugs->getLvdsLaneImgsizeStatis(cntlr, devno, lane, pSize); + (void)OsalMutexUnlock(&(cntlr->lock)); + HDF_LOGI("%s: success!", __func__); + + return HDF_SUCCESS; +} \ No newline at end of file diff --git a/support/platform/src/mipi/mipi_csi_if.c b/support/platform/src/mipi/mipi_csi_if.c new file mode 100755 index 0000000000000000000000000000000000000000..4da0556204753cdf4d8bfc1944213e346f82f4bc --- /dev/null +++ b/support/platform/src/mipi/mipi_csi_if.c @@ -0,0 +1,87 @@ +/* + * Copyright (c) 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 "mipi_csi_if.h" +#include "mipi_csi_core.h" + +#define HDF_LOG_TAG mipi_csi_if + +DevHandle MipiCsiOpen(uint8_t id) +{ + return (DevHandle)MipiCsiCntlrGet(id); +} + +void MipiCsiClose(DevHandle handle) +{ + MipiCsiCntlrPut((struct MipiCsiCntlr *)handle); +} + +int32_t MipiCsiSetComboDevAttr(DevHandle handle, ComboDevAttr *pAttr) +{ + return MipiCsiCntlrSetComboDevAttr((struct MipiCsiCntlr *)handle, pAttr); +} + +int32_t MipiCsiSetPhyCmvmode(DevHandle handle, uint8_t devno, PhyCmvMode cmvMode) +{ + return MipiCsiCntlrSetPhyCmvmode((struct MipiCsiCntlr *)handle, devno, cmvMode); +} + +int32_t MipiCsiSetExtDataType(DevHandle handle, ExtDataType* dataType) +{ + return MipiCsiCntlrSetExtDataType((struct MipiCsiCntlr *)handle, dataType); +} + +int32_t MipiCsiSetHsMode(DevHandle handle, LaneDivideMode laneDivideMode) +{ + return MipiCsiCntlrSetHsMode((struct MipiCsiCntlr *)handle, laneDivideMode); +} + +int32_t MipiCsiEnableClock(DevHandle handle, uint8_t comboDev) +{ + return MipiCsiCntlrEnableClock((struct MipiCsiCntlr *)handle, comboDev); +} + +int32_t MipiCsiDisableClock(DevHandle handle, uint8_t comboDev) +{ + return MipiCsiCntlrDisableClock((struct MipiCsiCntlr *)handle, comboDev); +} + +int32_t MipiCsiResetRx(DevHandle handle, uint8_t comboDev) +{ + return MipiCsiCntlrResetRx((struct MipiCsiCntlr *)handle, comboDev); +} + +int32_t MipiCsiUnresetRx(DevHandle handle, uint8_t comboDev) +{ + return MipiCsiCntlrUnresetRx((struct MipiCsiCntlr *)handle, comboDev); +} + +int32_t MipiCsiEnableSensorClock(DevHandle handle, uint8_t snsClkSource) +{ + return MipiCsiCntlrEnableSensorClock((struct MipiCsiCntlr *)handle, snsClkSource); +} + +int32_t MipiCsiDisableSensorClock(DevHandle handle, uint8_t snsClkSource) +{ + return MipiCsiCntlrDisableSensorClock((struct MipiCsiCntlr *)handle, snsClkSource); +} + +int32_t MipiCsiResetSensor(DevHandle handle, uint8_t snsResetSource) +{ + return MipiCsiCntlrResetSensor((struct MipiCsiCntlr *)handle, snsResetSource); +} + +int32_t MipiCsiUnresetSensor(DevHandle handle, uint8_t snsResetSource) +{ + return MipiCsiCntlrUnresetSensor((struct MipiCsiCntlr *)handle, snsResetSource); +} + +int32_t MipiCsiSetDrvData(DevHandle handle, void *drvData) +{ + return MipiCsiCntlrSetDrvData((struct MipiCsiCntlr *)handle, drvData); +} diff --git a/support/platform/src/mipi_dsi_core.c b/support/platform/src/mipi/mipi_dsi_core.c similarity index 85% rename from support/platform/src/mipi_dsi_core.c rename to support/platform/src/mipi/mipi_dsi_core.c index 8d75f5b1311358a4726f953ab3526dba8806889c..42f8bd2852d490c84ea9c0b87f9eb106ec165f1b 100644 --- a/support/platform/src/mipi_dsi_core.c +++ b/support/platform/src/mipi/mipi_dsi_core.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * Copyright (c) 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. @@ -23,10 +23,9 @@ static struct MipiDsiHandle g_mipiDsihandle[MAX_CNTLR_CNT]; int32_t MipiDsiRegisterCntlr(struct MipiDsiCntlr *cntlr, struct HdfDeviceObject *device) { - HDF_LOGI("%s: enter!", __func__); if (cntlr == NULL) { HDF_LOGE("%s: cntlr is NULL.", __func__); - return HDF_ERR_INVALID_PARAM; + return HDF_ERR_INVALID_OBJECT; } if (cntlr->devNo >= MAX_CNTLR_CNT) { HDF_LOGE("%s: cntlr->devNo is error.", __func__); @@ -35,7 +34,7 @@ int32_t MipiDsiRegisterCntlr(struct MipiDsiCntlr *cntlr, struct HdfDeviceObject if (device == NULL) { HDF_LOGE("%s: device is NULL.", __func__); - return HDF_FAILURE; + return HDF_ERR_INVALID_OBJECT; } if (g_mipiDsihandle[cntlr->devNo].cntlr == NULL) { @@ -78,7 +77,6 @@ struct MipiDsiCntlr *MipiDsiCntlrFromDevice(struct HdfDeviceObject *device) struct MipiDsiCntlr *MipiDsiCntlrOpen(uint8_t number) { struct MipiDsiCntlr *cntlr = NULL; - HDF_LOGI("%s: enter!", __func__); if (number >= MAX_CNTLR_CNT) { HDF_LOGE("%s: invalid number.", __func__); @@ -100,12 +98,14 @@ struct MipiDsiCntlr *MipiDsiCntlrOpen(uint8_t number) void MipiDsiCntlrClose(struct MipiDsiCntlr *cntlr) { + uint8_t number; + if (cntlr == NULL) { HDF_LOGE("%s: cntlr is NULL.", __func__); return; } - uint8_t number = cntlr->devNo; + number = cntlr->devNo; if (number >= MAX_CNTLR_CNT) { HDF_LOGE("%s: invalid number.", __func__); return; @@ -117,16 +117,15 @@ void MipiDsiCntlrClose(struct MipiDsiCntlr *cntlr) int32_t MipiDsiCntlrSetCfg(struct MipiDsiCntlr *cntlr, struct MipiCfg *cfg) { int32_t ret; - HDF_LOGI("%s: enter!", __func__); if ((cntlr == NULL) || (cntlr->ops == NULL)) { HDF_LOGE("%s: cntlr or ops is NULL.", __func__); - return HDF_FAILURE; + return HDF_ERR_INVALID_OBJECT; } if (cfg == NULL) { HDF_LOGE("%s: cfg is NULL.", __func__); - return HDF_FAILURE; + return HDF_ERR_INVALID_OBJECT; } if (cntlr->ops->setCntlrCfg == NULL) { @@ -136,12 +135,10 @@ int32_t MipiDsiCntlrSetCfg(struct MipiDsiCntlr *cntlr, struct MipiCfg *cfg) (void)OsalMutexLock(&(cntlr->lock)); cntlr->cfg = *cfg; - ret = cntlr->ops->setCntlrCfg(cntlr); + ret = cntlr->ops->setCntlrCfg(cntlr); (void)OsalMutexUnlock(&(cntlr->lock)); - if (ret == HDF_SUCCESS) { - HDF_LOGI("%s: success!", __func__); - } else { + if (ret != HDF_SUCCESS) { HDF_LOGE("%s: failed!", __func__); } @@ -152,11 +149,11 @@ int32_t MipiDsiCntlrGetCfg(struct MipiDsiCntlr *cntlr, struct MipiCfg *cfg) { if ((cntlr == NULL) || (cntlr->ops == NULL)) { HDF_LOGE("%s: cntlr or ops is NULL.", __func__); - return HDF_FAILURE; + return HDF_ERR_INVALID_OBJECT; } if (cfg == NULL) { HDF_LOGE("%s: cfg is NULL.", __func__); - return HDF_FAILURE; + return HDF_ERR_INVALID_OBJECT; } (void)OsalMutexLock(&(cntlr->lock)); @@ -240,11 +237,11 @@ int32_t MipiDsiCntlrTx(struct MipiDsiCntlr *cntlr, struct DsiCmdDesc *cmd) if ((cntlr == NULL) || (cntlr->ops == NULL)) { HDF_LOGE("%s: cntlr or ops is NULL.", __func__); - return HDF_FAILURE; + return HDF_ERR_INVALID_OBJECT; } if (cmd == NULL) { HDF_LOGE("%s: cmd is NULL.", __func__); - return HDF_FAILURE; + return HDF_ERR_INVALID_OBJECT; } if (cntlr->ops->setCmd == NULL) { @@ -259,9 +256,7 @@ int32_t MipiDsiCntlrTx(struct MipiDsiCntlr *cntlr, struct DsiCmdDesc *cmd) } (void)OsalMutexUnlock(&(cntlr->lock)); - if (ret == HDF_SUCCESS) { - HDF_LOGI("%s: success!", __func__); - } else { + if (ret != HDF_SUCCESS) { HDF_LOGE("%s: failed!", __func__); } @@ -274,11 +269,11 @@ int32_t MipiDsiCntlrRx(struct MipiDsiCntlr *cntlr, struct DsiCmdDesc *cmd, int32 if ((cntlr == NULL) || (cntlr->ops == NULL)) { HDF_LOGE("%s: cntlr or ops is NULL.", __func__); - return HDF_FAILURE; + return HDF_ERR_INVALID_OBJECT; } if ((cmd == NULL) || (out == NULL)) { HDF_LOGE("%s: cmd or out is NULL.", __func__); - return HDF_FAILURE; + return HDF_ERR_INVALID_OBJECT; } if (cntlr->ops->getCmd == NULL) { @@ -290,9 +285,7 @@ int32_t MipiDsiCntlrRx(struct MipiDsiCntlr *cntlr, struct DsiCmdDesc *cmd, int32 ret = cntlr->ops->getCmd(cntlr, cmd, readLen, out); (void)OsalMutexUnlock(&(cntlr->lock)); - if (ret == HDF_SUCCESS) { - HDF_LOGI("%s: success!", __func__); - } else { + if (ret != HDF_SUCCESS) { HDF_LOGE("%s: failed!", __func__); } @@ -305,7 +298,7 @@ int32_t MipiDsiCntlrPowerControl(struct MipiDsiCntlr *cntlr, uint8_t enable) if ((cntlr == NULL) || (cntlr->ops == NULL)) { HDF_LOGE("%s: cntlr or ops is NULL.", __func__); - return HDF_FAILURE; + return HDF_ERR_INVALID_OBJECT; } if (cntlr->ops->powerControl == NULL) { @@ -317,9 +310,7 @@ int32_t MipiDsiCntlrPowerControl(struct MipiDsiCntlr *cntlr, uint8_t enable) ret = cntlr->ops->powerControl(cntlr, enable); (void)OsalMutexUnlock(&(cntlr->lock)); - if (ret == HDF_SUCCESS) { - HDF_LOGI("%s: success!", __func__); - } else { + if (ret != HDF_SUCCESS) { HDF_LOGE("%s: failed!", __func__); } @@ -332,7 +323,7 @@ int32_t MipiDsiCntlrAttach(struct MipiDsiCntlr *cntlr, uint8_t *name) if ((cntlr == NULL) || (cntlr->ops == NULL)) { HDF_LOGE("%s: cntlr or ops is NULL.", __func__); - return HDF_FAILURE; + return HDF_ERR_INVALID_OBJECT; } if (cntlr->ops->attach == NULL) { @@ -344,9 +335,32 @@ int32_t MipiDsiCntlrAttach(struct MipiDsiCntlr *cntlr, uint8_t *name) ret = cntlr->ops->attach(cntlr, name); (void)OsalMutexUnlock(&(cntlr->lock)); - if (ret == HDF_SUCCESS) { - HDF_LOGI("%s: success!", __func__); - } else { + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: failed!", __func__); + } + + return ret; +} + +int32_t MipiDsiCntlrSetDrvData(struct MipiDsiCntlr *cntlr, void *panelData) +{ + int32_t ret; + + if ((cntlr == NULL) || (cntlr->ops == NULL)) { + HDF_LOGE("%s: cntlr or ops is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->ops->setDrvData == NULL) { + HDF_LOGE("%s: setDrvData is NULL.", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + (void)OsalMutexLock(&(cntlr->lock)); + ret = cntlr->ops->setDrvData(cntlr, panelData); + (void)OsalMutexUnlock(&(cntlr->lock)); + + if (ret != HDF_SUCCESS) { HDF_LOGE("%s: failed!", __func__); } diff --git a/support/platform/src/mipi_dsi_if.c b/support/platform/src/mipi/mipi_dsi_if.c similarity index 90% rename from support/platform/src/mipi_dsi_if.c rename to support/platform/src/mipi/mipi_dsi_if.c index a1c4827494f60a177da331a8af495ea2016d0c16..3d22e9a26e1993c773feaada0ef08c22a58cd290 100755 --- a/support/platform/src/mipi_dsi_if.c +++ b/support/platform/src/mipi/mipi_dsi_if.c @@ -5,7 +5,7 @@ * the GPL, or the BSD license, at your option. * See the LICENSE file in the root of this repository for complete details. */ - + #include "mipi_dsi_if.h" #include "mipi_dsi_core.h" @@ -55,3 +55,8 @@ int32_t MipiDsiAttach(DevHandle handle, uint8_t *name) { return MipiDsiCntlrAttach((struct MipiDsiCntlr *)handle, name); } + +int32_t MipiDsiSetDrvData(DevHandle handle, void *panelData) +{ + return MipiDsiCntlrSetDrvData((struct MipiDsiCntlr *)handle, panelData); +} diff --git a/support/platform/src/mmc/mmc_block.c b/support/platform/src/mmc/mmc_block.c deleted file mode 100644 index 2917a2842919be037a7a171690a26b2b66c1d719..0000000000000000000000000000000000000000 --- a/support/platform/src/mmc/mmc_block.c +++ /dev/null @@ -1,166 +0,0 @@ -/* - * 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 "storage_block.h" -#include "hdf_base.h" -#include "hdf_log.h" -#include "mmc_corex.h" -#include "mmc_sd.h" -#include "osal_mem.h" -#include "securec.h" - -static ssize_t MmcBlockRead(struct StorageBlock *sb, uint8_t *buf, size_t secStart, size_t nSec) -{ - if (sb == NULL) { - return HDF_ERR_INVALID_OBJECT; - } - if (sb->type == MEDIA_MMC) { - return MmcDeviceRead((struct MmcDevice *)sb->media, buf, secStart, nSec); - } - return HDF_ERR_NOT_SUPPORT; -} - -static ssize_t MmcBlockWrite(struct StorageBlock *sb, const uint8_t *buf, size_t secStart, size_t nSec) -{ - if (sb == NULL) { - return HDF_ERR_INVALID_OBJECT; - } - if (sb->type == MEDIA_MMC) { - return MmcDeviceWrite((struct MmcDevice *)sb->media, (uint8_t *)buf, secStart, nSec); - } - return HDF_ERR_NOT_SUPPORT; -} - -static ssize_t MmcBlockErase(struct StorageBlock *sb, size_t secStart, size_t nSec) -{ - if (sb == NULL) { - return HDF_ERR_INVALID_OBJECT; - } - if (sb->type == MEDIA_MMC) { - return MmcDeviceErase((struct MmcDevice *)sb->media, secStart, nSec); - } - return HDF_ERR_NOT_SUPPORT; -} - -static uint32_t MmcBlockGetAuSize(struct StorageBlock *sb) -{ - struct MmcDevice *mmc = NULL; - struct SdDevice *sd = NULL; - - if (sb == NULL || sb->media == NULL) { - HDF_LOGE("MmcBlockGetAuSize: invalid sb or media!"); - return 0; - } - - if (sb->type != MEDIA_MMC) { - HDF_LOGE("MmcBlockGetAuSize: media is not mmc!"); - return 0; - } - - mmc = (struct MmcDevice *)sb->media; - if (mmc->type != MMC_DEV_SD) { - HDF_LOGE("MmcBlockGetAuSize: media is not sd!"); - return 0; - } - sd = (struct SdDevice *)mmc; - - return sd->reg.ssr.auSize; -} - -static bool MmcBlockIsPresent(struct StorageBlock *sb) -{ - return (sb != NULL && sb->type == MEDIA_MMC && - MmcDeviceIsPresent((struct MmcDevice *)sb->media)); -} - -static struct StorageBlockMethod g_mmcBlockOps = { - .read = MmcBlockRead, - .write = MmcBlockWrite, - .erase = MmcBlockErase, - .getAuSize = MmcBlockGetAuSize, - .isPresent = MmcBlockIsPresent, -}; - -static int32_t MmcBlockInit(struct StorageBlock *sb, struct MmcDevice *mmc) -{ - int32_t ret; - size_t nameSize; - - if (PlatformDeviceGet(&mmc->device) == NULL) { - return HDF_PLT_ERR_DEV_GET; - } - mmc->sb = sb; - sb->type = MEDIA_MMC; - sb->media = mmc; - sb->secSize = mmc->secSize; - sb->capacity = mmc->capacity; - sb->removeable = (mmc->state.bits.removeable == 0) ? false : true; - sb->ops = &g_mmcBlockOps; - nameSize = sizeof(sb->name); - ret = snprintf_s(sb->name, nameSize, nameSize - 1, "/dev/mmcblk%0d", mmc->cntlr->index); - if (ret <= 0) { - PlatformDevicePut(&mmc->device); - } - - return HDF_SUCCESS; -} - -static void MmcBlockUninit(struct StorageBlock *sb) -{ - struct MmcDevice *mmc = (struct MmcDevice *)sb->media; - - mmc->sb = NULL; - PlatformDevicePut(&mmc->device); -} - -int32_t MmcBlockAdd(struct MmcDevice *mmc) -{ - int32_t ret; - struct StorageBlock *sb = NULL; - - if (mmc == NULL) { - return HDF_ERR_INVALID_OBJECT; - } - - sb = (struct StorageBlock *)OsalMemCalloc(sizeof(*sb)); - if (sb == NULL) { - return HDF_ERR_MALLOC_FAIL; - } - - ret = MmcBlockInit(sb, mmc); - if (ret != HDF_SUCCESS) { - OsalMemFree(sb); - return ret; - } - - ret = StorageBlockAdd(sb); - if (ret != HDF_SUCCESS) { - MmcBlockUninit(sb); - OsalMemFree(sb); - return ret; - } - - return HDF_SUCCESS; -} - -void MmcBlockDel(struct MmcDevice *mmc) -{ - struct StorageBlock *sb = NULL; - - if (mmc == NULL) { - return; - } - sb = mmc->sb; - if (sb == NULL) { - return; - } - - StorageBlockDel(sb); - MmcBlockUninit(sb); - OsalMemFree(sb); -} diff --git a/support/platform/src/pin/pin_core.c b/support/platform/src/pin/pin_core.c new file mode 100644 index 0000000000000000000000000000000000000000..cf8b6958a0d07117c9698b28633143473a7a6083 --- /dev/null +++ b/support/platform/src/pin/pin_core.c @@ -0,0 +1,389 @@ +/* + * Copyright (c) 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 "pin_core.h" +#include "hdf_log.h" + +#define HDF_LOG_TAG pin_core + +#define MAX_CNT_PER_CNTLR 20 + +static struct DListHead g_cntlrListHead; +static OsalSpinlock g_listLock; +static uint32_t g_irqSave; + +static struct DListHead *PinCntlrListGet(void) +{ + static struct DListHead *head = NULL; + uint32_t irqSave; + if (head == NULL) { + head = &g_cntlrListHead; + DListHeadInit(head); + OsalSpinInit(&g_listLock); + } + while (OsalSpinLockIrqSave(&g_listLock, &irqSave) != HDF_SUCCESS); + g_irqSave = irqSave; + return head; +} + +static void PinCntlrListPut(void) +{ + (void)OsalSpinUnlockIrqRestore(&g_listLock, &g_irqSave); +} + +int32_t PinCntlrAdd(struct PinCntlr *cntlr) +{ + struct DListHead *head = NULL; + + if (cntlr == NULL) { + HDF_LOGE("%s: invalid object cntlr is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + DListHeadInit(&cntlr->node); + + if (cntlr->method == NULL) { + HDF_LOGE("%s: no method supplied!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->pinCount >= MAX_CNT_PER_CNTLR) { + HDF_LOGE("%s: invalid pinCount:%u", __func__, cntlr->pinCount); + return HDF_ERR_INVALID_PARAM; + } + + OsalSpinInit(&cntlr->spin); + + head = PinCntlrListGet(); + DListInsertTail(&cntlr->node, head); + PinCntlrListPut(); + return HDF_SUCCESS; +} + +void PinCntlrRemove(struct PinCntlr *cntlr) +{ + if (cntlr == NULL) { + HDF_LOGE("%s: cntlr is NULL!", __func__); + return; + } + + (void)PinCntlrListGet(); + DListRemove(&cntlr->node); + PinCntlrListPut(); + (void)OsalSpinDestroy(&cntlr->spin); +} + +struct PinDesc *PinCntlrGetPinDescByName(const char *pinName) +{ + struct DListHead *head = NULL; + struct PinCntlr *cntlr = NULL; + struct PinCntlr *tmp = NULL; + int32_t num; + + if (pinName == NULL) { + HDF_LOGE("%s: pinName is NULL!", __func__); + return NULL; + } + + head = PinCntlrListGet(); + + DLIST_FOR_EACH_ENTRY_SAFE(cntlr, tmp, head, struct PinCntlr, node) { + for (num = 0; num < cntlr->pinCount; num++) { + if (cntlr->pins[num].pinName == NULL) { + continue; + } + if (!strcmp(cntlr->pins[num].pinName, pinName)) { + PinCntlrListPut(); + HDF_LOGI("%s: cntlr->pins[%d].pinName is %s!", __func__, num, cntlr->pins[num].pinName); + return &cntlr->pins[num]; + } + } + } + PinCntlrListPut(); + HDF_LOGE("%s: pinName:%s doesn't matching!", __func__, pinName); + return NULL; +} + +struct PinCntlr *PinCntlrGetByNumber(uint16_t number) +{ + struct DListHead *head = NULL; + struct PinCntlr *cntlr = NULL; + struct PinCntlr *tmp = NULL; + + head = PinCntlrListGet(); + + DLIST_FOR_EACH_ENTRY_SAFE(cntlr, tmp, head, struct PinCntlr, node) { + if (cntlr->number == number) { + PinCntlrListPut(); + HDF_LOGI("%s: get cntlr by number success!", __func__); + return cntlr; + } + } + PinCntlrListPut(); + HDF_LOGE("%s: get cntlr by number error!", __func__); + return NULL; +} + +struct PinCntlr *PinCntlrGetByPin(struct PinDesc *desc) +{ + struct DListHead *head = NULL; + struct PinCntlr *cntlr = NULL; + struct PinCntlr *tmp = NULL; + int32_t num; + + head = PinCntlrListGet(); + + DLIST_FOR_EACH_ENTRY_SAFE(cntlr, tmp, head, struct PinCntlr, node) { + for (num = 0; num pinCount; num++) { + if (desc == &cntlr->pins[num]) { + PinCntlrListPut(); + HDF_LOGI("%s: get cntlr by desc success!", __func__); + return cntlr; + } + } + } + PinCntlrListPut(); + HDF_LOGE("%s: pinCtrl:%s not in any controllers!", __func__, desc->pinName); + return NULL; +} + +static int32_t GetPinIndex(struct PinCntlr *cntlr, struct PinDesc *desc) +{ + int32_t index, ret; + + for (index = 0; index < cntlr->pinCount; index++) { + if (cntlr->pins[index].pinName == NULL) { + HDF_LOGE("%s: cntlr->pin[index].pinName is NULL!", __func__); + break; + } + ret = strcmp(cntlr->pins[index].pinName, desc->pinName); + if (ret == 0) { + HDF_LOGI("%s: get pin index:%d success!", __func__, index); + return index; + } + } + HDF_LOGE("%s: get pin index failed!", __func__); + return HDF_ERR_INVALID_PARAM; +} + +void PinCntlrPutPin(struct PinDesc *desc) +{ + (void)desc; +} + +int32_t PinCntlrSetPinPull(struct PinCntlr *cntlr, struct PinDesc *desc, enum PinPullType pullType) +{ + int32_t ret; + uint32_t index; + uint32_t irqSave; + + if (cntlr == NULL) { + HDF_LOGE("%s: invalid object cntlr is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->method == NULL || cntlr->method->SetPinPull == NULL) { + HDF_LOGE("%s: method or SetPinPull is NULL", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (desc == NULL) { + HDF_LOGE("%s: desc is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + + index = (uint32_t)GetPinIndex(cntlr, desc); + if (index < HDF_SUCCESS) { + HDF_LOGE("%s: get pin index fail!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + (void)OsalSpinLockIrqSave(&cntlr->spin, &irqSave); + ret = cntlr->method->SetPinPull(cntlr, index, pullType); + (void)OsalSpinUnlockIrqRestore(&cntlr->spin, &irqSave); + return ret; +} + +int32_t PinCntlrGetPinPull(struct PinCntlr *cntlr, struct PinDesc *desc, enum PinPullType *pullType) +{ + int32_t ret; + uint32_t index; + uint32_t irqSave; + if (cntlr == NULL) { + HDF_LOGE("%s: invalid object cntlr is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->method == NULL || cntlr->method->GetPinPull == NULL) { + HDF_LOGE("%s: method or GetPinPull is NULL", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (desc == NULL) { + HDF_LOGE("%s: desc is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + + if (pullType == NULL) { + HDF_LOGE("%s: pullType is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + + index = (uint32_t)GetPinIndex(cntlr, desc); + if (index < HDF_SUCCESS) { + HDF_LOGE("%s: get pin index failed!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + (void)OsalSpinLockIrqSave(&cntlr->spin, &irqSave); + ret = cntlr->method->GetPinPull(cntlr, index, pullType); + (void)OsalSpinUnlockIrqRestore(&cntlr->spin, &irqSave); + + return ret; +} + +int32_t PinCntlrSetPinStrength(struct PinCntlr *cntlr, struct PinDesc *desc, uint32_t strength) +{ + int32_t ret; + uint32_t index; + uint32_t irqSave; + + if (cntlr == NULL) { + HDF_LOGE("%s: invalid object cntlr is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->method == NULL || cntlr->method->SetPinStrength == NULL) { + HDF_LOGE("%s: method or SetStrength is NULL", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (desc == NULL) { + HDF_LOGE("%s: desc is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + + index = (uint32_t)GetPinIndex(cntlr, desc); + if (index < HDF_SUCCESS) { + HDF_LOGE("%s: get pin index fail!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + (void)OsalSpinLockIrqSave(&cntlr->spin, &irqSave); + ret = cntlr->method->SetPinStrength(cntlr, index, strength); + (void)OsalSpinUnlockIrqRestore(&cntlr->spin, &irqSave); + return ret; +} + +int32_t PinCntlrGetPinStrength(struct PinCntlr *cntlr, struct PinDesc *desc, uint32_t *strength) +{ + int32_t ret; + uint32_t index; + uint32_t irqSave; + if (cntlr == NULL) { + HDF_LOGE("%s: invalid object cntlr is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->method == NULL || cntlr->method->GetPinStrength == NULL) { + HDF_LOGE("%s: method or GetStrength is NULL", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (desc == NULL) { + HDF_LOGE("%s: desc is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + + if (strength == NULL) { + HDF_LOGE("%s: strength is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + + index = (uint32_t)GetPinIndex(cntlr, desc); + if (index < HDF_SUCCESS) { + HDF_LOGE("%s: get pin index failed!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + (void)OsalSpinLockIrqSave(&cntlr->spin, &irqSave); + ret = cntlr->method->GetPinStrength(cntlr, index, strength); + (void)OsalSpinUnlockIrqRestore(&cntlr->spin, &irqSave); + + return ret; +} + +int32_t PinCntlrSetPinFunc(struct PinCntlr *cntlr, struct PinDesc *desc, const char *funcName) +{ + int32_t ret; + uint32_t index; + uint32_t irqSave; + + if (cntlr == NULL) { + HDF_LOGE("%s: invalid object cntlr is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->method == NULL || cntlr->method->SetPinFunc == NULL) { + HDF_LOGE("%s: method or SetPinFunc is NULL", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (desc == NULL) { + HDF_LOGE("%s: desc is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + + index = (uint32_t)GetPinIndex(cntlr, desc); + if (index < HDF_SUCCESS) { + HDF_LOGE("%s: get pin index failed!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + if (funcName == NULL) { + HDF_LOGE("%s: invalid funcName pointer", __func__); + return HDF_ERR_INVALID_PARAM; + } + + (void)OsalSpinLockIrqSave(&cntlr->spin, &irqSave); + ret = cntlr->method->SetPinFunc(cntlr, index, funcName); + (void)OsalSpinUnlockIrqRestore(&cntlr->spin, &irqSave); + return ret; +} + +int32_t PinCntlrGetPinFunc(struct PinCntlr *cntlr, struct PinDesc *desc, const char **funcName) +{ + int32_t ret; + uint32_t index; + uint32_t irqSave; + + if (cntlr == NULL) { + HDF_LOGE("%s: invalid object cntlr is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (cntlr->method == NULL || cntlr->method->GetPinFunc == NULL) { + HDF_LOGE("%s: method or SetPinFunc is NULL", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + if (desc == NULL) { + HDF_LOGE("%s: desc is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + + index = (uint32_t)GetPinIndex(cntlr, desc); + if (index < HDF_SUCCESS) { + HDF_LOGE("%s: get pin index failed!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + (void)OsalSpinLockIrqSave(&cntlr->spin, &irqSave); + ret = cntlr->method->GetPinFunc(cntlr, index, funcName); + (void)OsalSpinUnlockIrqRestore(&cntlr->spin, &irqSave); + return ret; +} diff --git a/support/platform/src/pin/pin_if.c b/support/platform/src/pin/pin_if.c new file mode 100644 index 0000000000000000000000000000000000000000..79d282f0ef7525dab378e6aa8eca20fd6ad66a5b --- /dev/null +++ b/support/platform/src/pin/pin_if.c @@ -0,0 +1,105 @@ +/* + * Copyright (c) 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 "pin_if.h" +#include "pin_core.h" +#include "hdf_log.h" + +#define HDF_LOG_TAG pin_if + +DevHandle PinGet(const char *pinName) +{ + return (DevHandle)PinCntlrGetPinDescByName(pinName); +} + +void PinPut(DevHandle handle) +{ + if (handle == NULL) { + HDF_LOGE("%s: handle is NULL!", __func__); + return; + } + return PinCntlrPutPin((struct PinDesc *)handle); +} + +int32_t PinSetPull(DevHandle handle, enum PinPullType pullType) +{ + struct PinCntlr *cntlr = NULL; + + if (handle == NULL) { + HDF_LOGE("%s: invalid handle!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + cntlr = PinCntlrGetByPin((struct PinDesc *)handle); + return PinCntlrSetPinPull(cntlr, (struct PinDesc *)handle, pullType); +} + +int32_t PinGetPull(DevHandle handle, enum PinPullType *pullType) +{ + struct PinCntlr *cntlr = NULL; + + if (handle == NULL) { + HDF_LOGE("%s: invalid handle!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + cntlr = PinCntlrGetByPin((struct PinDesc *)handle); + return PinCntlrGetPinPull(cntlr, (struct PinDesc *)handle, pullType); +} + +int32_t PinSetStrength(DevHandle handle, uint32_t strength) +{ + struct PinCntlr *cntlr = NULL; + + if (handle == NULL) { + HDF_LOGE("%s: invalid handle!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + cntlr = PinCntlrGetByPin((struct PinDesc *)handle); + return PinCntlrSetPinStrength(cntlr, (struct PinDesc *)handle, strength); +} + +int32_t PinGetStrength(DevHandle handle, uint32_t *strength) +{ + struct PinCntlr *cntlr = NULL; + + if (handle == NULL) { + HDF_LOGE("%s: invalid handle!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + cntlr = PinCntlrGetByPin((struct PinDesc *)handle); + return PinCntlrGetPinStrength(cntlr, (struct PinDesc *)handle, strength); +} + +int32_t PinSetFunc(DevHandle handle, const char *funcName) +{ + struct PinCntlr *cntlr = NULL; + + if (handle == NULL) { + HDF_LOGE("%s: invalid handle!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + cntlr = PinCntlrGetByPin((struct PinDesc *)handle); + return PinCntlrSetPinFunc(cntlr, (struct PinDesc *)handle, funcName); +} + +int32_t PinGetFunc(DevHandle handle, const char **funcName) +{ + struct PinCntlr *cntlr = NULL; + + if (handle == NULL) { + HDF_LOGE("%s: invalid handle!", __func__); + return HDF_ERR_INVALID_PARAM; + } + + cntlr = PinCntlrGetByPin((struct PinDesc *)handle); + return PinCntlrGetPinFunc(cntlr, (struct PinDesc *)handle, funcName); +} \ No newline at end of file diff --git a/support/platform/src/pwm_core.c b/support/platform/src/pwm/pwm_core.c similarity index 50% rename from support/platform/src/pwm_core.c rename to support/platform/src/pwm/pwm_core.c index 98b2347be96b7dd91de36b011c2cbdff8d7683ff..82c7736af6b7344f268b430eeceba15e7d84079f 100644 --- a/support/platform/src/pwm_core.c +++ b/support/platform/src/pwm/pwm_core.c @@ -6,71 +6,44 @@ * See the LICENSE file in the root of this repository for complete details. */ -#include "hdf_log.h" -#include "osal_mem.h" #include "pwm_core.h" -#include "pwm_if.h" -#include "securec.h" +#include "hdf_log.h" -#define HDF_LOG_TAG PWM_CORE -#define PWM_NAME_LEN 32 +#define HDF_LOG_TAG pwm_core -static struct PwmDev *PwmGetDevByNum(uint32_t num) -{ - int ret; - char *name = NULL; - struct PwmDev *pwm = NULL; - - name = (char *)OsalMemCalloc(PWM_NAME_LEN + 1); - if (name == NULL) { - return NULL; - } - ret = snprintf_s(name, PWM_NAME_LEN + 1, PWM_NAME_LEN, "HDF_PLATFORM_PWM_%u", num); - if (ret < 0) { - HDF_LOGE("%s: snprintf_s failed", __func__); - OsalMemFree(name); - return NULL; - } - pwm = (struct PwmDev *)DevSvcManagerClntGetService(name); - OsalMemFree(name); - return pwm; -} - -DevHandle PwmOpen(uint32_t num) +int32_t PwmDeviceGet(struct PwmDev *pwm) { int32_t ret; - struct PwmDev *pwm = PwmGetDevByNum(num); if (pwm == NULL) { - HDF_LOGE("%s: dev is null", __func__); - return NULL; + return HDF_ERR_INVALID_PARAM; } + (void)OsalSpinLock(&(pwm->lock)); if (pwm->busy) { (void)OsalSpinUnlock(&(pwm->lock)); - HDF_LOGE("%s: pwm%u is busy", __func__, num); - return NULL; + HDF_LOGE("%s: pwm%u is busy", __func__, pwm->num); + return HDF_ERR_DEVICE_BUSY; } if (pwm->method != NULL && pwm->method->open != NULL) { ret = pwm->method->open(pwm); if (ret != HDF_SUCCESS) { (void)OsalSpinUnlock(&(pwm->lock)); HDF_LOGE("%s: open failed, ret %d", __func__, ret); - return NULL; + return HDF_FAILURE; } } + pwm->busy = true; (void)OsalSpinUnlock(&(pwm->lock)); - return (DevHandle)pwm; + return HDF_SUCCESS; } -void PwmClose(DevHandle handle) +void PwmDevicePut(struct PwmDev *pwm) { int32_t ret; - struct PwmDev *pwm = (struct PwmDev *)handle; - + if (pwm == NULL) { - HDF_LOGE("%s: dev is null", __func__); return; } @@ -86,20 +59,14 @@ void PwmClose(DevHandle handle) (void)OsalSpinUnlock(&(pwm->lock)); } -int32_t PwmSetConfig(DevHandle handle, struct PwmConfig *config) +int32_t PwmDeviceSetConfig(struct PwmDev *pwm, struct PwmConfig *config) { int32_t ret; - struct PwmDev *pwm = NULL; - - if (handle == NULL) { - HDF_LOGE("%s: handle is NULL", __func__); - return HDF_ERR_INVALID_OBJECT; - } - if (config == NULL) { - HDF_LOGE("%s: config is NULL", __func__); + + if (pwm == NULL || config == NULL) { return HDF_ERR_INVALID_PARAM; } - pwm = (struct PwmDev *)handle; + if (memcmp(config, &(pwm->cfg), sizeof(*config)) == 0) { HDF_LOGE("%s: do not need to set config", __func__); return HDF_SUCCESS; @@ -108,89 +75,18 @@ int32_t PwmSetConfig(DevHandle handle, struct PwmConfig *config) HDF_LOGE("%s: setConfig is not support", __func__); return HDF_ERR_NOT_SUPPORT; } + HDF_LOGI("%s: set PwmConfig: number %u, period %u, duty %u, polarity %u, enable %u.", __func__, + config->number, config->period, config->duty, config->polarity, config->status); ret = pwm->method->setConfig(pwm, config); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: failed, ret %d", __func__, ret); return ret; } pwm->cfg = *config; - return HDF_SUCCESS; -} - -int32_t PwmGetConfig(DevHandle handle, struct PwmConfig *config) -{ - struct PwmDev *pwm = NULL; - - if (handle == NULL) { - HDF_LOGE("%s: handle is NULL", __func__); - return HDF_ERR_INVALID_OBJECT; - } - if (config == NULL) { - HDF_LOGE("%s: config is NULL", __func__); - return HDF_ERR_INVALID_PARAM; - } - pwm = (struct PwmDev *)handle; - *config = pwm->cfg; return HDF_SUCCESS; } -int32_t PwmEnable(DevHandle handle) -{ - struct PwmConfig config; - - if (PwmGetConfig(handle, &config) != HDF_SUCCESS) { - return HDF_FAILURE; - } - config.status = PWM_ENABLE_STATUS; - return PwmSetConfig(handle, &config); -} - -int32_t PwmDisable(DevHandle handle) -{ - struct PwmConfig config; - - if (PwmGetConfig(handle, &config) != HDF_SUCCESS) { - return HDF_FAILURE; - } - config.status = PWM_DISABLE_STATUS; - return PwmSetConfig(handle, &config); -} - -int32_t PwmSetPeriod(DevHandle handle, uint32_t period) -{ - struct PwmConfig config; - - if (PwmGetConfig(handle, &config) != HDF_SUCCESS) { - return HDF_FAILURE; - } - config.period = period; - return PwmSetConfig(handle, &config); -} - -int32_t PwmSetDuty(DevHandle handle, uint32_t duty) -{ - struct PwmConfig config; - - if (PwmGetConfig(handle, &config) != HDF_SUCCESS) { - return HDF_FAILURE; - } - config.duty = duty; - return PwmSetConfig(handle, &config); -} - -int32_t PwmSetPolarity(DevHandle handle, uint8_t polarity) -{ - struct PwmConfig config; - - if (PwmGetConfig(handle, &config) != HDF_SUCCESS) { - return HDF_FAILURE; - } - config.polarity = polarity; - config.duty = config.period - config.duty; - return PwmSetConfig(handle, &config); -} - int32_t PwmSetPriv(struct PwmDev *pwm, void *priv) { if (pwm == NULL) { diff --git a/support/platform/src/pwm/pwm_if.c b/support/platform/src/pwm/pwm_if.c new file mode 100755 index 0000000000000000000000000000000000000000..1a3c9c3cf64c7e2ae90002027aa7c09c49a48a38 --- /dev/null +++ b/support/platform/src/pwm/pwm_if.c @@ -0,0 +1,202 @@ +/* + * Copyright (c) 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_log.h" +#include "osal_mem.h" +#include "pwm_core.h" +#include "securec.h" + +#define HDF_LOG_TAG pwm_if +#define PWM_NAME_LEN 32 + +static void *PwmGetDevByNum(uint32_t num) +{ + int32_t ret; + char *name = NULL; + void *pwm = NULL; + + name = (char *)OsalMemCalloc(PWM_NAME_LEN + 1); + if (name == NULL) { + return NULL; + } + ret = snprintf_s(name, PWM_NAME_LEN + 1, PWM_NAME_LEN, "HDF_PLATFORM_PWM_%u", num); + if (ret < 0) { + HDF_LOGE("%s: snprintf_s failed", __func__); + OsalMemFree(name); + return NULL; + } + pwm = (void *)DevSvcManagerClntGetService(name); + OsalMemFree(name); + return pwm; +} + +DevHandle PwmOpen(uint32_t num) +{ + int32_t ret; + void *pwm = PwmGetDevByNum(num); + + if (pwm == NULL) { + HDF_LOGE("%s: dev is null", __func__); + return NULL; + } + + ret = PwmDeviceGet((struct PwmDev *)pwm); + if(ret != HDF_SUCCESS) { + HDF_LOGE("%s: PwmDeviceGet failed, ret: %d", __func__, ret); + return NULL; + } + return (DevHandle)pwm; +} + +void PwmClose(DevHandle handle) +{ + if (handle == NULL) { + HDF_LOGE("%s: dev is null", __func__); + return; + } + + PwmDevicePut((struct PwmDev *)handle); +} + +int32_t PwmSetPeriod(DevHandle handle, uint32_t period) +{ + struct PwmConfig config; + uint32_t curValue; + int32_t ret; + + HDF_LOGI("%s: enter.", __func__); + if (PwmGetConfig(handle, &config) != HDF_SUCCESS) { + return HDF_FAILURE; + } + curValue = config.period; + config.period = period; + ret = PwmSetConfig(handle, &config); + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success. period: %d -> %d.", __func__, curValue, config.period); + } + return ret; +} + +int32_t PwmSetDuty(DevHandle handle, uint32_t duty) +{ + struct PwmConfig config; + uint32_t curValue; + int32_t ret; + + HDF_LOGI("%s: enter.", __func__); + if (PwmGetConfig(handle, &config) != HDF_SUCCESS) { + return HDF_FAILURE; + } + curValue = config.duty; + config.duty = duty; + ret = PwmSetConfig(handle, &config); + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success. duty: %d -> %d.", __func__, curValue, config.duty); + } + return ret; +} + +int32_t PwmSetPolarity(DevHandle handle, uint8_t polarity) +{ + struct PwmConfig config; + uint32_t curValue; + int32_t ret; + + HDF_LOGI("%s: enter.", __func__); + if (PwmGetConfig(handle, &config) != HDF_SUCCESS) { + return HDF_FAILURE; + } + curValue = config.polarity; + config.polarity = polarity; + ret = PwmSetConfig(handle, &config); + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success. polarity: %d -> %d.", __func__, curValue, config.polarity); + } + return ret; +} + +int32_t PwmEnable(DevHandle handle) +{ + struct PwmConfig config; + uint32_t curValue; + int32_t ret; + + HDF_LOGI("%s: enter.", __func__); + if (PwmGetConfig(handle, &config) != HDF_SUCCESS) { + return HDF_FAILURE; + } + curValue = config.status; + config.status = PWM_ENABLE_STATUS; + ret = PwmSetConfig(handle, &config); + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success. enable: %d -> %d.", __func__, curValue, config.status); + } + return ret; +} + +int32_t PwmDisable(DevHandle handle) +{ + struct PwmConfig config; + uint32_t curValue; + int32_t ret; + + HDF_LOGI("%s: enter.", __func__); + if (PwmGetConfig(handle, &config) != HDF_SUCCESS) { + return HDF_FAILURE; + } + curValue = config.status; + config.status = PWM_DISABLE_STATUS; + ret = PwmSetConfig(handle, &config); + if (ret == HDF_SUCCESS) { + HDF_LOGI("%s: success. enable: %d -> %d.", __func__, curValue, config.status); + } + return ret; +} + +int32_t PwmSetConfig(DevHandle handle, struct PwmConfig *config) +{ + int32_t ret; + + HDF_LOGI("%s: enter.", __func__); + if (handle == NULL) { + HDF_LOGE("%s: handle is NULL", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (config == NULL) { + HDF_LOGE("%s: config is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + + ret = PwmDeviceSetConfig(handle, config); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: PwmSetConfig failed, ret: %d", __func__, ret); + } + + HDF_LOGI("%s: success.", __func__); + return HDF_SUCCESS; +} + +int32_t PwmGetConfig(DevHandle handle, struct PwmConfig *config) +{ + struct PwmDev *pwm = NULL; + + HDF_LOGI("%s: enter.", __func__); + if (handle == NULL) { + HDF_LOGE("%s: handle is NULL", __func__); + return HDF_ERR_INVALID_OBJECT; + } + if (config == NULL) { + HDF_LOGE("%s: config is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + pwm = (struct PwmDev *)handle; + *config = pwm->cfg; + HDF_LOGI("%s: success.", __func__); + + return HDF_SUCCESS; +} \ No newline at end of file diff --git a/support/platform/src/regulator/regulator_core.c b/support/platform/src/regulator/regulator_core.c new file mode 100755 index 0000000000000000000000000000000000000000..fcfcadd6896b05e1311b656e68a438753d7d1747 --- /dev/null +++ b/support/platform/src/regulator/regulator_core.c @@ -0,0 +1,739 @@ +/* + * Copyright (c) 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 "regulator_core.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "osal_time.h" +#include "securec.h" +#include "regulator_tree_mgr.h" + +#define HDF_LOG_TAG regulator_core +struct RegulatorManager { + struct IDeviceIoService service; + struct HdfDeviceObject *device; + struct DListHead regulatorHead; + struct OsalMutex lock; +}; + +static struct RegulatorManager *g_regulatorManager = NULL; + +struct RegulatorNode *RegulatorNodeOpen(const char *name) +{ + CHECK_NULL_PTR_RETURN_VALUE(name, NULL); + struct RegulatorNode *pos = NULL; + struct RegulatorNode *tmp = NULL; + + struct RegulatorManager *manager = g_regulatorManager; + CHECK_NULL_PTR_RETURN_VALUE(manager, NULL); + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeOpen: lock regulator manager fail!"); + return NULL; + } + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->regulatorHead, struct RegulatorNode, node) { + if (strcmp(name, pos->regulatorInfo.name) == 0) { + if ((pos->ops->open != NULL) && pos->ops->open(pos) != HDF_SUCCESS) { + (void)OsalMutexUnlock(&manager->lock); + HDF_LOGE("RegulatorNodeOpen: open regulator[%s] fail!", name); + return NULL; + } + (void)OsalMutexUnlock(&manager->lock); + return pos; + } + } + + (void)OsalMutexUnlock(&manager->lock); + HDF_LOGE("RegulatorNodeOpen: No %s regulator exist", name); + return NULL; +} + +int32_t RegulatorNodeClose(struct RegulatorNode *node) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_OBJECT); + return HDF_SUCCESS; +} + +void RegulatorNodeListPrint(void) +{ + struct RegulatorNode *pos = NULL; + struct RegulatorNode *tmp = NULL; + + struct RegulatorManager *manager = g_regulatorManager; + CHECK_NULL_PTR_RETURN(manager); + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeListPrint: lock regulator manager fail!"); + return; + } + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->regulatorHead, struct RegulatorNode, node) { + HDF_LOGI("RegulatorNodeListPrint: name[%s], [%d][%d][%d], [%d][%d]--[%d][%d]", + pos->regulatorInfo.name, pos->regulatorInfo.status, + pos->regulatorInfo.constraints.alwaysOn, pos->regulatorInfo.constraints.mode, + pos->regulatorInfo.constraints.minUv, pos->regulatorInfo.constraints.maxUv, + pos->regulatorInfo.constraints.minUa, pos->regulatorInfo.constraints.maxUa); + if ((pos->regulatorInfo.parentName != NULL) && (strlen(pos->regulatorInfo.parentName) > 0)) { + HDF_LOGI("RegulatorNodeListPrint:parentName[%s]", pos->regulatorInfo.parentName); + } + } + + (void)OsalMutexUnlock(&manager->lock); + RegulatorTreePrint(); +} + +int32_t RegulatorNodeSetParent(struct RegulatorNode *node) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); + struct RegulatorNode *pos = NULL; + struct RegulatorNode *tmp = NULL; + struct RegulatorManager *manager = g_regulatorManager; + CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_FAILURE); + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeSetParent: lock regulator manager fail!"); + return HDF_ERR_DEVICE_BUSY; + } + // parent set + if ((node->regulatorInfo.parentName != NULL) + && (strlen(node->regulatorInfo.parentName) > 0)) { + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->regulatorHead, struct RegulatorNode, node) { + if (strcmp(node->regulatorInfo.parentName, pos->regulatorInfo.name) == 0) { + if (RegulatorTreeSet(node->regulatorInfo.name, node, pos) != HDF_SUCCESS) { + HDF_LOGE("%s: RegulatorTreeSet failed", __func__); + (void)OsalMutexUnlock(&manager->lock); + return HDF_FAILURE; + } else { + HDF_LOGI("%s:regulator [%s] RegulatorTreeSet success", __func__, node->regulatorInfo.name); + (void)OsalMutexUnlock(&manager->lock); + return HDF_SUCCESS; + } + } + } + + HDF_LOGE("%s: RegulatorTreeSet find %s parent %s error", + __func__, node->regulatorInfo.name, node->regulatorInfo.parentName); + (void)OsalMutexUnlock(&manager->lock); + return HDF_FAILURE; + } + + (void)OsalMutexUnlock(&manager->lock); + HDF_LOGD("%s: the node %s no need to set parent", __func__, node->regulatorInfo.name); + return HDF_SUCCESS; +} + +int32_t RegulatorNodeSetChild(struct RegulatorNode *parent) +{ + CHECK_NULL_PTR_RETURN_VALUE(parent, HDF_ERR_INVALID_PARAM); + struct RegulatorNode *pos = NULL; + struct RegulatorNode *tmp = NULL; + struct RegulatorManager *manager = g_regulatorManager; + CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_FAILURE); + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeSetChild: lock regulator manager fail!"); + return HDF_ERR_DEVICE_BUSY; + } + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->regulatorHead, struct RegulatorNode, node) { + if ((pos->regulatorInfo.parentName != NULL) && + (strcmp(parent->regulatorInfo.name, pos->regulatorInfo.parentName) == 0)) { + HDF_LOGD("%s: node[%s] parent is %s, tree info process", __func__, + pos->regulatorInfo.parentName, parent->regulatorInfo.name); + if (RegulatorTreeSet(pos->regulatorInfo.name, pos, parent) != HDF_SUCCESS) { + HDF_LOGE("%s: RegulatorTreeSet failed", __func__); + (void)OsalMutexUnlock(&manager->lock); + return HDF_FAILURE; + } + } + } + + HDF_LOGD("%s: the node %s child info process suceess", __func__, parent->regulatorInfo.name); + (void)OsalMutexUnlock(&manager->lock); + return HDF_SUCCESS; +} + +void RegulatorNodeInitEnable(struct RegulatorNode *node) +{ + CHECK_NULL_PTR_RETURN(node); + if (node->regulatorInfo.status == REGULATOR_STATUS_ON) { + HDF_LOGD("RegulatorNodeInitEnable: %s status on", node->regulatorInfo.name); + return; + } + + bool isChildAlwayson = RegulatorTreeIsChildAlwayson(node->regulatorInfo.name); + bool isChildOn = RegulatorTreeIsChildStatusOn(node->regulatorInfo.name); + // if regulator alwaysOn is true or there is child's alwaysOn is true or there is child's status on, then process + if ((node->regulatorInfo.constraints.alwaysOn) || (isChildAlwayson) || (isChildOn)) { + // RegulatorTreeIsUpNodeComplete is false, call RegulatorNodeEnable will fail. + if (RegulatorTreeIsUpNodeComplete(node->regulatorInfo.name)) { + HDF_LOGD("RegulatorNodeInitEnable: %s UpNodeComplete", node->regulatorInfo.name); + RegulatorNodeEnable(node); + return; + } + if (OsalMutexLock(&node->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeInitEnable: lock regulator %s fail!", node->regulatorInfo.name); + return; + } + // first enable + if (node->ops->enable(node) != HDF_SUCCESS) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGE("RegulatorNodeInitEnable: %s failed", node->regulatorInfo.name); + return; + } + node->regulatorInfo.status = REGULATOR_STATUS_ON; + RegulatorNodeStatusCb(node); + + (void)OsalMutexUnlock(&node->lock); + HDF_LOGD("RegulatorNodeInitEnable: %s success", node->regulatorInfo.name); + return; + } +} + +/* +* complete up and down management topology +* process alwayson +*/ +int32_t RegulatorNodeInitProcess(struct RegulatorNode *node) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); + + // parent or child set + if (RegulatorNodeSetParent(node) != HDF_SUCCESS) { + HDF_LOGD("%s: node %s RegulatorNodeSetParent fail, parent not add", __func__, node->regulatorInfo.name); + } + + if (RegulatorNodeSetChild(node) != HDF_SUCCESS) { + HDF_LOGE("%s: node %s RegulatorNodeSetChild fail", __func__, node->regulatorInfo.name); + return HDF_FAILURE; + } + + if (node->regulatorInfo.constraints.mode == REGULATOR_CHANGE_CURRENT) { + RegulatorNodeSetCurrent(node, node->regulatorInfo.constraints.minUa, node->regulatorInfo.constraints.maxUa); + } else if(node->regulatorInfo.constraints.mode == REGULATOR_CHANGE_VOLTAGE) { + RegulatorNodeSetVoltage(node, node->regulatorInfo.constraints.minUv, node->regulatorInfo.constraints.maxUv); + } + + RegulatorNodeInitEnable(node); + + HDF_LOGD("%s: the node %s init success", __func__, node->regulatorInfo.name); + return HDF_SUCCESS; +} + +int32_t RegulatorNodeAdd(struct RegulatorNode *node) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(node->ops, HDF_ERR_INVALID_PARAM); + struct RegulatorNode *pos = NULL; + struct RegulatorNode *tmp = NULL; + struct RegulatorManager *manager = g_regulatorManager; + CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_FAILURE); + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->regulatorHead, struct RegulatorNode, node) { + if (strcmp(node->regulatorInfo.name, pos->regulatorInfo.name) == 0) { + HDF_LOGE("%s: regulatorInfo[%s] existed", __func__, node->regulatorInfo.name); + return HDF_FAILURE; + } + } + + // init node info + node->regulatorInfo.cb = NULL; + node->regulatorInfo.useCount = 0; + node->regulatorInfo.status = REGULATOR_STATUS_OFF; + node->regulatorInfo.useCount = 0; + if (OsalMutexInit(&node->lock) != HDF_SUCCESS) { + HDF_LOGE("%s: OsalMutexInit %s failed", __func__, node->regulatorInfo.name); + return HDF_FAILURE; + } + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorManagerAddNode: lock regulator manager fail!"); + return HDF_ERR_DEVICE_BUSY; + } + DListInsertTail(&node->node, &manager->regulatorHead); + (void)OsalMutexUnlock(&manager->lock); + + if (RegulatorNodeInitProcess(node) != HDF_SUCCESS) { + HDF_LOGE("%s: node %s RegulatorNodeInitProcess fail", __func__, node->regulatorInfo.name); + return HDF_FAILURE; + } + + HDF_LOGI("%s: add regulator name[%s] success", __func__, node->regulatorInfo.name); + + return HDF_SUCCESS; +} + +int32_t RegulatorNodeRemove(const char *name) +{ + CHECK_NULL_PTR_RETURN_VALUE(name, HDF_ERR_INVALID_PARAM); + + struct RegulatorNode *pos = NULL; + struct RegulatorNode *tmp = NULL; + struct RegulatorManager *manager = g_regulatorManager; + if (manager == NULL) { + HDF_LOGE("RegulatorNodeRemoveAll: regulator manager null!"); + return HDF_ERR_NOT_SUPPORT; + } + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeRemoveAll: lock regulator manager fail!"); + return HDF_ERR_DEVICE_BUSY; + } + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->regulatorHead, struct RegulatorNode, node) { + if (strcmp(pos->regulatorInfo.name, name) == 0) { + if ((pos->ops->release != NULL) && pos->ops->release(pos) != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeRemoveAll: release regulator[%s] fail!", pos->regulatorInfo.name); + } + DListRemove(&pos->node); + (void)OsalMutexDestroy(&pos->lock); + OsalMemFree(pos); + break; + } + } + + (void)OsalMutexUnlock(&manager->lock); + HDF_LOGI("%s: remove regulator %s success", __func__, name); + return HDF_SUCCESS; +} + +int32_t RegulatorNodeRemoveAll(void) +{ + if (RegulatorTreeNodeRemoveAll() != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeRemoveAll: RegulatorTreeNodeRemoveAll failed"); + return HDF_FAILURE; + } + + struct RegulatorNode *pos = NULL; + struct RegulatorNode *tmp = NULL; + struct RegulatorManager *manager = g_regulatorManager; + if (manager == NULL) { + HDF_LOGE("RegulatorNodeRemoveAll: regulator manager null!"); + return HDF_ERR_NOT_SUPPORT; + } + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeRemoveAll: lock regulator manager fail!"); + return HDF_ERR_DEVICE_BUSY; + } + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->regulatorHead, struct RegulatorNode, node) { + if ((pos->ops->release != NULL) && pos->ops->release(pos) != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeRemoveAll: release regulator[%s] fail!", pos->regulatorInfo.name); + } + DListRemove(&pos->node); + (void)OsalMutexDestroy(&pos->lock); + OsalMemFree(pos); + } + + (void)OsalMutexUnlock(&manager->lock); + HDF_LOGI("%s: remove all regulator success", __func__); + return HDF_SUCCESS; +} + +int32_t RegulatorNodeStatusCb(struct RegulatorNode *node) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(node->regulatorInfo.cb, HDF_SUCCESS); + struct RegulatorStatusChangeInfo info; + memset_s(&info, sizeof(struct RegulatorStatusChangeInfo), 0, sizeof(struct RegulatorStatusChangeInfo)); + + info.status = node->regulatorInfo.status; + info.name = node->regulatorInfo.name; + HDF_LOGI("%s: Cb %s %d", __func__, info.name, info.status); + + return node->regulatorInfo.cb(&info); +} + +int32_t RegulatorNodeEnable(struct RegulatorNode *node) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); + if (node->regulatorInfo.status == REGULATOR_STATUS_ON) { + HDF_LOGD("RegulatorNodeEnable: %s status on", node->regulatorInfo.name); + return HDF_SUCCESS; + } + + if (OsalMutexLock(&node->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeEnable: lock regulator %s fail!", node->regulatorInfo.name); + return HDF_ERR_DEVICE_BUSY; + } + + if ((node->regulatorInfo.parentName != NULL) && (strlen(node->regulatorInfo.parentName) > 0)) { + struct RegulatorNode *parent = RegulatorTreeGetParent(node->regulatorInfo.name); + if (parent == NULL) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGE("RegulatorNodeEnable: %s failed", node->regulatorInfo.name); + return HDF_FAILURE; + } + if (RegulatorNodeEnable(parent) != HDF_SUCCESS) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGE("RegulatorNodeEnable: %s failed", parent->regulatorInfo.name); + return HDF_FAILURE; + } + } + + // first enable + if (node->ops->enable(node) != HDF_SUCCESS) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGE("RegulatorNodeEnable:enable: %s failed", node->regulatorInfo.name); + return HDF_FAILURE; + } + RegulatorNodeStatusCb(node); + + (void)OsalMutexUnlock(&node->lock); + return HDF_SUCCESS; +} + +int32_t RegulatorNodeDisable(struct RegulatorNode *node) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); + if ((node->regulatorInfo.status == REGULATOR_STATUS_OFF) || (node->regulatorInfo.constraints.alwaysOn)) { + HDF_LOGI("RegulatorNodeDisable: %s [%d][%d], unsatisfied closing adjusment", + node->regulatorInfo.name, node->regulatorInfo.status, node->regulatorInfo.constraints.alwaysOn); + return HDF_SUCCESS; + } + + if (OsalMutexLock(&node->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeDisable: lock regulator %s fail!", node->regulatorInfo.name); + return HDF_ERR_DEVICE_BUSY; + } + + if (!RegulatorTreeIsAllChildDisable(node->regulatorInfo.name)) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGE("RegulatorNodeDisable:there is %s child not disable, so disable node failed", + node->regulatorInfo.name); + return HDF_FAILURE; + } + + // the regulator no user, can disable + + if (node->ops->disable(node) != HDF_SUCCESS) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGE("RegulatorNodeDisable:disable %s failed", node->regulatorInfo.name); + return HDF_FAILURE; + } + + RegulatorNodeStatusCb(node); + + // set parent + if ((node->regulatorInfo.parentName != NULL) && (strlen(node->regulatorInfo.parentName) > 0)) { + struct RegulatorNode *parent = RegulatorTreeGetParent(node->regulatorInfo.name); + if (parent == NULL) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGE("RegulatorNodeDisable: %s failed", node->regulatorInfo.name); + return HDF_FAILURE; + } + if (RegulatorNodeDisable(parent) != HDF_SUCCESS) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGD("RegulatorNodeDisable: disable %s's parent %s failed", + node->regulatorInfo.name, parent->regulatorInfo.name); + return HDF_SUCCESS; + } + } + + (void)OsalMutexUnlock(&node->lock); + return HDF_SUCCESS; +} + +int32_t RegulatorNodeForceDisable(struct RegulatorNode *node) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); + if (OsalMutexLock(&node->lock) != HDF_SUCCESS) { + HDF_LOGE(": lock regulator %s fail!", node->regulatorInfo.name); + return HDF_ERR_DEVICE_BUSY; + } + + if (node->regulatorInfo.status == REGULATOR_STATUS_OFF) { + (void)OsalMutexUnlock(&node->lock); + return HDF_SUCCESS; + } + + // if the regulator force disable ,set all child node disable + if (RegulatorTreeChildForceDisable(node)) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGE("RegulatorNodeForceDisable--RegulatorTreeConsumerForceDisable: %s failed", node->regulatorInfo.name); + return HDF_FAILURE; + } + + if (node->ops->forceDisable != NULL) { + if (node->ops->forceDisable(node) != HDF_SUCCESS) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGE("RegulatorNodeForceDisable:forceDisable %s failed", node->regulatorInfo.name); + return HDF_FAILURE; + } + } else if (node->ops->disable(node) != HDF_SUCCESS) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGE("RegulatorNodeForceDisable:disable %s failed", node->regulatorInfo.name); + return HDF_FAILURE; + } + node->regulatorInfo.status = REGULATOR_STATUS_OFF; + RegulatorNodeStatusCb(node); + HDF_LOGI("RegulatorNodeForceDisable:regulator %s force disable success", node->regulatorInfo.name); + + // set parent + if ((node->regulatorInfo.parentName != NULL) && (strlen(node->regulatorInfo.parentName) > 0)) { + struct RegulatorNode *parent = RegulatorTreeGetParent(node->regulatorInfo.name); + if (parent == NULL) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGE(": %s failed", node->regulatorInfo.name); + return HDF_FAILURE; + } + if (RegulatorNodeDisable(parent) != HDF_SUCCESS) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGD("RegulatorNodeDisable: disable %s's parent %s failed", + node->regulatorInfo.name, parent->regulatorInfo.name); + return HDF_SUCCESS; + } + } + + (void)OsalMutexUnlock(&node->lock); + return HDF_SUCCESS; +} + +int32_t RegulatorNodeSetVoltage(struct RegulatorNode *node, uint32_t minUv, uint32_t maxUv) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); + if (node->regulatorInfo.constraints.mode != REGULATOR_CHANGE_VOLTAGE) { + HDF_LOGE("RegulatorNodeSetVoltage: %s mode %d invalid!", + node->regulatorInfo.name, node->regulatorInfo.constraints.mode); + return HDF_FAILURE; + } + + if (minUv == node->regulatorInfo.minUv && maxUv == node->regulatorInfo.maxUv) { + return HDF_SUCCESS; + } + + if ((minUv > maxUv) || + (minUv < node->regulatorInfo.constraints.minUv || + maxUv > node->regulatorInfo.constraints.maxUv)) { + HDF_LOGE("RegulatorNodeSetVoltage: %s Uv [%d, %d] invalid!", + node->regulatorInfo.name, minUv, maxUv); + return HDF_FAILURE; + } + + if (OsalMutexLock(&node->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeSetVoltage: lock regulator %s fail!", node->regulatorInfo.name); + return HDF_ERR_DEVICE_BUSY; + } + + int ret = node->ops->setVoltage(node, minUv, maxUv); + if (ret != HDF_SUCCESS) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGE("RegulatorNodeSetVoltage: setVoltage %s fail!", node->regulatorInfo.name); + return HDF_FAILURE; + } + + node->regulatorInfo.minUv = minUv; + node->regulatorInfo.maxUv = maxUv; + (void)OsalMutexUnlock(&node->lock); + + return HDF_SUCCESS; +} + +int32_t RegulatorNodeGetVoltage(struct RegulatorNode *node, uint32_t *voltage) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(voltage, HDF_ERR_INVALID_PARAM); + + if (node->regulatorInfo.constraints.mode != REGULATOR_CHANGE_VOLTAGE) { + HDF_LOGE("RegulatorNodeSetVoltage: %s mode %d invalid!", + node->regulatorInfo.name, node->regulatorInfo.constraints.mode); + return HDF_FAILURE; + } + + int ret = node->ops->getVoltage(node, voltage); + if (ret != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeGetVoltage: getVoltage %s fail!", node->regulatorInfo.name); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t RegulatorNodeSetCurrent(struct RegulatorNode *node, uint32_t minUA, uint32_t maxUA) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); + if (node->regulatorInfo.constraints.mode != REGULATOR_CHANGE_CURRENT) { + HDF_LOGE("RegulatorNodeSetVoltage: %s mode %d invalid!", + node->regulatorInfo.name, node->regulatorInfo.constraints.mode); + return HDF_FAILURE; + } + + if (minUA == node->regulatorInfo.minUa && maxUA == node->regulatorInfo.maxUa) { + return HDF_SUCCESS; + } + + if ((minUA > maxUA) || + (minUA < node->regulatorInfo.constraints.minUa || + maxUA > node->regulatorInfo.constraints.maxUa)) { + HDF_LOGE("RegulatorNodeSetCurrent: %s UA [%d, %d] invalid!", + node->regulatorInfo.name, minUA, maxUA); + return HDF_FAILURE; + } + + if (OsalMutexLock(&node->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeSetCurrent: lock regulator %s fail!", node->regulatorInfo.name); + return HDF_ERR_DEVICE_BUSY; + } + + int ret = node->ops->setCurrent(node, minUA, maxUA); + if (ret != HDF_SUCCESS) { + (void)OsalMutexUnlock(&node->lock); + HDF_LOGE("RegulatorNodeSetCurrent: setCurrent %s fail!", node->regulatorInfo.name); + return HDF_FAILURE; + } + + node->regulatorInfo.minUa = minUA; + node->regulatorInfo.maxUa = maxUA; + (void)OsalMutexUnlock(&node->lock); + return HDF_SUCCESS; +} + +int32_t RegulatorNodeGetCurrent(struct RegulatorNode *node, uint32_t *regCurrent) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_OBJECT); + CHECK_NULL_PTR_RETURN_VALUE(regCurrent, HDF_ERR_INVALID_OBJECT); + if (node->regulatorInfo.constraints.mode != REGULATOR_CHANGE_CURRENT) { + HDF_LOGE("RegulatorNodeGetCurrent: %s mode %d invalid!", + node->regulatorInfo.name, node->regulatorInfo.constraints.mode); + return HDF_FAILURE; + } + + int ret = node->ops->getCurrent(node, regCurrent); + if (ret != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeGetCurrent: getCurrent %s fail!", node->regulatorInfo.name); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t RegulatorNodeGetStatus(struct RegulatorNode *node, uint32_t *status) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_OBJECT); + CHECK_NULL_PTR_RETURN_VALUE(status, HDF_ERR_INVALID_OBJECT); + if (node->ops->getStatus(node, status) != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeGetStatus: getStatus %s fail!", node->regulatorInfo.name); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t RegulatorNodeRegisterStatusChangeCb(struct RegulatorNode *node, RegulatorStatusChangecb cb) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_OBJECT); + CHECK_NULL_PTR_RETURN_VALUE(cb, HDF_ERR_INVALID_OBJECT); + node->regulatorInfo.cb = cb; + return HDF_SUCCESS; +} + +int32_t RegulatorTreeInfoInit(struct RegulatorNode *node) +{ + struct RegulatorNode *pos = NULL; + struct RegulatorNode *tmp = NULL; + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_OBJECT); + struct RegulatorManager *manager = g_regulatorManager; + CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_ERR_INVALID_OBJECT); + + if ((node->regulatorInfo.parentName != NULL) + && (strlen(node->regulatorInfo.parentName) > 0)) { + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->regulatorHead, struct RegulatorNode, node) { + if (strcmp(node->regulatorInfo.parentName, pos->regulatorInfo.name) == 0) { + if (RegulatorTreeSet(node->regulatorInfo.name, node, pos) != HDF_SUCCESS) { + HDF_LOGE("%s: RegulatorTreeSet failed", __func__); + return HDF_FAILURE; + } else { + HDF_LOGI("%s:regulator [%s] RegulatorTreeSet success", __func__, node->regulatorInfo.name); + return HDF_SUCCESS; + } + } + } + + HDF_LOGE("%s: RegulatorTreeSet find %s parent %s error", + __func__, node->regulatorInfo.name, node->regulatorInfo.parentName); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +static int32_t RegulatorManagerBind(struct HdfDeviceObject *device) +{ + int32_t ret; + struct RegulatorManager *manager = NULL; + + HDF_LOGI("RegulatorManagerBind: Enter!"); + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_OBJECT); + + manager = (struct RegulatorManager *)OsalMemCalloc(sizeof(*manager)); + if (manager == NULL) { + HDF_LOGE("RegulatorManagerBind: malloc manager fail!"); + return HDF_ERR_MALLOC_FAIL; + } + + ret = OsalMutexInit(&manager->lock); + if (ret != HDF_SUCCESS) { + HDF_LOGE("RegulatorManagerBind: mutex init fail:%d", ret); + OsalMemFree(manager); + return HDF_FAILURE; + } + + manager->device = device; + device->service = &manager->service; + DListHeadInit(&manager->regulatorHead); + g_regulatorManager = manager; + + if (RegulatorTreeManagerInit() != HDF_SUCCESS) { + HDF_LOGE("RegulatorManagerBind: RegulatorTreeManagerInit init fail"); + OsalMemFree(manager); + return HDF_FAILURE; + } + HDF_LOGI("RegulatorManagerBind: success!"); + return HDF_SUCCESS; +} + +static int32_t RegulatorManagerInit(struct HdfDeviceObject *device) +{ + (void)device; + + HDF_LOGI("RegulatorManagerInit: success!"); + return HDF_SUCCESS; +} + +static void RegulatorManagerRelease(struct HdfDeviceObject *device) +{ + HDF_LOGI("RegulatorManagerRelease: enter"); + CHECK_NULL_PTR_RETURN(device); + + if (RegulatorNodeRemoveAll() != HDF_SUCCESS) { + HDF_LOGE("RegulatorNodeRemoveAll failed"); + return; + } + + struct RegulatorManager *manager = (struct RegulatorManager *)device->service; + CHECK_NULL_PTR_RETURN(manager); + OsalMutexDestroy(&manager->lock); + OsalMemFree(manager); + g_regulatorManager = NULL; + + if (RegulatorTreeManagerDestory() != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeManagerDestory failed"); + return; + } +} + +struct HdfDriverEntry g_regulatorManagerEntry = { + .moduleVersion = 1, + .Bind = RegulatorManagerBind, + .Init = RegulatorManagerInit, + .Release = RegulatorManagerRelease, + .moduleName = "HDF_PLATFORM_REGULATOR_MANAGER", +}; + +HDF_INIT(g_regulatorManagerEntry); diff --git a/support/platform/src/regulator/regulator_if.c b/support/platform/src/regulator/regulator_if.c new file mode 100755 index 0000000000000000000000000000000000000000..90165741546e2ebf5adfad20caba18cdb697b025 --- /dev/null +++ b/support/platform/src/regulator/regulator_if.c @@ -0,0 +1,182 @@ +/* + * Copyright (c) 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 "regulator_if.h" +#include "hdf_log.h" +#include "regulator_core.h" + +DevHandle RegulatorOpen(const char *name) +{ + if (name == NULL) { + HDF_LOGE("%s: name is null", __func__); + return NULL; + } + + return (DevHandle)RegulatorNodeOpen(name); +} + +void RegulatorClose(DevHandle handle) +{ + struct RegulatorNode *node = (struct RegulatorNode *)handle; + if (node == NULL) { + HDF_LOGE("%s: node is null", __func__); + return; + } + + if (RegulatorNodeClose(node) != HDF_SUCCESS) { + HDF_LOGE("%s: RegulatorNodeClose fail", __func__); + return; + } +} + +int32_t RegulatorEnable(DevHandle handle) +{ + struct RegulatorNode *node = (struct RegulatorNode *)handle; + if (node == NULL) { + HDF_LOGE("%s: node is null", __func__); + return HDF_FAILURE; + } + + int ret = RegulatorNodeEnable(node); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: RegulatorNodeEnable fail", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t RegulatorDisable(DevHandle handle) +{ + struct RegulatorNode *node = (struct RegulatorNode *)handle; + if (node == NULL) { + HDF_LOGE("%s: node is null", __func__); + return HDF_FAILURE; + } + + int ret = RegulatorNodeDisable(node); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: RegulatorNodeDisable fail", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t RegulatorForceDisable(DevHandle handle) +{ + struct RegulatorNode *node = (struct RegulatorNode *)handle; + if (node == NULL) { + HDF_LOGE("%s: node is null", __func__); + return HDF_FAILURE; + } + + int ret = RegulatorNodeForceDisable(node); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: RegulatorNodeForceDisable fail", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t RegulatorSetVoltage(DevHandle handle, uint32_t minUv, uint32_t maxUv) +{ + struct RegulatorNode *node = (struct RegulatorNode *)handle; + if (node == NULL) { + HDF_LOGE("%s: node is null", __func__); + return HDF_FAILURE; + } + + if (minUv > maxUv) { + HDF_LOGE("RegulatorSetVoltage: %s Uv [%d, %d] invalid!", + node->regulatorInfo.name, minUv, maxUv); + return HDF_FAILURE; + } + + int ret = RegulatorNodeSetVoltage(node, minUv, maxUv); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: RegulatorSetVoltage fail", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t RegulatorGetVoltage(DevHandle handle, uint32_t *voltage) +{ + struct RegulatorNode *node = (struct RegulatorNode *)handle; + if (node == NULL || voltage == NULL) { + HDF_LOGE("%s: param is null", __func__); + return HDF_FAILURE; + } + + int ret = RegulatorNodeGetVoltage(node, voltage); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: RegulatorNodeGetVoltage fail", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t RegulatorSetCurrent(DevHandle handle, uint32_t minUa, uint32_t maxUa) +{ + struct RegulatorNode *node = (struct RegulatorNode *)handle; + if (node == NULL) { + HDF_LOGE("%s: node is null", __func__); + return HDF_FAILURE; + } + + if (minUa > maxUa) { + HDF_LOGE("RegulatorSetCurrent: %s Ua [%d, %d] invalid!", + node->regulatorInfo.name, minUa, maxUa); + return HDF_FAILURE; + } + + int ret = RegulatorNodeSetCurrent(node, minUa, maxUa); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: RegulatorNodeSetCurrent fail", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t RegulatorGetCurrent(DevHandle handle, uint32_t *regCurrent) +{ + struct RegulatorNode *node = (struct RegulatorNode *)handle; + if (node == NULL || regCurrent == NULL) { + HDF_LOGE("%s: param is null", __func__); + return HDF_FAILURE; + } + + int ret = RegulatorNodeGetCurrent(node, regCurrent); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: RegulatorNodeGetCurrent fail", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t RegulatorGetStatus(DevHandle handle, uint32_t *status) +{ + struct RegulatorNode *node = (struct RegulatorNode *)handle; + if (node == NULL || status == NULL) { + HDF_LOGE("%s: param is null", __func__); + return HDF_FAILURE; + } + + int ret = RegulatorNodeGetStatus(node, status); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: RegulatorNodeGetStatus fail", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} diff --git a/support/platform/src/regulator/regulator_tree_mgr.c b/support/platform/src/regulator/regulator_tree_mgr.c new file mode 100755 index 0000000000000000000000000000000000000000..c49b0a5d57ae83db650c5253418bc8e38dcc1421 --- /dev/null +++ b/support/platform/src/regulator/regulator_tree_mgr.c @@ -0,0 +1,436 @@ +/* + * Copyright (c) 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 "regulator_tree_mgr.h" +#include "osal_mem.h" +#include "securec.h" + +static struct RegulatorTreeManager *g_regulatorTreeManager = NULL; +static int RegulatorChildNodeAdd(struct RegulatorTreeInfo *pRegulator, struct RegulatorNode *child) +{ + CHECK_NULL_PTR_RETURN_VALUE(pRegulator, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(child, HDF_ERR_INVALID_PARAM); + + struct RegulatorChildNode *nodeInfo = NULL; + + nodeInfo = (struct RegulatorChildNode *)OsalMemCalloc(sizeof(*nodeInfo)); + if (nodeInfo == NULL) { + HDF_LOGE("%s: OsalMemCalloc failed", __func__); + return HDF_FAILURE; + } + nodeInfo->child = child; + + DListInsertTail(&nodeInfo->node, &pRegulator->childHead); + HDF_LOGI("RegulatorChildNodeAdd: add %s child node success!", pRegulator->name); + return HDF_SUCCESS; +} + +void RegulatorChildListDestroy(struct RegulatorTreeInfo *pRegulator) +{ + CHECK_NULL_PTR_RETURN(pRegulator); + struct RegulatorChildNode *nodeInfo = NULL; + struct RegulatorChildNode *tmp = NULL; + + DLIST_FOR_EACH_ENTRY_SAFE(nodeInfo, tmp, &pRegulator->childHead, struct RegulatorChildNode, node) { + DListRemove(&nodeInfo->node); + OsalMemFree(nodeInfo); + } +} + +// name:the regulator node name; fun :get the node parent struct RegulatorNode +struct RegulatorNode * RegulatorTreeGetParent(const char *name) +{ + CHECK_NULL_PTR_RETURN_VALUE(name, NULL); + + struct RegulatorTreeInfo *pos = NULL; + struct RegulatorTreeInfo *tmp = NULL; + struct RegulatorTreeManager *manager = g_regulatorTreeManager; + CHECK_NULL_PTR_RETURN_VALUE(manager, NULL); + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeGetParent: lock regulator manager fail!"); + return NULL; + } + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->treeMgrHead, struct RegulatorTreeInfo, node) { + if (strcmp(pos->name, name) == 0) { + if (pos->parent == NULL) { + (void)OsalMutexUnlock(&manager->lock); + HDF_LOGI("RegulatorTreeGetParent: %s no parent", name); + return NULL; + } + (void)OsalMutexUnlock(&manager->lock); + HDF_LOGI("RegulatorTreeGetParent: get %s parent %s success!", + name, pos->parent->regulatorInfo.name); + return pos->parent; + } + } + + (void)OsalMutexUnlock(&manager->lock); + HDF_LOGI("RegulatorTreeGetParent: no %s Tree node", name); + return NULL; +} + +// next level child +static struct DListHead *RegulatorTreeGetChild(const char *name) +{ + CHECK_NULL_PTR_RETURN_VALUE(name, NULL); + + struct RegulatorTreeInfo *pos = NULL; + struct RegulatorTreeInfo *tmp = NULL; + struct RegulatorTreeManager *manager = g_regulatorTreeManager; + CHECK_NULL_PTR_RETURN_VALUE(manager, NULL); + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeGetChild: lock regulator manager fail!"); + return NULL; + } + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->treeMgrHead, struct RegulatorTreeInfo, node) { + if (strcmp(pos->name, name) == 0) { + (void)OsalMutexUnlock(&manager->lock); + HDF_LOGI("RegulatorTreeGetChild: get %s child success!", name); + return (&pos->childHead); + } + } + + (void)OsalMutexUnlock(&manager->lock); + HDF_LOGE("RegulatorTreeGetChild: get %s child failed!", name); + return NULL; +} + +// name:the regulator node name +bool RegulatorTreeIsUpNodeComplete(const char *name) +{ + CHECK_NULL_PTR_RETURN_VALUE(name, false); + + struct RegulatorNode *node = RegulatorTreeGetParent(name); + CHECK_NULL_PTR_RETURN_VALUE(node, false); + + if ((node->regulatorInfo.parentName == NULL) || (strlen(node->regulatorInfo.parentName) == 0)) { + return true; + } else { + return RegulatorTreeIsUpNodeComplete(node->regulatorInfo.name); + } +} + +bool RegulatorTreeIsChildAlwayson(const char *name) +{ + CHECK_NULL_PTR_RETURN_VALUE(name, false); + struct DListHead *pList = RegulatorTreeGetChild(name); + CHECK_NULL_PTR_RETURN_VALUE(pList, false); + + struct RegulatorChildNode *nodeInfo = NULL; + struct RegulatorChildNode *tmp = NULL; + DLIST_FOR_EACH_ENTRY_SAFE(nodeInfo, tmp, pList, struct RegulatorChildNode, node) { + if (nodeInfo->child->regulatorInfo.constraints.alwaysOn) { + HDF_LOGD("RegulatorTreeIsChildAlwayson:%s's child %s alwaysOn true!", + name, nodeInfo->child->regulatorInfo.name); + return true; + } + } + + HDF_LOGD("RegulatorTreeIsChildAlwayson:%s's all child alwaysOn false!", name); + return false; +} + +bool RegulatorTreeIsChildStatusOn(const char *name) +{ + CHECK_NULL_PTR_RETURN_VALUE(name, false); + struct DListHead *pList = RegulatorTreeGetChild(name); + CHECK_NULL_PTR_RETURN_VALUE(pList, false); + + struct RegulatorChildNode *nodeInfo = NULL; + struct RegulatorChildNode *tmp = NULL; + DLIST_FOR_EACH_ENTRY_SAFE(nodeInfo, tmp, pList, struct RegulatorChildNode, node) { + if (nodeInfo->child->regulatorInfo.status == REGULATOR_STATUS_ON) { + HDF_LOGD("RegulatorTreeIsChildAlwayson:%s's child %s status on!", + name, nodeInfo->child->regulatorInfo.name); + return true; + } + } + + HDF_LOGD("RegulatorTreeIsChildAlwayson:%s's all child status off!", name); + return false; +} + +bool RegulatorTreeIsAllChildDisable(const char *name) +{ + CHECK_NULL_PTR_RETURN_VALUE(name, true); + struct DListHead *pList = RegulatorTreeGetChild(name); + CHECK_NULL_PTR_RETURN_VALUE(pList, true); + + struct RegulatorChildNode *nodeInfo = NULL; + struct RegulatorChildNode *tmp = NULL; + DLIST_FOR_EACH_ENTRY_SAFE(nodeInfo, tmp, pList, struct RegulatorChildNode, node) { + if (nodeInfo->child->regulatorInfo.status == REGULATOR_STATUS_ON) { + HDF_LOGI("RegulatorTreeIsAllChildDisable:%s's child %s on!", name, nodeInfo->child->regulatorInfo.name); + return false; + } + } + + HDF_LOGI("RegulatorTreeIsAllChildDisable:%s's all child off!", name); + return true; +} + +int32_t RegulatorTreeChildForceDisable(struct RegulatorNode *node) +{ + CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM); + struct DListHead *pList = RegulatorTreeGetChild(node->regulatorInfo.name); + CHECK_NULL_PTR_RETURN_VALUE(pList, HDF_SUCCESS); + + struct RegulatorChildNode *nodeInfo = NULL; + struct RegulatorChildNode *tmp = NULL; + DLIST_FOR_EACH_ENTRY_SAFE(nodeInfo, tmp, pList, struct RegulatorChildNode, node) { + if (RegulatorTreeChildForceDisable(nodeInfo->child) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeChildForceDisable: %s fail!", nodeInfo->child->regulatorInfo.name); + return HDF_FAILURE; + } + + if (OsalMutexLock(&nodeInfo->child->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeChildForceDisable: lock regulator %s fail!", node->regulatorInfo.name); + return HDF_ERR_DEVICE_BUSY; + } + if (nodeInfo->child->regulatorInfo.status == REGULATOR_STATUS_ON) { + nodeInfo->child->ops->disable(nodeInfo->child); + nodeInfo->child->regulatorInfo.status = REGULATOR_STATUS_OFF; + RegulatorNodeStatusCb(nodeInfo->child); + } + (void)OsalMutexUnlock(&nodeInfo->child->lock); + HDF_LOGI("RegulatorTreeChildForceDisable: child %s ForceDisable success!", nodeInfo->child->regulatorInfo.name); + } + + return HDF_SUCCESS; +} + +// if Tree regulator node not exist, then add +static int32_t RegulatorTreeManagerNodeInit(const char *name) +{ + CHECK_NULL_PTR_RETURN_VALUE(name, HDF_FAILURE); + + struct RegulatorTreeInfo *nodeInfo = NULL; + struct RegulatorTreeInfo *pos = NULL; + struct RegulatorTreeInfo *tmp = NULL; + struct RegulatorTreeManager *manager = g_regulatorTreeManager; + CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_FAILURE); + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeManagerNodeInit: lock regulator manager fail!"); + return HDF_ERR_DEVICE_BUSY; + } + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->treeMgrHead, struct RegulatorTreeInfo, node) { + if (strcmp(pos->name, name) == 0) { + HDF_LOGI("RegulatorTreeManagerNodeInit: node %s has exists!", name); + (void)OsalMutexUnlock(&manager->lock); + return HDF_SUCCESS; + } + } + + nodeInfo = (struct RegulatorTreeInfo *)OsalMemCalloc(sizeof(*nodeInfo)); + CHECK_NULL_PTR_RETURN_VALUE(nodeInfo, HDF_FAILURE); + + DListHeadInit(&nodeInfo->childHead); + nodeInfo->name = name; + + DListInsertTail(&nodeInfo->node, &manager->treeMgrHead); + (void)OsalMutexUnlock(&manager->lock); + + HDF_LOGI("RegulatorTreeManagerNodeInit: init %s node success!", name); + return HDF_SUCCESS; +} + +// set regulator (name)'s (parent) info +static int RegulatorTreeSetParent(const char *name, struct RegulatorNode *parent) +{ + CHECK_NULL_PTR_RETURN_VALUE(name, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(parent, HDF_ERR_INVALID_PARAM); + + struct RegulatorTreeInfo *pos = NULL; + struct RegulatorTreeInfo *tmp = NULL; + struct RegulatorTreeManager *manager = g_regulatorTreeManager; + CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_FAILURE); + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeSetParent: lock regulator manager fail!"); + return HDF_ERR_DEVICE_BUSY; + } + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->treeMgrHead, struct RegulatorTreeInfo, node) { + if (strcmp(pos->name, name) == 0) { + pos->parent = parent; + (void)OsalMutexUnlock(&manager->lock); + HDF_LOGI("RegulatorTreeSetParent: set %s parent success!", name); + return HDF_SUCCESS; + } + } + + (void)OsalMutexUnlock(&manager->lock); + HDF_LOGI("RegulatorTreeSetParent:%s does not exist!", name); + return HDF_FAILURE; +} + +// add (child) to regulator (name)'s childHead +static int RegulatorTreeSetChild(const char *name, struct RegulatorNode *child) +{ + CHECK_NULL_PTR_RETURN_VALUE(name, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(child, HDF_ERR_INVALID_PARAM); + + struct RegulatorTreeInfo *pos = NULL; + struct RegulatorTreeInfo *tmp = NULL; + struct RegulatorTreeManager *manager = g_regulatorTreeManager; + CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_FAILURE); + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeSetChild: lock regulator manager fail!"); + return HDF_ERR_DEVICE_BUSY; + } + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->treeMgrHead, struct RegulatorTreeInfo, node) { + if (strcmp(pos->name, name) == 0) { + if (RegulatorChildNodeAdd(pos, child) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeSetChild: RegulatorChildNodeAdd fail!"); + (void)OsalMutexUnlock(&manager->lock); + return HDF_FAILURE; + } + (void)OsalMutexUnlock(&manager->lock); + HDF_LOGI("RegulatorTreeSetChild: set %s child success!", name); + return HDF_SUCCESS; + } + } + + (void)OsalMutexUnlock(&manager->lock); + HDF_LOGI("RegulatorTreeSetChild:%s does not exist!", name); + return HDF_FAILURE; +} + +/* +* name: child regulator node name +* child: child regulator node info +* parent: parent regulator node info +* process: set regultor (name)'s RegulatorTreeInfo:parent,and add (name) to (parent)'s RegulatorTreeInfo:childHead +*/ +int RegulatorTreeSet(const char *name, struct RegulatorNode *child, struct RegulatorNode *parent) +{ + CHECK_NULL_PTR_RETURN_VALUE(name, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(child, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(parent, HDF_ERR_INVALID_PARAM); + + if (RegulatorTreeManagerNodeInit(name) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeSet: RegulatorTreeManagerNodeInit %s fail!", name); + return HDF_FAILURE; + } + if (RegulatorTreeSetParent(name, parent) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeSet: RegulatorTreeSetParent %s fail!", name); + return HDF_FAILURE; + } + + if (RegulatorTreeManagerNodeInit(parent->regulatorInfo.name) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeSet: RegulatorTreeManagerNodeInit %s fail!", parent->regulatorInfo.name); + return HDF_FAILURE; + } + if (RegulatorTreeSetChild(parent->regulatorInfo.name, child) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeSet: RegulatorTreeSetChild %s fail!", name); + return HDF_FAILURE; + } + + HDF_LOGI("RegulatorTreeSet: set [%s], parent[%s] and child info success!", + name, parent->regulatorInfo.name); + return HDF_SUCCESS; +} +static void RegulatorTreePrintChild(const char *name, struct DListHead *childHead) +{ + CHECK_NULL_PTR_RETURN(childHead); + CHECK_NULL_PTR_RETURN(name); + + struct RegulatorChildNode *nodeInfo = NULL; + struct RegulatorChildNode *tmp = NULL; + + DLIST_FOR_EACH_ENTRY_SAFE(nodeInfo, tmp, childHead, struct RegulatorChildNode, node) { + HDF_LOGI("RegulatorTreePrintChild: %s's child %s !", + name, nodeInfo->child->regulatorInfo.name); + } +} + +void RegulatorTreePrint(void) +{ + struct RegulatorTreeInfo *pos = NULL; + struct RegulatorTreeInfo *tmp = NULL; + struct RegulatorTreeManager *manager = g_regulatorTreeManager; + CHECK_NULL_PTR_RETURN(manager); + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreePrint: lock regulator manager fail!"); + return; + } + + DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->treeMgrHead, struct RegulatorTreeInfo, node) { + HDF_LOGI("RegulatorTreePrint %s info IN ---->", pos->name); + if (pos->parent != NULL) { + HDF_LOGI("RegulatorTreePrint %s info, parent name[%s]", + pos->name, pos->parent->regulatorInfo.name); + } + + RegulatorTreePrintChild(pos->name, &pos->childHead); + HDF_LOGI("RegulatorTreePrint %s info out---->", pos->name); + } + (void)OsalMutexUnlock(&manager->lock); +} + +int RegulatorTreeNodeRemoveAll(void) +{ + struct RegulatorTreeInfo *nodeInfo = NULL; + struct RegulatorTreeInfo *tmp = NULL; + struct RegulatorTreeManager *manager = g_regulatorTreeManager; + CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_FAILURE); + + if (OsalMutexLock(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeNodeRemoveAll: lock regulator manager fail!"); + return HDF_ERR_DEVICE_BUSY; + } + + DLIST_FOR_EACH_ENTRY_SAFE(nodeInfo, tmp, &manager->treeMgrHead, struct RegulatorTreeInfo, node) { + RegulatorChildListDestroy(nodeInfo); + DListRemove(&nodeInfo->node); + OsalMemFree(nodeInfo); + } + + (void)OsalMutexUnlock(&manager->lock); + return HDF_SUCCESS; +} + +int RegulatorTreeManagerDestory(void) +{ + if (RegulatorTreeNodeRemoveAll() != HDF_SUCCESS) { + HDF_LOGE("func:%s RegulatorTreeNodeRemoveAll failed", __func__); + } + + struct RegulatorTreeManager *manager = g_regulatorTreeManager; + CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_FAILURE); + OsalMutexDestroy(&manager->lock); + OsalMemFree(manager); + g_regulatorTreeManager = NULL; + return HDF_SUCCESS; +} + +int RegulatorTreeManagerInit(void) +{ + struct RegulatorTreeManager *manager = + (struct RegulatorTreeManager *)OsalMemCalloc(sizeof(struct RegulatorTreeManager)); + CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_FAILURE); + + if (OsalMutexInit(&manager->lock) != HDF_SUCCESS) { + HDF_LOGE("RegulatorTreeManagerInit: mutex init fail"); + OsalMemFree(manager); + return HDF_FAILURE; + } + + DListHeadInit(&manager->treeMgrHead); + g_regulatorTreeManager = manager; + return HDF_SUCCESS; +} diff --git a/support/platform/src/rtc_base.c b/support/platform/src/rtc/rtc_base.c similarity index 99% rename from support/platform/src/rtc_base.c rename to support/platform/src/rtc/rtc_base.c index 25be00507119e77a01e32598e6c1b699652dec57..f98003ee2cbbacbcd1db20d0e15f340d6d6c607e 100644 --- a/support/platform/src/rtc_base.c +++ b/support/platform/src/rtc/rtc_base.c @@ -7,8 +7,7 @@ */ #include "rtc_base.h" -#include "hdf_log.h" -#include "plat_log.h" +#include "platform_core.h" #define HDF_LOG_TAG rtc_base diff --git a/support/platform/src/rtc_core.c b/support/platform/src/rtc/rtc_core.c similarity index 100% rename from support/platform/src/rtc_core.c rename to support/platform/src/rtc/rtc_core.c diff --git a/support/platform/src/rtc_if.c b/support/platform/src/rtc/rtc_if.c similarity index 100% rename from support/platform/src/rtc_if.c rename to support/platform/src/rtc/rtc_if.c diff --git a/support/platform/src/spi_core.c b/support/platform/src/spi/spi_core.c similarity index 100% rename from support/platform/src/spi_core.c rename to support/platform/src/spi/spi_core.c diff --git a/support/platform/src/spi_if.c b/support/platform/src/spi/spi_if.c similarity index 100% rename from support/platform/src/spi_if.c rename to support/platform/src/spi/spi_if.c diff --git a/support/platform/src/uart_core.c b/support/platform/src/uart/uart_core.c similarity index 100% rename from support/platform/src/uart_core.c rename to support/platform/src/uart/uart_core.c diff --git a/support/platform/src/uart_if.c b/support/platform/src/uart/uart_if.c similarity index 100% rename from support/platform/src/uart_if.c rename to support/platform/src/uart/uart_if.c diff --git a/support/platform/src/watchdog_core.c b/support/platform/src/watchdog/watchdog_core.c similarity index 96% rename from support/platform/src/watchdog_core.c rename to support/platform/src/watchdog/watchdog_core.c index ba522098b03d6789fed1871e67e5d6368b457cd4..cdf901f5be9abd2b6f8caefabc8d1f4072168cb3 100644 --- a/support/platform/src/watchdog_core.c +++ b/support/platform/src/watchdog/watchdog_core.c @@ -55,14 +55,15 @@ void WatchdogCntlrRemove(struct WatchdogCntlr *cntlr) (void)OsalSpinDestroy(&cntlr->lock); } -void WatchdogGetPrivData(struct WatchdogCntlr *cntlr) +int32_t WatchdogGetPrivData(struct WatchdogCntlr *cntlr) { if (cntlr == NULL || cntlr->ops == NULL) { - return; + return HDF_ERR_INVALID_OBJECT; } if (cntlr->ops->getPriv != NULL) { - cntlr->ops->getPriv(cntlr); + return cntlr->ops->getPriv(cntlr); } + return HDF_SUCCESS; } void WatchdogReleasePriv(struct WatchdogCntlr *cntlr) diff --git a/support/platform/src/watchdog_if.c b/support/platform/src/watchdog/watchdog_if.c similarity index 89% rename from support/platform/src/watchdog_if.c rename to support/platform/src/watchdog/watchdog_if.c index b67506eef5c5ff143aeeddbb436e61c8661518ea..f1f85aee2800a9bf55785649357732687a7aba48 100644 --- a/support/platform/src/watchdog_if.c +++ b/support/platform/src/watchdog/watchdog_if.c @@ -46,16 +46,24 @@ static struct Watchdog *WatchdogGetById(int16_t wdtId) return service; } -DevHandle WatchdogOpen(int16_t wdtId) +int32_t WatchdogOpen(int16_t wdtId, DevHandle *handle) { struct Watchdog *service = NULL; + int32_t ret; service = WatchdogGetById(wdtId); if (service == NULL) { - return NULL; + *handle = NULL; + return HDF_ERR_INVALID_OBJECT; + } + + ret = WatchdogGetPrivData((struct WatchdogCntlr *)service); + if (ret == HDF_SUCCESS) { + *handle = (DevHandle)service; + return ret; } - WatchdogGetPrivData((struct WatchdogCntlr *)service); - return (DevHandle)service; + + return ret; } void WatchdogClose(DevHandle handle) diff --git a/support/platform/test/unittest/common/hdf_dac_test.cpp b/support/platform/test/unittest/common/hdf_dac_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..808d90dccdc416b3216bcef4a2bd7c6721f331b3 --- /dev/null +++ b/support/platform/test/unittest/common/hdf_dac_test.cpp @@ -0,0 +1,84 @@ +/* + * Copyright (c) 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 +#include +#include +#include +#include +#include +#include +#include "hdf_uhdf_test.h" +#include "dac_test.h" +#include "hdf_io_service_if.h" + +using namespace testing::ext; + +class HdfLiteDacTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void HdfLiteDacTest::SetUpTestCase() +{ + HdfTestOpenService(); +} + +void HdfLiteDacTest::TearDownTestCase() +{ + HdfTestCloseService(); +} + +void HdfLiteDacTest::SetUp() +{ +} + +void HdfLiteDacTest::TearDown() +{ +} + +/** + * @tc.name: DacTestRead001 + * @tc.desc: dac write test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteDacTest, DacTestWrite001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_DAC_TYPE, DAC_TEST_CMD_WRITE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: DacTestMultiThread001 + * @tc.desc: dac multi thread test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteDacTest, DacTestMultiThread001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_DAC_TYPE, DAC_TEST_CMD_MULTI_THREAD, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: DacTestReliability001 + * @tc.desc: dac reliability test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteDacTest, DacTestReliability001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_DAC_TYPE, DAC_TEST_CMD_RELIABILITY, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + + diff --git a/support/platform/test/unittest/common/hdf_gpio_test.cpp b/support/platform/test/unittest/common/hdf_gpio_test.cpp index f6800ef9684fb0fa279daff907256aea9edce7c1..a352b75d60f62f435487e2cc04ff404245208322 100644 --- a/support/platform/test/unittest/common/hdf_gpio_test.cpp +++ b/support/platform/test/unittest/common/hdf_gpio_test.cpp @@ -13,22 +13,12 @@ #include #include #include +#include "gpio_test.h" #include "hdf_uhdf_test.h" #include "hdf_io_service_if.h" using namespace testing::ext; -// pal gpio test case number -enum GpioTestCmd { - GPIO_TEST_SET_GET_DIR = 0, - GPIO_TEST_WRITE_READ = 1, - GPIO_TEST_IRQ_LEVEL = 2, - GPIO_TEST_IRQ_EDGE = 3, - GPIO_TEST_IRQ_THREAD = 4, - GPIO_TEST_RELIABILITY = 5, - GPIO_TEST_MAX = 6, -}; - class HdfLiteGpioTest : public testing::Test { public: static void SetUpTestCase(); @@ -65,6 +55,10 @@ HWTEST_F(HdfLiteGpioTest, GpioTestSetGetDir001, TestSize.Level1) { struct HdfTestMsg msg = {TEST_PAL_GPIO_TYPE, GPIO_TEST_SET_GET_DIR, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); + printf("%s: kernel test done, then for user...\n", __func__); + + EXPECT_EQ(0, GpioTestExecute(GPIO_TEST_SET_GET_DIR)); + printf("%s: exit!\n", __func__); } /** @@ -77,6 +71,10 @@ HWTEST_F(HdfLiteGpioTest, GpioTestWriteRead001, TestSize.Level1) { struct HdfTestMsg msg = {TEST_PAL_GPIO_TYPE, GPIO_TEST_WRITE_READ, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); + printf("%s: kernel test done, then for user...\n", __func__); + + EXPECT_EQ(0, GpioTestExecute(GPIO_TEST_WRITE_READ)); + printf("%s: exit!\n", __func__); } /** @@ -89,6 +87,10 @@ HWTEST_F(HdfLiteGpioTest, GpioTestIrqLevel001, TestSize.Level1) { struct HdfTestMsg msg = {TEST_PAL_GPIO_TYPE, GPIO_TEST_IRQ_LEVEL, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); + printf("%s: kernel test done, then for user...\n", __func__); + + EXPECT_EQ(0, GpioTestExecute(GPIO_TEST_IRQ_LEVEL)); + printf("%s: exit!\n", __func__); } /** @@ -101,6 +103,10 @@ HWTEST_F(HdfLiteGpioTest, GpioTestIrqEdge001, TestSize.Level1) { struct HdfTestMsg msg = {TEST_PAL_GPIO_TYPE, GPIO_TEST_IRQ_EDGE, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); + printf("%s: kernel test done, then for user...\n", __func__); + + EXPECT_EQ(0, GpioTestExecute(GPIO_TEST_IRQ_EDGE)); + printf("%s: exit!\n", __func__); } /** @@ -113,6 +119,10 @@ HWTEST_F(HdfLiteGpioTest, GpioTestIrqThread001, TestSize.Level1) { struct HdfTestMsg msg = {TEST_PAL_GPIO_TYPE, GPIO_TEST_IRQ_THREAD, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); + printf("%s: kernel test done, then for user...\n", __func__); + + EXPECT_EQ(0, GpioTestExecute(GPIO_TEST_IRQ_THREAD)); + printf("%s: exit!\n", __func__); } /** @@ -125,4 +135,8 @@ HWTEST_F(HdfLiteGpioTest, GpioTestReliability001, TestSize.Level1) { struct HdfTestMsg msg = {TEST_PAL_GPIO_TYPE, GPIO_TEST_RELIABILITY, -1}; EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); + printf("%s: kernel test done, then for user...\n", __func__); + + EXPECT_EQ(0, GpioTestExecute(GPIO_TEST_RELIABILITY)); + printf("%s: exit!\n", __func__); } diff --git a/support/platform/test/unittest/common/hdf_hdmi_test.cpp b/support/platform/test/unittest/common/hdf_hdmi_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..e0017c2fd644b083ef40437c4640962618fa912c --- /dev/null +++ b/support/platform/test/unittest/common/hdf_hdmi_test.cpp @@ -0,0 +1,266 @@ +/* + * Copyright (c) 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 +#include +#include +#include +#include +#include +#include +#include "hdmi_if.h" +#include "hdf_uhdf_test.h" +#include "hdf_io_service_if.h" + + +using namespace testing::ext; + +enum HdmiTestCmd { + HDMI_START_AND_STOP_01 = 0, + HDMI_SET_AUDIO_ATTR_01 = 1, + HDMI_SET_VIDEO_ATTR_01 = 2, + HDMI_SET_HDR_ATTR_01 = 3, + HDMI_SET_AVMUTE_01 = 4, + HDMI_EDID_RAW_DATA_GET_01 = 5, + HDMI_DEEP_COLOR_SET_AND_GET_01 = 6, + HDMI_HPD_REGISTER_AND_UNREGISTER_01 = 7, +}; + +class HdfLiteHdmiTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void HdfLiteHdmiTest::SetUpTestCase() +{ + HdfTestOpenService(); +} + +void HdfLiteHdmiTest::TearDownTestCase() +{ + HdfTestCloseService(); +} + +void HdfLiteHdmiTest::SetUp() +{ +} + +void HdfLiteHdmiTest::TearDown() +{ +} + +static void HdmiUserHpdHandle(void *data, bool hpd) +{ + if (data == NULL) { + printf("data is null"); + } + if (hpd == true) { + printf("HdmiUserHpdHandle: hpd."); + } else { + printf("HdmiUserHpdHandle: unhpd."); + } +} + +static void HdmiUserSetAttrCaseTest(DevHandle handle) +{ + struct HdmiVideoAttr videoAttr; + struct HdmiAudioAttr audioAttr; + struct HdmiHdrAttr hdrAttr; + int32_t ret; + + videoAttr.colorSpace = HDMI_COLOR_SPACE_YCBCR444; + videoAttr.colorimetry = HDMI_COLORIMETRY_EXTENDED; + videoAttr.extColorimetry = HDMI_EXTENDED_COLORIMETRY_BT2020_CONST_LUM; + videoAttr.quantization = HDMI_QUANTIZATION_RANGE_FULL; + ret = HdmiSetVideoAttribute(handle, &videoAttr); + if (ret != HDF_SUCCESS) { + printf("HdmiSetVideoAttribute fail."); + } + audioAttr.codingType = HDMI_AUDIO_CODING_TYPE_MP3; + audioAttr.ifType = HDMI_AUDIO_IF_TYPE_I2S; + audioAttr.bitDepth = HDMI_ADIO_BIT_DEPTH_16; + audioAttr.sampleRate = HDMI_SAMPLE_RATE_8K; + audioAttr.channels = HDMI_AUDIO_FORMAT_CHANNEL_3; + ret = HdmiSetAudioAttribute(handle, &audioAttr); + if (ret != HDF_SUCCESS) { + printf("HdmiSetAudioAttribute fail."); + } + hdrAttr.mode = HDMI_HDR_MODE_CEA_861_3; + hdrAttr.userMode = HDMI_HDR_USERMODE_DOLBY; + hdrAttr.eotfType = HDMI_EOTF_SMPTE_ST_2048; + hdrAttr.metadataType = HDMI_DRM_STATIC_METADATA_TYPE_1; + hdrAttr.colorimetry = HDMI_HDR_EXTENDED_COLORIMETRY_XV_YCC_709; + ret = HdmiSetHdrAttribute(handle, &hdrAttr); + if (ret != HDF_SUCCESS) { + printf("HdmiSetHdrAttribute fail."); + } +} + +static void HdmiUserTest(void) +{ + DevHandle handle = NULL; + int32_t ret; + enum HdmiDeepColor color = HDMI_DEEP_COLOR_24BITS; + uint8_t data[128] = {0}; + struct HdmiHpdCallbackInfo callback; + + handle = HdmiOpen(0); + if (handle == NULL) { + printf("HdmiOpen fail."); + } + callback.data = NULL; + callback.callbackFunc = HdmiUserHpdHandle; + ret = HdmiRegisterHpdCallbackFunc(handle, &callback); + if (ret != HDF_SUCCESS) { + printf("HdmiRegisterHpdCallbackFunc fail."); + } + ret = HdmiAvmuteSet(handle, true); + if (ret != HDF_SUCCESS) { + printf("HdmiAvmuteSet fail."); + } + ret = HdmiDeepColorSet(handle, HDMI_DEEP_COLOR_48BITS); + if (ret != HDF_SUCCESS) { + printf("HdmiDeepColorSet fail."); + } + ret = HdmiDeepColorGet(handle, &color); + if (ret != HDF_SUCCESS) { + printf("HdmiDeepColorGet fail."); + } + printf("HdmiDeepColorGet success, color = %d.", color); + + HdmiUserSetAttrCaseTest(handle); + + ret = HdmiStart(handle); + if (ret != HDF_SUCCESS) { + printf("HdmiStart fail."); + } + ret = HdmiReadSinkEdid(handle, data, 128); + if (ret < 0) { + printf("HdmiReadSinkEdid fail."); + } + printf("HdmiReadSinkEdid success, data[6] = %d, data[8] = %d.", data[6], data[8]); + ret = HdmiStop(handle); + if (ret != HDF_SUCCESS) { + printf("HdmiStop fail."); + } + ret = HdmiUnregisterHpdCallbackFunc(handle); + if (ret != HDF_SUCCESS) { + printf("HdmiUnregisterHpdCallbackFunc fail."); + } + HdmiClose(handle); +} + +/** + * @tc.name: HdmiStartAndStop001 + * @tc.desc: test HdmiStart/HdmiStop interface in kernel status. + * @tc.type: FUNC + * @tc.require: SR000G4490 + */ +HWTEST_F(HdfLiteHdmiTest, HdmiStartAndStop001, TestSize.Level1) +{ + struct HdfTestMsg msg = { TEST_PAL_HDMI_TYPE, HDMI_START_AND_STOP_01, -1 }; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HdmiSetAudioAttr001 + * @tc.desc: test HdmiSetAudioAttr interface in kernel status. + * @tc.type: FUNC + * @tc.require: SR000G4490 + */ +HWTEST_F(HdfLiteHdmiTest, HdmiSetAudioAttr001, TestSize.Level1) +{ + struct HdfTestMsg msg = { TEST_PAL_HDMI_TYPE, HDMI_SET_AUDIO_ATTR_01, -1 }; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HdmiSetVideoAttr001 + * @tc.desc: test HdmiSetVideoAttr interface in kernel status. + * @tc.type: FUNC + * @tc.require: SR000G4490 + */ +HWTEST_F(HdfLiteHdmiTest, HdmiSetVideoAttr001, TestSize.Level1) +{ + struct HdfTestMsg msg = { TEST_PAL_HDMI_TYPE, HDMI_SET_VIDEO_ATTR_01, -1 }; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HdmiSetHdrAttr001 + * @tc.desc: test HdmiSetHdrAttr interface in kernel status. + * @tc.type: FUNC + * @tc.require: SR000G4490 + */ +HWTEST_F(HdfLiteHdmiTest, HdmiSetHdrAttr001, TestSize.Level1) +{ + struct HdfTestMsg msg = { TEST_PAL_HDMI_TYPE, HDMI_SET_HDR_ATTR_01, -1 }; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HdmiSetAvmute001 + * @tc.desc: test HdmiSetAvmute interface in kernel status. + * @tc.type: FUNC + * @tc.require: SR000G4490 + */ +HWTEST_F(HdfLiteHdmiTest, HdmiSetAvmute001, TestSize.Level1) +{ + struct HdfTestMsg msg = { TEST_PAL_HDMI_TYPE, HDMI_SET_AVMUTE_01, -1 }; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HdmiEdidRawDataGet001 + * @tc.desc: test HdmiReadSinkEdid interface in kernel status. + * @tc.type: FUNC + * @tc.require: SR000G4490 + */ +HWTEST_F(HdfLiteHdmiTest, HdmiEdidRawDataGet001, TestSize.Level1) +{ + struct HdfTestMsg msg = { TEST_PAL_HDMI_TYPE, HDMI_EDID_RAW_DATA_GET_01, -1 }; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HdmiDeepColorSetAndGet001 + * @tc.desc: test HdmiDeepColorSet/HdmiDeepColorGet interface in kernel status. + * @tc.type: FUNC + * @tc.require: SR000G4490 + */ +HWTEST_F(HdfLiteHdmiTest, HdmiDeepColorSetAndGet001, TestSize.Level1) +{ + struct HdfTestMsg msg = { TEST_PAL_HDMI_TYPE, HDMI_DEEP_COLOR_SET_AND_GET_01, -1 }; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HdmiDeepColorSetAndGet001 + * @tc.desc: test HdmiDeepColorSet/HdmiDeepColorGet interface in kernel status. + * @tc.type: FUNC + * @tc.require: SR000G4490 + */ +HWTEST_F(HdfLiteHdmiTest, HdmiHpdRegisterAndUngister001, TestSize.Level1) +{ + struct HdfTestMsg msg = { TEST_PAL_HDMI_TYPE, HDMI_HPD_REGISTER_AND_UNREGISTER_01, -1 }; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HdmiUserTest001 + * @tc.desc: test hdmi all interface in user status. + * @tc.type: FUNC + * @tc.require: SR000G4490 + */ +HWTEST_F(HdfLiteHdmiTest, HdmiUserTest001, TestSize.Level1) +{ + HdmiUserTest(); +} diff --git a/support/platform/test/unittest/common/hdf_i3c_test.cpp b/support/platform/test/unittest/common/hdf_i3c_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..ff340826f60c6596ae0334791cf6a68dd94fc923 --- /dev/null +++ b/support/platform/test/unittest/common/hdf_i3c_test.cpp @@ -0,0 +1,134 @@ +/* + * Copyright (c) 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 +#include +#include +#include +#include +#include +#include +#include "hdf_uhdf_test.h" +#include "i3c_test.h" +#include "hdf_io_service_if.h" + +using namespace testing::ext; + +class HdfI3cTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void HdfI3cTest::SetUpTestCase() +{ + struct HdfTestMsg msg = {TEST_PAL_I3C_TYPE, I3C_TEST_CMD_SETUP_ALL, -1}; + HdfTestOpenService(); + HdfTestSendMsgToService(&msg); +} + +void HdfI3cTest::TearDownTestCase() +{ + struct HdfTestMsg msg = {TEST_PAL_I3C_TYPE, I3C_TEST_CMD_TEARDOWN_ALL, -1}; + HdfTestSendMsgToService(&msg); + HdfTestCloseService(); +} + +void HdfI3cTest::SetUp() +{ +} + +void HdfI3cTest::TearDown() +{ +} + +/** + * @tc.name: HdfI3cTestTransfer001 + * @tc.desc: i3c transfer test + * @tc.type: FUNC + * @tc.require: N/A + */ +HWTEST_F(HdfI3cTest, HdfI3cTestTransfer001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_I3C_TYPE, I3C_TEST_CMD_TRANSFER, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HdfI3cTestSetConfig001 + * @tc.desc: i3c set config test + * @tc.type: FUNC + * @tc.require: N/A + */ +HWTEST_F(HdfI3cTest, HdfI3cTestSetConfig001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_I3C_TYPE, I3C_TEST_CMD_SET_CONFIG, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HdfI3cTestGetConfig001 + * @tc.desc: i3c get config test + * @tc.type: FUNC + * @tc.require: N/A + */ +HWTEST_F(HdfI3cTest, HdfI3cTestGetConfig001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_I3C_TYPE, I3C_TEST_CMD_GET_CONFIG, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HdfI3cTestRequestIbi001 + * @tc.desc: i3c request ibi test + * @tc.type: FUNC + * @tc.require: N/A + */ +HWTEST_F(HdfI3cTest, HdfI3cTestRequestIbi001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_I3C_TYPE, I3C_TEST_CMD_REQUEST_IBI, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HdfI3cTestRreeIbi001 + * @tc.desc: i3c free ibi test + * @tc.type: FUNC + * @tc.require: N/A + */ +HWTEST_F(HdfI3cTest, HdfI3cTestRreeIbi001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_I3C_TYPE, I3C_TEST_CMD_FREE_IBI, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HdfI3cTestMultiThread001 + * @tc.desc: i3c multithreading test + * @tc.type: FUNC + * @tc.require: N/A + */ +HWTEST_F(HdfI3cTest, HdfI3cTestMultiThread001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_I3C_TYPE, I3C_TEST_CMD_MULTI_THREAD, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HdfI3cTestReliability001 + * @tc.desc: i3c reliability test + * @tc.type: FUNC + * @tc.require: N/A + */ +HWTEST_F(HdfI3cTest, HdfI3cTestReliability001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_I3C_TYPE, I3C_TEST_CMD_RELIABILITY, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} diff --git a/support/platform/test/unittest/common/hdf_mipi_csi_test.cpp b/support/platform/test/unittest/common/hdf_mipi_csi_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..8c661ecff7c24a6fe838367995391d41e6f4a0d0 --- /dev/null +++ b/support/platform/test/unittest/common/hdf_mipi_csi_test.cpp @@ -0,0 +1,206 @@ +/* + * Copyright (c) 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_uhdf_test.h" +#include + +using namespace testing::ext; + +/** + * @brief Mipi csi test case number. + * + * The sequence number is related to the test logic, which is different from the actual call. + * 1, 4, 8 and 9 need to be called according to the actual situation. + * + * @since 1.0 + */ +enum MipiCsiTestCmd { + MIPI_CSI_TEST_SET_HS_MODE = 0, + MIPI_CSI_TEST_DISABLE_MIPI_CLOCK = 1, /* for test */ + MIPI_CSI_TEST_ENABLE_MIPI_CLOCK = 2, + MIPI_CSI_TEST_RESET_RX = 3, + MIPI_CSI_TEST_DISABLE_SENSOR_CLOCK = 4, /* for test */ + MIPI_CSI_TEST_ENABLE_SENSOR_CLOCK = 5, + MIPI_CSI_TEST_RESET_SENSOR = 6, + MIPI_CSI_TEST_SET_DEV_ATTR = 7, + MIPI_CSI_TEST_SET_PHY_CMVMODE = 8, /* for test */ + MIPI_CSI_TEST_SET_EXT_DATA_TYPE = 9, /* for test */ + MIPI_CSI_TEST_UNRESET_RX = 10, + MIPI_CSI_TEST_UNRESET_SENSOR = 11, + MIPI_CSI_TEST_MAX = 12 +}; + +class HdfLiteMipiCsiTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void HdfLiteMipiCsiTest::SetUpTestCase() +{ + HdfTestOpenService(); +} + +void HdfLiteMipiCsiTest::TearDownTestCase() +{ + HdfTestCloseService(); +} + +void HdfLiteMipiCsiTest::SetUp() +{ +} + +void HdfLiteMipiCsiTest::TearDown() +{ +} + +/** + * @tc.name: MipiCsiSetHsModeTest001 + * @tc.desc: mipi csi function test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteMipiCsiTest, MipiCsiSetHsModeTest001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_MIPI_CSI_TYPE, MIPI_CSI_TEST_SET_HS_MODE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: MipiCsiDisableMipiClockTest001 + * @tc.desc: mipi csi function test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteMipiCsiTest, MipiCsiDisableMipiClockTest001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_MIPI_CSI_TYPE, MIPI_CSI_TEST_DISABLE_MIPI_CLOCK, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: MipiCsiEnableMipiClockTest001 + * @tc.desc: mipi csi function test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteMipiCsiTest, MipiCsiEnableMipiClockTest001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_MIPI_CSI_TYPE, MIPI_CSI_TEST_ENABLE_MIPI_CLOCK, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: MipiCsiResetRxTest001 + * @tc.desc: mipi csi function test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteMipiCsiTest, MipiCsiResetRxTest001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_MIPI_CSI_TYPE, MIPI_CSI_TEST_RESET_RX, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: MipiCsiDisableSensorClockTest001 + * @tc.desc: mipi csi function test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteMipiCsiTest, MipiCsiDisableSensorClockTest001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_MIPI_CSI_TYPE, MIPI_CSI_TEST_DISABLE_SENSOR_CLOCK, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: MipiCsiEnableSensorClockTest001 + * @tc.desc: mipi csi function test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteMipiCsiTest, MipiCsiEnableSensorClockTest001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_MIPI_CSI_TYPE, MIPI_CSI_TEST_ENABLE_SENSOR_CLOCK, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: MipiCsiResetSensorTest001 + * @tc.desc: mipi csi function test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteMipiCsiTest, MipiCsiResetSensorTest001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_MIPI_CSI_TYPE, MIPI_CSI_TEST_RESET_SENSOR, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: MipiCsiSetComboDevAttrTest001 + * @tc.desc: mipi csi function test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteMipiCsiTest, MipiCsiSetComboDevAttrTest001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_MIPI_CSI_TYPE, MIPI_CSI_TEST_SET_DEV_ATTR, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: MipiCsiSetPhyCmvmodeTest001 + * @tc.desc: mipi csi function test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteMipiCsiTest, MipiCsiSetPhyCmvmodeTest001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_MIPI_CSI_TYPE, MIPI_CSI_TEST_SET_PHY_CMVMODE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: MipiCsiSetExtDataTypeTest001 + * @tc.desc: mipi csi function test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteMipiCsiTest, MipiCsiSetExtDataTypeTest001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_MIPI_CSI_TYPE, MIPI_CSI_TEST_SET_EXT_DATA_TYPE, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: MipiCsiUnresetRxTest001 + * @tc.desc: mipi csi function test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteMipiCsiTest, MipiCsiUnresetRxTest001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_MIPI_CSI_TYPE, MIPI_CSI_TEST_UNRESET_RX, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: MipiCsiUnresetSensorTest001 + * @tc.desc: mipi csi function test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteMipiCsiTest, MipiCsiUnresetSensorTest001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_MIPI_CSI_TYPE, MIPI_CSI_TEST_UNRESET_SENSOR, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} \ No newline at end of file diff --git a/support/platform/test/unittest/common/hdf_mipi_dsi_test.cpp b/support/platform/test/unittest/common/hdf_mipi_dsi_test.cpp index 4f394ec3895b9b9378acc3ec26ef378aa6688187..d0b009e15501331d2256b6975c570adbf5a526b0 100644 --- a/support/platform/test/unittest/common/hdf_mipi_dsi_test.cpp +++ b/support/platform/test/unittest/common/hdf_mipi_dsi_test.cpp @@ -7,14 +7,7 @@ */ #include "hdf_uhdf_test.h" -#include -#include -#include -#include #include -#include -#include -#include "hdf_io_service_if.h" using namespace testing::ext; diff --git a/support/platform/test/unittest/common/hdf_pin_test.cpp b/support/platform/test/unittest/common/hdf_pin_test.cpp new file mode 100644 index 0000000000000000000000000000000000000000..0b1ed87cf70a969b0bf582dc79d82b29f195a300 --- /dev/null +++ b/support/platform/test/unittest/common/hdf_pin_test.cpp @@ -0,0 +1,97 @@ +/* Copyright (c) 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 +#include +#include +#include +#include +#include +#include +#include "hdf_uhdf_test.h" +#include "hdf_io_service_if.h" +#include "pin_test.h" + +using namespace testing::ext; + +class HdfPinTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void HdfPinTest::SetUpTestCase() +{ + struct HdfTestMsg msg = {TEST_PAL_PIN_TYPE, PIN_TEST_CMD_SETUP_ALL, -1}; + HdfTestOpenService(); + HdfTestSendMsgToService(&msg); +} + +void HdfPinTest::TearDownTestCase() +{ + struct HdfTestMsg msg = {TEST_PAL_PIN_TYPE, PIN_TEST_CMD_TEARDOWN_ALL, -1}; + HdfTestSendMsgToService(&msg); + HdfTestCloseService(); +} + +void HdfPinTest::SetUp() +{ +} + +void HdfPinTest::TearDown() +{ +} + +/** + * @tc.name: PinTestSetGetPinPull001 + * @tc.desc: Pin set get pin Pull test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfPinTest, PinSetGetPull001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_PIN_TYPE, PIN_TEST_CMD_SETGETPULL, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: PinTestSetGetStrength001 + * @tc.desc: Pin set get pin Strength test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfPinTest, PinSetGetStrength001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_PIN_TYPE, PIN_TEST_CMD_SETGETSTRENGTH, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: PinSetGetPinFunc001 + * @tc.desc: Pin set get pin func test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfPinTest, PinSetGetPinFunc001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_PIN_TYPE, PIN_TEST_CMD_SETGETFUNC, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: PinReliabilityTest001 + * @tc.desc: Pin function test + * @tc.type: FUNC + * @tc.require: + */ +HWTEST_F(HdfPinTest, PinReliabilityTest001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_PIN_TYPE, PIN_TEST_CMD_RELIABILITY, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} \ No newline at end of file diff --git a/support/platform/test/unittest/common/hdf_pwm_test.cpp b/support/platform/test/unittest/common/hdf_pwm_test.cpp index 3a439a5eacf35a633739fab2eb4f7a8bad25f16e..c7c787dfa5c2cff4fa5500b25db7dac98cede39d 100644 --- a/support/platform/test/unittest/common/hdf_pwm_test.cpp +++ b/support/platform/test/unittest/common/hdf_pwm_test.cpp @@ -6,13 +6,7 @@ * See the LICENSE file in the root of this repository for complete details. */ -#include -#include -#include -#include #include -#include -#include #include "hdf_uhdf_test.h" using namespace testing::ext; diff --git a/support/platform/test/unittest/common/hdf_regulator_test.cpp b/support/platform/test/unittest/common/hdf_regulator_test.cpp new file mode 100755 index 0000000000000000000000000000000000000000..237d390ad43b3bf8597c51881c02de3a5ff0e1d9 --- /dev/null +++ b/support/platform/test/unittest/common/hdf_regulator_test.cpp @@ -0,0 +1,168 @@ +/* + * Copyright (c) 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 +#include +#include +#include +#include +#include +#include +#include "hdf_uhdf_test.h" +#include "hdf_io_service_if.h" + +using namespace testing::ext; + +enum RegulatorTestCmd { + REGULATOR_ENABLE_TEST, + REGULATOR_DISABLE_TEST, + REGULATOR_FORCE_DISABLE_TEST, + REGULATOR_SET_VOLTAGE_TEST, + REGULATOR_GET_VOLTAGE_TEST, + REGULATOR_SET_CURRENT_TEST, + REGULATOR_GET_CURRENT_TEST, + REGULATOR_GET_STATUS_TEST, + REGULATOR_MULTI_THREAD_TEST, + REGULATOR_RELIABILITY_TEST, +}; + +class HdfLiteRegulatorTest : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void HdfLiteRegulatorTest::SetUpTestCase() +{ + HdfTestOpenService(); +} + +void HdfLiteRegulatorTest::TearDownTestCase() +{ + HdfTestCloseService(); +} + +void HdfLiteRegulatorTest::SetUp() +{ +} + +void HdfLiteRegulatorTest::TearDown() +{ +} +/** + * @tc.name: RegulatorTestEnable001 + * @tc.desc: regulator enable test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteRegulatorTest, RegulatorTestEnable001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_REGULATOR_TYPE, REGULATOR_ENABLE_TEST, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +/** + * @tc.name: RegulatorTestDisable001 + * @tc.desc: regulator disable test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteRegulatorTest, RegulatorTestDisable001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_REGULATOR_TYPE, REGULATOR_DISABLE_TEST, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +/** + * @tc.name: RegulatorTestForceDisable001 + * @tc.desc: regulator force disable test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteRegulatorTest, RegulatorTestForceDisable001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_REGULATOR_TYPE, REGULATOR_FORCE_DISABLE_TEST, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +/** + * @tc.name: RegulatorTestSetVoltage001 + * @tc.desc: regulator set voltage test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteRegulatorTest, RegulatorTestSetVoltage001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_REGULATOR_TYPE, REGULATOR_SET_VOLTAGE_TEST, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +/** + * @tc.name: RegulatorTestGetVoltage001 + * @tc.desc: regulator get voltage test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteRegulatorTest, RegulatorTestGetVoltage001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_REGULATOR_TYPE, REGULATOR_GET_VOLTAGE_TEST, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +/** + * @tc.name: RegulatorTestSetCurrent001 + * @tc.desc: regulator set current test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteRegulatorTest, RegulatorTestSetCurrent001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_REGULATOR_TYPE, REGULATOR_SET_CURRENT_TEST, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +/** + * @tc.name: RegulatorTestGetCurrent001 + * @tc.desc: regulator get current test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteRegulatorTest, RegulatorTestGetCurrent001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_REGULATOR_TYPE, REGULATOR_GET_CURRENT_TEST, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +/** + * @tc.name: RegulatorTestGetCurrent001 + * @tc.desc: regulator get status test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteRegulatorTest, RegulatorTestGetStatus001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_REGULATOR_TYPE, REGULATOR_GET_STATUS_TEST, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +/** + * @tc.name: RegulatorTestMultiThread001 + * @tc.desc: regulator multi thread test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteRegulatorTest, RegulatorTestMultiThread001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_REGULATOR_TYPE, REGULATOR_MULTI_THREAD_TEST, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} +/** + * @tc.name: RegulatorTestReliability001 + * @tc.desc: regulator Reliability test + * @tc.type: FUNC + * @tc.require: NA + */ +HWTEST_F(HdfLiteRegulatorTest, RegulatorTestReliability001, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_PAL_REGULATOR_TYPE, REGULATOR_RELIABILITY_TEST, -1}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} diff --git a/support/platform/test/unittest/common/hdf_spi_test.cpp b/support/platform/test/unittest/common/hdf_spi_test.cpp index 050d053ae6bf9996c323b32f65449d8b204a8da3..8bc75fefa417508781b965f2273847a2dcc383cd 100644 --- a/support/platform/test/unittest/common/hdf_spi_test.cpp +++ b/support/platform/test/unittest/common/hdf_spi_test.cpp @@ -27,18 +27,6 @@ enum HdfTestCaseCmd { SPI_PERFORMANCE_TEST, }; -/*enum HdfTestCaseCmd { - SPI_SET_CFG_TEST = 0, - SPI_TRANSFER_TEST, - SPI_WRITE_TEST, - SPI_READ_TEST, - SPI_DMA_TEST, - SPI_INTERRUPT_TEST, - SPI_RELIABILITY_TEST, - SPI_PERFORMANCE_TEST, -}; -*/ - class HdfLiteSpiTest : public testing::Test { public: static void SetUpTestCase(); diff --git a/support/posix/test/unittest/common/hdf_osal_test.cpp b/support/posix/test/unittest/common/hdf_osal_test.cpp index 889f3b965b7a5d4b29fea36b9ad2d353cbd33a22..0f904f284679697365e85d74e9349bc45cf57918 100644 --- a/support/posix/test/unittest/common/hdf_osal_test.cpp +++ b/support/posix/test/unittest/common/hdf_osal_test.cpp @@ -13,14 +13,12 @@ #include #include #include -#include "osal_test_case_def.h" -#include "hdf_uhdf_test.h" #include "hdf_io_service_if.h" +#include "hdf_uhdf_test.h" +#include "osal_test_case_def.h" using namespace testing::ext; -static const int OSAL_TEST_TIME = 30; -static const int OSAL_WAIT_END_TIME = 5; static const char *OSAL_FW_PATH = "/lib/firmware"; static const int OSAL_FW_PATH_MODE = 0x777; #define OSAL_TEST_FUNC_DEFINE(subCmd) do { \ @@ -35,6 +33,9 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); +private: + static const int OSAL_TEST_TIME = 30; + static const int OSAL_WAIT_END_TIME = 5; }; static void OsalCreateDir(bool flag) diff --git a/support/posix/test/unittest/common/hdf_osal_test_posix.cpp b/support/posix/test/unittest/common/hdf_osal_test_posix.cpp index ae22b4fdc5cb1983c897a07533fbe2a92e1ca1d0..5b1101a9f533d07ade38ef944a6278a8488764c5 100755 --- a/support/posix/test/unittest/common/hdf_osal_test_posix.cpp +++ b/support/posix/test/unittest/common/hdf_osal_test_posix.cpp @@ -13,9 +13,9 @@ #include #include #include -#include "osal_test_case_def.h" #include "hdf_uhdf_test.h" #include "osal_get_case_test.h" +#include "osal_test_case_def.h" int32_t HdfOsalUserEntry(enum HdfOsalTestCaseCmd cmd) { @@ -41,9 +41,6 @@ int32_t HdfOsalUserEntry(enum HdfOsalTestCaseCmd cmd) using namespace testing::ext; -static const int OSAL_TEST_TIME = 30; -static const int OSAL_WAIT_END_TIME = 5; - #define OSAL_TEST_FUNC_DEFINE(subCmd) do { \ printf("OSAL test enter cmd:%d\n\r", subCmd); \ EXPECT_EQ(0, HdfOsalUserEntry(subCmd)); \ @@ -55,6 +52,9 @@ public: static void TearDownTestCase(); void SetUp(); void TearDown(); +private: + static const int OSAL_TEST_TIME = 30; + static const int OSAL_WAIT_END_TIME = 5; }; void OsalTest::SetUpTestCase() diff --git a/test/unittest/common/hdf_main_test.c b/test/unittest/common/hdf_main_test.c index 75ae6386af7bc6ee7eed17dfa1337e544dd486a3..52a8d2f1d559e8076beeddac1687f828bce52868 100644 --- a/test/unittest/common/hdf_main_test.c +++ b/test/unittest/common/hdf_main_test.c @@ -6,10 +6,10 @@ * See the LICENSE file in the root of this repository for complete details. */ -#include "hdf_log.h" +#include "hcs_parser_test.h" #include "hdf_base.h" -#include "hdf_config_test.h" #include "hdf_device_desc.h" +#include "hdf_log.h" #include "hdf_main_test.h" #include "osal_test_entry.h" @@ -17,15 +17,27 @@ #if defined(LOSCFG_DRIVERS_HDF_PLATFORM_GPIO) || defined(CONFIG_DRIVERS_HDF_PLATFORM_GPIO) #include "hdf_gpio_entry_test.h" #endif +#if defined(LOSCFG_DRIVERS_HDF_PLATFORM_PIN) || defined(CONFIG_DRIVERS_HDF_PLATFORM_PIN) +#include "hdf_pin_entry_test.h" +#endif #if defined(LOSCFG_DRIVERS_HDF_PLATFORM_I2C) || defined(CONFIG_DRIVERS_HDF_PLATFORM_I2C) #include "hdf_i2c_entry_test.h" #endif #if defined(LOSCFG_DRIVERS_HDF_PLATFORM_I2S) || defined(CONFIG_DRIVERS_HDF_PLATFORM_I2S) #include "hdf_i2s_entry_test.h" #endif +#if defined(LOSCFG_DRIVERS_HDF_PLATFORM_REGULATOR) || defined(CONFIG_DRIVERS_HDF_PLATFORM_REGULATOR) +#include "hdf_regulator_entry_test.h" +#endif #if defined(LOSCFG_DRIVERS_HDF_PLATFORM_ADC) || defined(CONFIG_DRIVERS_HDF_PLATFORM_ADC) #include "hdf_adc_entry_test.h" #endif +#if defined(LOSCFG_DRIVERS_HDF_PLATFORM_DAC) || defined(CONFIG_DRIVERS_HDF_PLATFORM_DAC) +#include "hdf_dac_entry_test.h" +#endif +#if defined(LOSCFG_DRIVERS_HDF_PLATFORM_I3C) || defined(CONFIG_DRIVERS_HDF_PLATFORM_I3C) +#include "hdf_i3c_entry_test.h" +#endif #if defined(LOSCFG_DRIVERS_HDF_PLATFORM_SPI) || defined(CONFIG_DRIVERS_HDF_PLATFORM_SPI) #include "hdf_spi_entry_test.h" #endif @@ -44,6 +56,9 @@ #if defined(LOSCFG_DRIVERS_HDF_PLATFORM_MIPI_DSI) || defined(CONFIG_DRIVERS_HDF_PLATFORM_MIPI_DSI) #include "hdf_mipi_dsi_entry_test.h" #endif +#if defined(LOSCFG_DRIVERS_HDF_PLATFORM_MIPI_CSI) || defined(CONFIG_DRIVERS_HDF_PLATFORM_MIPI_CSI) +#include "hdf_mipi_csi_entry_test.h" +#endif #if (defined(LOSCFG_STORAGE_EMMC) && defined(LOSCFG_DRIVERS_HDF_PLATFORM_EMMC)) || \ defined(CONFIG_DRIVERS_HDF_PLATFORM_EMMC) #include "hdf_emmc_entry_test.h" @@ -57,6 +72,7 @@ #endif #if defined(LOSCFG_DRIVERS_HDF_AUDIO_TEST) || defined(CONFIG_DRIVERS_HDF_AUDIO_TEST) #include "hdf_audio_test.h" +#include "hdf_audio_driver_test.h" #endif #if defined(LOSCFG_DRIVERS_HDF_USB_DDK_DEVICE) || defined(CONFIG_DRIVERS_HDF_USB_DDK_DEVICE) #include "hdf_usb_device_test.h" @@ -73,15 +89,27 @@ HdfTestFuncList g_hdfTestFuncList[] = { #if defined(LOSCFG_DRIVERS_HDF_PLATFORM_GPIO) || defined(CONFIG_DRIVERS_HDF_PLATFORM_GPIO) { TEST_PAL_GPIO_TYPE, HdfGpioTestEntry }, #endif +#if defined(LOSCFG_DRIVERS_HDF_PLATFORM_PIN) || defined(CONFIG_DRIVERS_HDF_PLATFORM_PIN) + { TEST_PAL_PIN_TYPE, HdfPinTestEntry }, +#endif #if defined(LOSCFG_DRIVERS_HDF_PLATFORM_I2C) || defined(CONFIG_DRIVERS_HDF_PLATFORM_I2C) { TEST_PAL_I2C_TYPE, HdfI2cTestEntry }, #endif #if defined(LOSCFG_DRIVERS_HDF_PLATFORM_I2S) || defined(CONFIG_DRIVERS_HDF_PLATFORM_I2S) - { TEST_PAL_I2S_TYPE, HdfI2sUnitTestEntry }, + { TEST_PAL_I2S_TYPE, HdfI2sUnitTestEntry }, +#endif +#if defined(LOSCFG_DRIVERS_HDF_PLATFORM_REGULATOR) || defined(CONFIG_DRIVERS_HDF_PLATFORM_REGULATOR) + { TEST_PAL_REGULATOR_TYPE, HdfRegulatorUnitTestEntry }, #endif #if defined(LOSCFG_DRIVERS_HDF_PLATFORM_ADC) || defined(CONFIG_DRIVERS_HDF_PLATFORM_ADC) { TEST_PAL_ADC_TYPE, HdfAdcTestEntry }, #endif +#if defined(LOSCFG_DRIVERS_HDF_PLATFORM_DAC) || defined(CONFIG_DRIVERS_HDF_PLATFORM_DAC) + { TEST_PAL_DAC_TYPE, HdfDacTestEntry }, +#endif +#if defined(LOSCFG_DRIVERS_HDF_PLATFORM_I3C) || defined(CONFIG_DRIVERS_HDF_PLATFORM_I3C) + { TEST_PAL_I3C_TYPE, HdfI3cTestEntry }, +#endif #if defined(LOSCFG_DRIVERS_HDF_PLATFORM_SPI) || defined(CONFIG_DRIVERS_HDF_PLATFORM_SPI) { TEST_PAL_SPI_TYPE, HdfSpiUnitTestEntry }, #endif @@ -97,6 +125,9 @@ HdfTestFuncList g_hdfTestFuncList[] = { #if defined(LOSCFG_DRIVERS_HDF_PLATFORM_MIPI_DSI) || defined(CONFIG_DRIVERS_HDF_PLATFORM_MIPI_DSI) { TEST_PAL_MIPI_DSI_TYPE, HdfMipiDsiEntry }, #endif +#if defined(LOSCFG_DRIVERS_HDF_PLATFORM_MIPI_CSI) || defined(CONFIG_DRIVERS_HDF_PLATFORM_MIPI_CSI) + { TEST_PAL_MIPI_CSI_TYPE, HdfMipiCsiEntry }, +#endif #if defined(LOSCFG_DRIVERS_HDF_PLATFORM_SDIO) || defined(CONFIG_DRIVERS_HDF_PLATFORM_SDIO) { TEST_PAL_SDIO_TYPE, HdfSdioUnitTestEntry }, #endif @@ -115,6 +146,7 @@ HdfTestFuncList g_hdfTestFuncList[] = { #endif #if defined(LOSCFG_DRIVERS_HDF_AUDIO_TEST) || defined(CONFIG_DRIVERS_HDF_AUDIO_TEST) {TEST_AUDIO_TYPE, HdfAudioEntry}, + {TEST_AUDIO_DRIVER_TYPE, HdfAudioDriverEntry}, #endif #if defined(LOSCFG_DRIVERS_HDF_USB_DDK_DEVICE) || defined(CONFIG_DRIVERS_HDF_USB_DDK_DEVICE) {TEST_USB_DEVICE_TYPE, HdfUsbDeviceEntry}, @@ -190,13 +222,14 @@ void HdfTestDriverDispatch(struct HdfDeviceObject *device) int HdfTestDriverBind(struct HdfDeviceObject *device) { + static struct TestService testService; + if (device == NULL) { return -1; } - static struct TestService testService = { - .testRemoteService.Dispatch = HdfTestCaseProcess, - }; + testService.testRemoteService.Dispatch = HdfTestCaseProcess; + device->service = &testService.testRemoteService; return 0; } diff --git a/test/unittest/common/hdf_main_test.h b/test/unittest/common/hdf_main_test.h index c54969825d0b141e8a7a7bf9943e14df7d416fb4..173b2294b4183daeac8d21c2b2bcb825ca44ea16 100644 --- a/test/unittest/common/hdf_main_test.h +++ b/test/unittest/common/hdf_main_test.h @@ -38,7 +38,7 @@ typedef enum { TEST_PAL_I2C_TYPE = 0, TEST_PAL_SPI_TYPE = 1, TEST_PAL_GPIO_TYPE = 2, - TEST_PAL_PINCTRL_TYPE = 3, + TEST_PAL_PIN_TYPE = 3, TEST_PAL_CLOCK_TYPE = 4, TEST_PAL_REGULATOR_TYPE = 5, TEST_PAL_MIPI_DSI_TYPE = 6, @@ -58,6 +58,8 @@ typedef enum { TEST_PAL_ADC_TYPE = 20, TEST_PAL_WDT_TYPE = 21, TEST_PAL_I3C_TYPE = 22, + TEST_PAL_MIPI_CSI_TYPE = 23, + TEST_PAL_DAC_TYPE = 24, TEST_PAL_END = 200, TEST_OSAL_BEGIN = TEST_PAL_END, #define HDF_OSAL_TEST_ITEM(v) (TEST_OSAL_BEGIN + (v)) @@ -68,6 +70,7 @@ typedef enum { TEST_WIFI_END = 600, TEST_CONFIG_TYPE = 601, TEST_AUDIO_TYPE = 701, + TEST_AUDIO_DRIVER_TYPE = TEST_AUDIO_TYPE + 1, TEST_HDF_FRAME_END = 800, TEST_USB_DEVICE_TYPE = 900, TEST_USB_HOST_TYPE = 1000, diff --git a/test/unittest/include/hdf_uhdf_test.h b/test/unittest/include/hdf_uhdf_test.h index 0c22f0cb934afcfb324b4bf5c9ed0129b3b1d08c..8dcc54f65f6150c93e52f5219f6dfd086df74604 100644 --- a/test/unittest/include/hdf_uhdf_test.h +++ b/test/unittest/include/hdf_uhdf_test.h @@ -34,7 +34,7 @@ enum HdfTestSubModuleCmd { TEST_PAL_I2C_TYPE = 0, TEST_PAL_SPI_TYPE = 1, TEST_PAL_GPIO_TYPE = 2, - TEST_PAL_PINCTRL_TYPE = 3, + TEST_PAL_PIN_TYPE = 3, TEST_PAL_CLOCK_TYPE = 4, TEST_PAL_REGULATOR_TYPE = 5, TEST_PAL_MIPI_DSI_TYPE = 6, @@ -54,11 +54,13 @@ enum HdfTestSubModuleCmd { TEST_PAL_ADC_TYPE = 20, TEST_PAL_WDT_TYPE = 21, TEST_PAL_I3C_TYPE = 22, + TEST_PAL_MIPI_CSI_TYPE = 23, + TEST_PAL_DAC_TYPE = 24, TEST_PAL_END = 200, TEST_OSAL_BEGIN = TEST_PAL_END, #define HDF_OSAL_TEST_ITEM(v) (TEST_OSAL_BEGIN + (v)) TEST_OSAL_ITEM = HDF_OSAL_TEST_ITEM(1), - TEST_OSAL_END = 400, + TEST_OSAL_END = 400, TEST_WIFI_BEGIN = TEST_OSAL_END, TEST_WIFI_TYPE = TEST_WIFI_BEGIN + 1, TEST_WIFI_END = 600, @@ -77,4 +79,4 @@ int HdfTestSendMsgToService(struct HdfTestMsg *msg); } #endif /* __cplusplus */ -#endif // HDF_UHDF_TEST_H \ No newline at end of file +#endif // HDF_UHDF_TEST_H diff --git a/test/unittest/manager/sample_driver_test.c b/test/unittest/manager/sample_driver_test.c index 609787660c183f625dcb29173c005a279ed884e8..deb89265635449e768f0ad8b9b0d1bbbf3bb6f51 100644 --- a/test/unittest/manager/sample_driver_test.c +++ b/test/unittest/manager/sample_driver_test.c @@ -6,11 +6,13 @@ * See the LICENSE file in the root of this repository for complete details. */ #include "sample_driver_test.h" -#include "devsvc_manager_clnt.h" #include "devmgr_service.h" +#include "devsvc_manager_clnt.h" +#include "hdf_device_object.h" #include "hdf_log.h" -#include "hdf_device_desc.h" #include "hdf_pm.h" +#include "osal_file.h" +#include "osal_mem.h" #define HDF_LOG_TAG sample_driver_test @@ -18,49 +20,129 @@ #define INT32_MAX 0x7fffffff #endif +struct SampleTestDevice { + struct DListHead listNode; + struct HdfDeviceObject *devobj; +}; + +struct DListHead g_sampleDeviceList = { NULL }; + +#define REGISTER_DEV_MAX 16 +struct HdfDeviceObject *g_resistedDevice[REGISTER_DEV_MAX] = { 0 }; + +static void SaveRegistedDevice(struct SampleTestDevice *sampleDev) +{ + if (g_sampleDeviceList.next == NULL) { + DListHeadInit(&g_sampleDeviceList); + } + DListInsertTail(&sampleDev->listNode, &g_sampleDeviceList); +} + +struct SampleTestDevice *GetRegistedDevice(const char *serviceName) +{ + struct SampleTestDevice *sampleDev = NULL; + struct SampleTestDevice *sampleDevTmp = NULL; + DLIST_FOR_EACH_ENTRY_SAFE(sampleDev, sampleDevTmp, &g_sampleDeviceList, struct SampleTestDevice, listNode) { + if (sampleDev->devobj == NULL || HdfDeviceGetServiceName(sampleDev->devobj) == NULL) { + DListRemove(&sampleDev->listNode); + OsalMemFree(sampleDev); + continue; + } + + if (strcmp(HdfDeviceGetServiceName(sampleDev->devobj), serviceName) == 0) { + return sampleDev; + } + } + + return NULL; +} + void HdfSampleDriverRelease(struct HdfDeviceObject *deviceObject) { (void)deviceObject; return; } -int32_t SampleDriverRegisterDevice(struct HdfSBuf *data) +int32_t SampleDriverRegisterDevice(struct HdfDeviceObject *dev, struct HdfSBuf *data) { + const char *moduleName = NULL; + const char *serviceName = NULL; + struct HdfDeviceObject *devObj = NULL; + struct SampleTestDevice *sampleDev = NULL; + int ret; + + HDF_LOGI("%s:called", __func__); if (data == NULL) { return HDF_FAILURE; } - const char *moduleName = HdfSbufReadString(data); + moduleName = HdfSbufReadString(data); if (moduleName == NULL) { return HDF_FAILURE; } - const char *serviceName = HdfSbufReadString(data); + serviceName = HdfSbufReadString(data); if (serviceName == NULL) { return HDF_FAILURE; } - struct HdfDeviceObject *devObj = HdfRegisterDevice(moduleName, serviceName, NULL); + devObj = HdfDeviceObjectAlloc(dev, moduleName); if (devObj == NULL) { + HDF_LOGE("faild to alloc new device for %s", moduleName); return HDF_FAILURE; } - return HDF_SUCCESS; + + ret = HdfDeviceObjectRegister(devObj); + if (ret != HDF_SUCCESS) { + HDF_LOGE("faild to register device for %s", moduleName); + HdfDeviceObjectRelease(devObj); + return HDF_FAILURE; + } + + ret = HdfDeviceObjectPublishService(devObj, serviceName, SERVICE_POLICY_CAPACITY, + OSAL_S_IREAD | OSAL_S_IWRITE | OSAL_S_IRGRP | OSAL_S_IWGRP | OSAL_S_IROTH); + if (ret != HDF_SUCCESS) { + HDF_LOGE("faild to publish service for %s", serviceName); + HdfDeviceObjectRelease(devObj); + return ret; + } + + sampleDev = OsalMemAlloc(sizeof(struct SampleTestDevice)); + if (sampleDev == NULL) { + HdfDeviceObjectRelease(devObj); + return HDF_ERR_MALLOC_FAIL; + } + sampleDev->devobj = devObj; + SaveRegistedDevice(sampleDev); + HDF_LOGI("register device %s:%s success", moduleName, serviceName); + return ret; } int32_t SampleDriverUnregisterDevice(struct HdfSBuf *data) { + const char *moduleName = NULL; + const char *serviceName = NULL; + struct SampleTestDevice *dev = NULL; if (data == NULL) { return HDF_FAILURE; } - const char *moduleName = HdfSbufReadString(data); + moduleName = HdfSbufReadString(data); if (moduleName == NULL) { return HDF_FAILURE; } - const char *serviceName = HdfSbufReadString(data); + serviceName = HdfSbufReadString(data); if (serviceName == NULL) { return HDF_FAILURE; } - HdfUnregisterDevice(moduleName, serviceName); + dev = GetRegistedDevice(serviceName); + if (dev == NULL) { + HDF_LOGE("failed to found device %s", serviceName); + return HDF_DEV_ERR_NO_DEVICE; + } + HdfDeviceObjectRelease(dev->devobj); + DListRemove(&dev->listNode); + OsalMemFree(dev); + HDF_LOGI("unregister device %s:%s success", moduleName, serviceName); return HDF_SUCCESS; } @@ -71,26 +153,45 @@ int32_t SampleDriverSendEvent(struct HdfDeviceIoClient *client, int id, struct H int32_t SampleDriverPowerStateInject(uint32_t powerState) { + int ret; struct IDevmgrService *devmgrService = DevmgrServiceGetInstance(); if (devmgrService == NULL || devmgrService->PowerStateChange == NULL) { return HDF_ERR_INVALID_OBJECT; } - int ret = devmgrService->PowerStateChange(devmgrService, powerState); + ret = devmgrService->PowerStateChange(devmgrService, powerState); HDF_LOGI("%s: inject power state(%d) done, ret = %d", __func__, powerState, ret); return ret; } +int32_t SampleDriverUpdateService(struct HdfDeviceIoClient *client, struct HdfSBuf *data) +{ + const char *servInfo = HdfSbufReadString(data); + int32_t ret; + if (servInfo == NULL) { + HDF_LOGE("%s: miss servce info", __func__); + return HDF_ERR_INVALID_PARAM; + } + + if(HdfDeviceObjectSetServInfo(client->device, servInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: failed to set servce info", __func__); + return HDF_ERR_INVALID_PARAM; + } + ret = HdfDeviceObjectUpdate(client->device); + HDF_LOGE("%s:set servce info done, ret = %d", __func__, ret); + return ret; +} + int32_t SampleDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) { + uint32_t powerState = 0; int32_t ret = HDF_SUCCESS; if (reply == NULL || client == NULL) { return HDF_FAILURE; } - uint32_t powerState = 0; switch (cmdId) { case SAMPLE_DRIVER_REGISTER_DEVICE: { - ret = SampleDriverRegisterDevice(data); + ret = SampleDriverRegisterDevice(client->device, data); HdfSbufWriteInt32(reply, ret); break; } @@ -98,8 +199,11 @@ int32_t SampleDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct ret = SampleDriverUnregisterDevice(data); HdfSbufWriteInt32(reply, ret); break; + case SAMPLE_DRIVER_UPDATE_SERVICE_INFO: + ret = SampleDriverUpdateService(client, data); + break; case SAMPLE_DRIVER_SENDEVENT_SINGLE_DEVICE: - ret = SampleDriverSendEvent(client, cmdId, data, false); + ret = SampleDriverSendEvent(client, cmdId, data, false); HdfSbufWriteInt32(reply, INT32_MAX); break; case SAMPLE_DRIVER_SENDEVENT_BROADCAST_DEVICE: @@ -118,15 +222,16 @@ int32_t SampleDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct int HdfSampleDriverBind(struct HdfDeviceObject *deviceObject) { - HDF_LOGD("%s::enter", __func__); - if (deviceObject == NULL) { - return HDF_FAILURE; - } static struct IDeviceIoService testService = { .Dispatch = SampleDriverDispatch, .Open = NULL, .Release = NULL, }; + HDF_LOGD("%s::enter", __func__); + if (deviceObject == NULL) { + return HDF_FAILURE; + } + deviceObject->service = &testService; return HDF_SUCCESS; } @@ -162,26 +267,26 @@ struct SampleDriverPmListener { int HdfSampleDriverInit(struct HdfDeviceObject *deviceObject) { + static struct SampleDriverPmListener pmListener = { 0 }; + int ret; HDF_LOGI("%s::enter!", __func__); if (deviceObject == NULL) { HDF_LOGE("%s::ptr is null!", __func__); return HDF_FAILURE; } HDF_LOGD("%s:Init success", __func__); - - static struct SampleDriverPmListener pmListener = {0}; + HdfDeviceObjectSetServInfo(deviceObject, SAMPLE_SERVICE); pmListener.powerListener.DozeResume = HdfSampleDozeResume; pmListener.powerListener.DozeSuspend = HdfSampleDozeSuspend; pmListener.powerListener.Resume = HdfSampleResume; pmListener.powerListener.Suspend = HdfSampleSuspend; - int ret = HdfPmRegisterPowerListener(deviceObject, &pmListener.powerListener); + ret = HdfPmRegisterPowerListener(deviceObject, &pmListener.powerListener); HDF_LOGI("%s:register power listener, ret = %d", __func__, ret); return HDF_SUCCESS; } - struct HdfDriverEntry g_sampleDriverEntry = { .moduleVersion = 1, .moduleName = "sample_driver", diff --git a/test/unittest/manager/sample_driver_test.h b/test/unittest/manager/sample_driver_test.h index a2ce58f499492f29c7cc25a3ce96825958d1d85a..25eba3bb517060e94b93f9265adba5c246dbfdc5 100644 --- a/test/unittest/manager/sample_driver_test.h +++ b/test/unittest/manager/sample_driver_test.h @@ -16,6 +16,7 @@ typedef enum { SAMPLE_DRIVER_REGISTER_DEVICE = 0, SAMPLE_DRIVER_UNREGISTER_DEVICE, + SAMPLE_DRIVER_UPDATE_SERVICE_INFO, SAMPLE_DRIVER_SENDEVENT_SINGLE_DEVICE, SAMPLE_DRIVER_SENDEVENT_BROADCAST_DEVICE, SAMPLE_DRIVER_PM_STATE_INJECT, diff --git a/test/unittest/model/audio/include/audio_accessory_base_test.h b/test/unittest/model/audio/include/audio_accessory_base_test.h new file mode 100644 index 0000000000000000000000000000000000000000..b717401cbd0a91355cf1ce9c6e76288752c32db9 --- /dev/null +++ b/test/unittest/model/audio/include/audio_accessory_base_test.h @@ -0,0 +1,38 @@ +/* + * Copyright (c) 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 AUDIO_ACCESSORY_BASE_TEST_H +#define AUDIO_ACCESSORY_BASE_TEST_H + +#include "hdf_types.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +int32_t AccessoryI2cReadWriteTest(void); +int32_t AccessoryRegBitsReadTest(void); +int32_t AccessoryRegBitsUpdateTest(void); + +int32_t AcessoryDeviceFrequencyParseTest(void); +int32_t AccessoryDaiParamsUpdateTest(void); +int32_t AccessoryDeviceCfgGetTest(void); +int32_t AccessoryDeviceCtrlRegInitTest(void); +int32_t AccessoryDeviceRegReadTest(void); +int32_t AccessoryDeviceRegWriteTest(void); +int32_t AccessoryGetConfigInfoTest(void); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* AUDIO_ACCESSORY_BASE_TEST_H */ diff --git a/test/unittest/model/audio/include/audio_codec_base_test.h b/test/unittest/model/audio/include/audio_codec_base_test.h new file mode 100644 index 0000000000000000000000000000000000000000..c91aa271fb99a1ef24353f0bd2fa4add2c098d1c --- /dev/null +++ b/test/unittest/model/audio/include/audio_codec_base_test.h @@ -0,0 +1,32 @@ +/* + * Copyright (c) 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 AUDIO_CODEC_BASE_TEST_H +#define AUDIO_CODEC_BASE_TEST_H + +#include "hdf_types.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +int32_t CodecGetServiceNameTest(void); +int32_t CodecGetDaiNameTest(void); +int32_t CodecGetConfigInfoTest(void); +int32_t CodecSetConfigInfoTest(void); +int32_t CodecSetCtlFuncTest(void); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* AUDIO_CODEC_BASE_TEST_H */ diff --git a/test/unittest/model/audio/include/audio_core_test.h b/test/unittest/model/audio/include/audio_core_test.h index b36a9f99cfa48e80826fda647da5128c703325b0..5f4b72a1e14fe03a193c1b47a2b3c00c9a76512f 100755 --- a/test/unittest/model/audio/include/audio_core_test.h +++ b/test/unittest/model/audio/include/audio_core_test.h @@ -17,25 +17,39 @@ extern "C" { #endif #endif /* __cplusplus */ -int32_t AudioSocTestRegisterDai(void); -int32_t AudioSocTestRegisterPlatform(void); -int32_t AudioTestRegisterCodec(void); -int32_t AudioTestBindDaiLink(void); -int32_t AudioTestSocDeviceRegister(void); -int32_t AudioTestSocRegisterDsp(void); -int32_t AudioTestRegisterAccessory(void); -int32_t AudioTestUpdateRegBits(void); -int32_t AudioTestAiaoUpdateRegBits(void); -int32_t AudioTestKcontrolGetCodec(void); -int32_t AudioTestAddControls(void); -int32_t AudioTestAddControl(void); -int32_t AudioTestDeviceReadReg(void); -int32_t AudioTestAiaoDeviceReadReg(void); -int32_t AudioTestInfoCtrlSw(void); -int32_t AudioTestGetCtrlSw(void); -int32_t AudioTestPutCtrlSw(void); -int32_t AiaoTestGetCtrlSw(void); -int32_t AiaoTestPutCtrlSw(void); +int32_t AudioDeviceReadRegTest(void); +int32_t AudioDeviceWriteRegTest(void); +int32_t AudioSocRegisterPlatformTest(void); +int32_t AudioSocRegisterDaiTest(void); +int32_t AudioRegisterDspTest(void); +int32_t AudioRegisterCodecTest(void); +int32_t AudioRegisterAccessoryTest(void); +int32_t AudioBindDaiLinkTest(void); +int32_t AudioUpdateCodecRegBitsTest(void); +int32_t AudioUpdateAccessoryRegBitsTest(void); +int32_t AudioUpdateDaiRegBitsTest(void); +int32_t AudioKcontrolGetCpuDaiTest(void); +int32_t AudioKcontrolGetCodecTest(void); +int32_t AudioKcontrolGetAccessoryTest(void); +int32_t AudioAddControlsTest(void); +int32_t AudioAddControlTest(void); +int32_t AudioGetCtrlOpsRRegTest(void); +int32_t AudioGetCtrlOpsRegTest(void); +int32_t AudioSetCtrlOpsRegTest(void); +int32_t AudioSetCtrlOpsRRegTest(void); +int32_t AudioDaiReadRegTest(void); +int32_t AudioDaiWriteRegTest(void); +int32_t AudioCodecReadRegTest(void); +int32_t AudioCodecWriteRegTest(void); +int32_t AudioAccessoryReadRegTest(void); +int32_t AudioAccessoryWriteRegTest(void); +int32_t AudioInfoCtrlOpsTest(void); +int32_t AudioCodecGetCtrlOpsTest(void); +int32_t AudioCodecSetCtrlOpsTest(void); +int32_t AudioAccessoryGetCtrlOpsTest(void); +int32_t AudioAccessorySetCtrlOpsTset(void); +int32_t AudioCpuDaiSetCtrlOpsTest(void); +int32_t AudioCpuDaiGetCtrlOpsTest(void); #ifdef __cplusplus #if __cplusplus diff --git a/model/storage/include/common/storage.h b/test/unittest/model/audio/include/audio_dai_base_test.h similarity index 53% rename from model/storage/include/common/storage.h rename to test/unittest/model/audio/include/audio_dai_base_test.h index d85a4a25955227ad1df346fd14d287ca95a979fd..ce1e0d4a07987219f5765fef5a954be8ad8ff485 100644 --- a/model/storage/include/common/storage.h +++ b/test/unittest/model/audio/include/audio_dai_base_test.h @@ -1,15 +1,15 @@ /* - * Copyright (c) 2020-2021 Huawei Device Co., Ltd. + * Copyright (c) 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 STORAGE_H -#define STORAGE_H +#ifndef AUDIO_DAI_BASE_TEST_H +#define AUDIO_DAI_BASE_TEST_H -#include "hdf_base.h" +#include "hdf_types.h" #ifdef __cplusplus #if __cplusplus @@ -17,13 +17,10 @@ extern "C" { #endif #endif /* __cplusplus */ -#define STORAGE_MAX_BYTES ((size_t)(-1)) - -enum StorageType { - MEDIA_MMC = 0, - MEDIA_MTD = 1, - MEDIA_ERR = 2, -}; +int32_t DaiDataFromCardTest(void); +int32_t DaiGetConfigInfoTest(void); +int32_t DaiCheckSampleRateTest(void); +int32_t DaiSetConfigInfoTest(void); #ifdef __cplusplus #if __cplusplus @@ -31,4 +28,4 @@ enum StorageType { #endif #endif /* __cplusplus */ -#endif /* STORAGE_H */ +#endif /* AUDIO_DAI_BASE_TEST_H */ diff --git a/test/unittest/model/audio/include/audio_dma_base_test.h b/test/unittest/model/audio/include/audio_dma_base_test.h new file mode 100644 index 0000000000000000000000000000000000000000..84cb7f95a2632c6f8dabcc421ebdbef3aa2f3c5a --- /dev/null +++ b/test/unittest/model/audio/include/audio_dma_base_test.h @@ -0,0 +1,37 @@ +/* + * Copyright (c) 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 AUDIO_DMA_BASE_TEST_H +#define AUDIO_DMA_BASE_TEST_H + +#include "hdf_types.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +int32_t AudioDmaBufAllocTest(void); +int32_t AudioDmaBufFreeTest(void); +int32_t AudioDmaRequestChannelTest(void); +int32_t AudioDmaConfigChannelTest(void); +int32_t AudioDmaPrepTest(void); +int32_t AudioDmaSubmitTest(void); +int32_t AudioDmaPendingTest(void); +int32_t AudioDmaPauseTest(void); +int32_t AudioDmaResumeTest(void); +int32_t AudioDmaPointerTest(void); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* AUDIO_DMA_BASE_TEST_H */ diff --git a/test/unittest/model/audio/include/audio_stream_dispatch_test.h b/test/unittest/model/audio/include/audio_dsp_base_test.h old mode 100755 new mode 100644 similarity index 61% rename from test/unittest/model/audio/include/audio_stream_dispatch_test.h rename to test/unittest/model/audio/include/audio_dsp_base_test.h index 5891ff424001ff300b290f18d823c805c2bbcc67..3a30a0d7f242e0ead5c640bf3c50fc5938faf7b8 --- a/test/unittest/model/audio/include/audio_stream_dispatch_test.h +++ b/test/unittest/model/audio/include/audio_dsp_base_test.h @@ -6,24 +6,24 @@ * See the LICENSE file in the root of this repository for complete details. */ -#ifndef AUDIO_STREAM_DISPATCH_TEST_H -#define AUDIO_STREAM_DISPATCH_TEST_H +#ifndef AUDIO_DSP_BASE_TEST_H +#define AUDIO_DSP_BASE_TEST_H #include "hdf_types.h" #ifdef __cplusplus #if __cplusplus -extern "C" -{ +extern "C" { #endif -#endif -int32_t AudioControlDispatchTestStreamDispatch(void); -int32_t AudioControlDispatchTestStreamHostDestroy(void); +#endif /* __cplusplus */ + +int32_t DspGetServiceNameTest(void); +int32_t DspGetDaiNameTest(void); #ifdef __cplusplus #if __cplusplus } #endif -#endif +#endif /* __cplusplus */ -#endif +#endif /* AUDIO_DSP_BASE_TEST_H */ diff --git a/test/unittest/model/audio/include/audio_host_test.h b/test/unittest/model/audio/include/audio_host_test.h index 42160326ba08daac6758c8ce86cca714f1ec50d5..c4e88e6dd4f0f2a0513ff0ca71595e700c244786 100755 --- a/test/unittest/model/audio/include/audio_host_test.h +++ b/test/unittest/model/audio/include/audio_host_test.h @@ -17,9 +17,8 @@ extern "C" { #endif #endif /* __cplusplus */ -int32_t AudioKcontrolTestGetCodec(void); -int32_t GetCardTestInstance(void); -int32_t AudioHostTestDestroy(void); +int32_t AudioHostCreateAndBindTest(void); +int32_t GetCardInstanceTest(void); #ifdef __cplusplus #if __cplusplus diff --git a/test/unittest/model/audio/include/audio_parse_test.h b/test/unittest/model/audio/include/audio_parse_test.h index 1e070050b6c562f79873c604562b9fb56d5dee6f..30aa734439fa0a5ecc4c49699de06c905acd5058 100755 --- a/test/unittest/model/audio/include/audio_parse_test.h +++ b/test/unittest/model/audio/include/audio_parse_test.h @@ -17,7 +17,8 @@ extern "C" { #endif #endif /* __cplusplus */ -int32_t AudioFillTestConfigData(void); +int32_t AudioFillConfigDataTest(void); +int32_t CodecGetRegConfigTest(void); #ifdef __cplusplus #if __cplusplus diff --git a/test/unittest/model/audio/include/audio_platform_base_test.h b/test/unittest/model/audio/include/audio_platform_base_test.h new file mode 100644 index 0000000000000000000000000000000000000000..f88a37be7e391cf9a6527a63cfa78d93b8ff6248 --- /dev/null +++ b/test/unittest/model/audio/include/audio_platform_base_test.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 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 AUDIO_PLATFORM_BASE_TEST_H +#define AUDIO_PLATFORM_BASE_TEST_H + +#include "hdf_types.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +int32_t PlatformDataFromCardTest(void); +int32_t AudioBytesToFramesTest(void); +int32_t AudioDataBigEndianChangeTest(void); +int32_t AudioFramatToBitWidthTest(void); +int32_t AudioSetPcmInfoTest(void); +int32_t AudioSetRenderBufInfoTest(void); +int32_t AudioSetCaptureBufInfoTest(void); +int32_t AudioPcmWriteTest(void); +int32_t AudioPcmReadTest(void); +int32_t AudioPcmMmapWriteTest(void); +int32_t AudioPcmMmapReadTest(void); +int32_t AudioRenderOpenTest(void); +int32_t AudioCaptureOpenTest(void); +int32_t AudioRenderCloseTest(void); +int32_t AudioPcmPointerTest(void); +int32_t AudioCaptureCloseTest(void); +int32_t AudioHwParamsTest(void); +int32_t AudioRenderPrepareTest(void); +int32_t AudioCapturePrepareTest(void); +int32_t AudioRenderTriggerTest(void); +int32_t AudioCaptureTriggerTest(void); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* AUDIO_PLATFORM_BASE_TEST_H */ diff --git a/test/unittest/model/audio/include/audio_sapm_test.h b/test/unittest/model/audio/include/audio_sapm_test.h index f3666c028e4766b712c9cb8566109037694027e5..3248b323135e4df25ac6b7c11dbaba7565b367f7 100755 --- a/test/unittest/model/audio/include/audio_sapm_test.h +++ b/test/unittest/model/audio/include/audio_sapm_test.h @@ -17,11 +17,17 @@ extern "C" { #endif #endif -int32_t AudioSapmTestNewComponents(void); -int32_t AudioSapmTestAddRoutes(void); -int32_t AudioSapmTestNewControls(void); -int32_t AudioSapmTestPowerComponents(void); -int32_t AudioSapmTestRefreshTime(void); + +int32_t AudioSapmNewComponentsTest(void); +int32_t AudioSapmAddRoutesTest(void); +int32_t AudioSapmNewControlsTest(void); +int32_t AudioSapmSleepTest(void); +int32_t AudioSampPowerUpTest(void); +int32_t AudioSampSetPowerMonitorTest(void); +int32_t AudioCodecSapmSetCtrlOpsTest(void); +int32_t AudioCodecSapmGetCtrlOpsTest(void); +int32_t AudioAccessorySapmSetCtrlOpsTest(void); +int32_t AudioAccessorySapmGetCtrlOpsTest(void); #ifdef __cplusplus #if __cplusplus diff --git a/test/unittest/model/audio/include/hdf_audio_test.h b/test/unittest/model/audio/include/hdf_audio_test.h index 36a3f34de05166d1cc05ca14c66eba382227a499..572998e1b2294639a0f44f7884cc381d35ae0003 100755 --- a/test/unittest/model/audio/include/hdf_audio_test.h +++ b/test/unittest/model/audio/include/hdf_audio_test.h @@ -18,36 +18,114 @@ extern "C" { #endif /* __cplusplus */ typedef enum { - AUDIO_DRIVER_TESTGETCODEC, - AUDIO_DRIVER_TESTGETCARDINSTANCE, - AUDIO_DRIVER_TESTHOSTDESTROY, - AUDIO_DRIVER_TESTGETCCNFIGDATA, - AUDIO_DRIVER_TESTREGISTERDAI, - AUDIO_DRIVER_TESTREGISTERPLATFORM, - AUDIO_DRIVER_TESTREGISTERCODEC, - AUDIO_DRIVER_TESTBINDDAILINK, - AUDIO_DRIVER_TESTDEVICEREGISTER, - AUDIO_DRIVER_TESTREGISTERDSP, - AUDIO_DRIVER_TESTREGISTERACCESSORY, - AUDIO_DRIVER_TESTUPDATEREGBITS, - AUDIO_DRIVER_TESTAIAOUPDATEREGBITS, - AUDIO_DRIVER_TESTKCONTROLGETCODEC, - AUDIO_DRIVER_TESTADDCONTROLS, - AUDIO_DRIVER_TESTADDCONTROL, - AUDIO_DRIVER_TESTDEVICEREADREG, - AUDIO_DRIVER_TESTAIAODEVICEREADREG, - AUDIO_DRIVER_TESTINFOCTRLSW, - AUDIO_DRIVER_TESTGETCTRLSW, - AUDIO_DRIVER_TESTPUTCTRLSW, - AUDIO_DRIVER_TESTAIAOGETCTRLSW, - AUDIO_DRIVER_TESTAIAOPUTCTRLSW, - AUDIO_DRIVER_TESTNEWCOMPONENT, - AUDIO_DRIVER_TESTADDROUTES, - AUDIO_DRIVER_TESTNEWCONTROLS, - AUDIO_DRIVER_TESTPOWERCOMPONET, - AUDIO_DRIVER_TESTREFRESHTIME, - AUDIO_DRIVER_TESTSTREAMDISPATCH, - AUDIO_DRIVER_TESTSTREAMDESTORY, + AUDIO_ADM_TEST_AUDIOHOSTCREATEANDBIND = 1, // audio ADM audio_host + AUDIO_ADM_TEST_GETCARDINSTANCE = 2, // audio ADM audio_host + + AUDIO_ADM_TEST_AUDIOFILLCONFIGDATA = 3, // audio ADM audio_parse + AUDIO_ADM_TEST_CODECGETREGCONFIG = 4, // audio ADM audio_parse + + AUDIO_ADM_TEST_AUDIODEVICEREADREG = 5, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIODEVICEWRITEREG, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOSOCREGISTERPLATFORM, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOSOCREGISTERDAI, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOREGISTERDSP, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOREGISTERCODEC, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOREGISTERACCESSORY, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOBINDDAILINK, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOUPDATECODECREGBITS, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOUPDATEACCESSORYREGBITS, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOUPDATEDAIREGBITS, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOKCONTROLGETCPUDAI, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOKCONTROLGETCODEC, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOKCONTROLGETACCESSORY, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOADDCONTROLS, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOADDCONTROL, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOGETCTRLOPSRREG, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOGETCTRLOPSREG, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOSETCTRLOPSREG, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOSETCTRLOPSRREG, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIODAIREADREG, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIODAIWRITEREG, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOCODECREADREG, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOCODECWRITEREG, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOACCESSORYREADREG, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOACCESSORYWRITEREG, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOINFOCTRLOPS, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOCODECGETCTRLOPS, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOCODECSETCTRLOPS, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOACCESSORYGETCTRLOPS, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOACCESSORYSETCTRLOPS, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOCPUDAISETCTRLOPS, // audio ADM audio_core + AUDIO_ADM_TEST_AUDIOCPUDAIGETCTRLOPS = 37, // audio ADM audio_core + + AUDIO_ADM_TEST_AUDIOSAPMNEWCOMPONENTS = 38, // audio ADM audio_sapm + AUDIO_ADM_TEST_AUDIOSAPMADDROUTES, // audio ADM audio_sapm + AUDIO_ADM_TEST_AUDIOSAPMNEWCONTROLS, // audio ADM audio_sapm + AUDIO_ADM_TEST_AUDIOSAPMSLEEP, // audio ADM audio_sapm + AUDIO_ADM_TEST_AUDIOSAMPPOWERUP, // audio ADM audio_sapm + AUDIO_ADM_TEST_AUDIOSAMPSETPOWERMONITOR, // audio ADM audio_sapm + AUDIO_ADM_TEST_AUDIOCODECSAPMSETCTRLOPS, // audio ADM audio_sapm + AUDIO_ADM_TEST_AUDIOCODECSAPMGETCTRLOPS, // audio ADM audio_sapm + AUDIO_ADM_TEST_AUDIOACCESSORYSAPMSETCTRLOPS, // audio ADM audio_sapm + AUDIO_ADM_TEST_AUDIOACCESSORYSAPMGETCTRLOPS = 47, // audio ADM audio_sapm + + AUDIO_ADM_TEST_I2CREADWRITE, // audio ADM audio_accessory_base + AUDIO_ADM_TEST_REGBITSREAD, + AUDIO_ADM_TEST_REGBITSUPDATE, + AUDIO_ADM_TEST_DEVICEFREQUENCYPARSE, + AUDIO_ADM_TEST_DAIPARAMSUPDATE, + AUDIO_ADM_TEST_DEVICECFGGET, + AUDIO_ADM_TEST_DEVICECTRLREGINIT, + AUDIO_ADM_TEST_DEVICEREGREAD, + AUDIO_ADM_TEST_DEVICEREGWRITE, + AUDIO_ADM_TEST_AGETCONFIGINFO, + + AUDIO_ADM_TEST_GETSERVICENAME, // audio ADM audio_codec_base + AUDIO_ADM_TEST_GETDAINAME, + AUDIO_ADM_TEST_GETCONFIGINFO, + AUDIO_ADM_TEST_SETCONFIGINFO, + AUDIO_ADM_TEST_SETCTLFUNC, + + AUDIO_ADM_TEST_DAIDATAFROMCARD, // audio ADM audio_dai_base + AUDIO_ADM_TEST_DAIGETCONFIGINFO, + AUDIO_ADM_TEST_DAICHECKSAMPLERATE, + AUDIO_ADM_TEST_DAISETCONFIGINFO, + + AUDIO_ADM_TEST_DMABUFALLOC, // audio ADM audio_dma_base + AUDIO_ADM_TEST_DMABUFFREE, + AUDIO_ADM_TEST_DMAREQUESTCHANNEL, + AUDIO_ADM_TEST_DMACONFIGCHANNEL, + AUDIO_ADM_TEST_DMAPREP, + AUDIO_ADM_TEST_DMASUBMIT, + AUDIO_ADM_TEST_DMAPENDING, + AUDIO_ADM_TEST_DMAPAUSE, + AUDIO_ADM_TEST_DMARESUME, + AUDIO_ADM_TEST_DMAPOINTER, + + AUDIO_ADM_TEST_DSPGETSERVICENAME, // audio ADM audio_dsp_base + AUDIO_ADM_TEST_DSPGETDAINAME, + + AUDIO_ADM_TEST_DATAFROMCARD, // audio ADM audio_platform_base + AUDIO_ADM_TEST_BYTESTOFRAMES, + AUDIO_ADM_TEST_DATABIGENDIANCHANGE, + AUDIO_ADM_TEST_FRAMATTOBITWIDTH, + AUDIO_ADM_TEST_SETPCMINFO, + AUDIO_ADM_TEST_SETRENDERBUFINFO, + AUDIO_ADM_TEST_SETCAPTUREBUFINFO, + AUDIO_ADM_TEST_PCMWRITE, + AUDIO_ADM_TEST_PCMREAD, + AUDIO_ADM_TEST_PCMMMAPWRITE, + AUDIO_ADM_TEST_PCMMMAPREAD, + AUDIO_ADM_TEST_RENDEROPEN, + AUDIO_ADM_TEST_CAPTUREOPEN, + AUDIO_ADM_TEST_RENDERCLOSE, + AUDIO_ADM_TEST_PCMPOINTER, + AUDIO_ADM_TEST_CAPTURECLOSE, + AUDIO_ADM_TEST_HWPARAMS, + AUDIO_ADM_TEST_RENDERPREPARE, + AUDIO_ADM_TEST_CAPTUREPREPARE, + AUDIO_ADM_TEST_RENDERTRIGGER, + AUDIO_ADM_TEST_CAPTURETRIGGER, } HdfAudioTestCaseCmd; int32_t HdfAudioEntry(HdfTestMsg *msg); diff --git a/test/unittest/model/audio/src/audio_accessory_base_test.c b/test/unittest/model/audio/src/audio_accessory_base_test.c new file mode 100644 index 0000000000000000000000000000000000000000..8e345a64cf7c9399be275fcfcc66e0972a8f508e --- /dev/null +++ b/test/unittest/model/audio/src/audio_accessory_base_test.c @@ -0,0 +1,126 @@ +/* + * Copyright (c) 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 "audio_accessory_base_test.h" +#include "audio_accessory_base.h" +#include "audio_driver_log.h" + +#define HDF_LOG_TAG audio_accessory_base_test + +int32_t AccessoryI2cReadWriteTest(void) +{ + if (AccessoryI2cReadWrite(NULL, 0) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AccessoryRegBitsReadTest(void) +{ + if (AccessoryRegBitsRead(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AccessoryRegBitsUpdateTest(void) +{ + struct AudioMixerControl regValue; + regValue.reg = 1; // 1 is test reg + if (AccessoryRegBitsUpdate(regValue) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AccessoryDaiParamsUpdate fail", __func__, __LINE__); + } + + return HDF_SUCCESS; +} + + +int32_t AcessoryDeviceFrequencyParseTest(void) +{ + if (AcessoryDeviceFrequencyParse(0, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AccessoryDaiParamsUpdateTest(void) +{ + struct DaiParamsVal value; + + value.frequencyVal = 1; // 1 is dma channel + if (AccessoryDaiParamsUpdate(value) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AccessoryDaiParamsUpdate fail", __func__, __LINE__); + } + + return HDF_SUCCESS; +} + +int32_t AccessoryDeviceCfgGetTest(void) +{ + if (AccessoryDeviceCfgGet(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AccessoryDeviceCtrlRegInitTest(void) +{ + if (AccessoryDeviceCtrlRegInit() == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AccessoryDeviceCtrlRegInitTest fail", __func__, __LINE__); + } + + return HDF_SUCCESS; +} + +int32_t AccessoryDeviceRegReadTest(void) +{ + uint32_t val; + struct AccessoryDevice codec; + if (AccessoryDeviceRegRead(NULL, 0, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AccessoryDeviceRegRead fail", __func__, __LINE__); + } + + if (AccessoryDeviceRegRead(&codec, 0, &val) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AccessoryDeviceRegRead fail", __func__, __LINE__); + } + return HDF_SUCCESS; +} + +int32_t AccessoryDeviceRegWriteTest(void) +{ + struct AccessoryDevice codec; + if (AccessoryDeviceRegWrite(NULL, 0, 0) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AccessoryDeviceRegWrite fail", __func__, __LINE__); + } + + if (AccessoryDeviceRegWrite(&codec, 0, 0) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AccessoryDeviceRegWrite fail", __func__, __LINE__); + } + return HDF_SUCCESS; +} + +int32_t AccessoryGetConfigInfoTest(void) +{ + struct HdfDeviceObject device; + struct AccessoryData codecData; + + if (AccessoryGetConfigInfo(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AccessoryGetConfigInfo(&device, &codecData) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AccessoryGetConfigInfo fail", __func__, __LINE__); + } + + return HDF_SUCCESS; +} + diff --git a/test/unittest/model/audio/src/audio_codec_base_test.c b/test/unittest/model/audio/src/audio_codec_base_test.c new file mode 100644 index 0000000000000000000000000000000000000000..58c5f77df95c5ecd37d484cd49ba85ed64c2b7d2 --- /dev/null +++ b/test/unittest/model/audio/src/audio_codec_base_test.c @@ -0,0 +1,94 @@ +/* + * Copyright (c) 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 "audio_codec_base_test.h" +#include "audio_codec_base.h" +#include "audio_driver_log.h" + +#define HDF_LOG_TAG audio_codec_base_test + +int32_t CodecGetServiceNameTest(void) +{ + struct HdfDeviceObject device; + const char *drvCodecName = ""; + + if (CodecGetServiceName(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (CodecGetServiceName(&device, &drvCodecName) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t CodecGetDaiNameTest(void) +{ + struct HdfDeviceObject device; + const char *drvCodecName = ""; + + if (CodecGetDaiName(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (CodecGetDaiName(&device, &drvCodecName) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t CodecGetConfigInfoTest(void) +{ + struct HdfDeviceObject device; + struct CodecData codecData; + + if (CodecGetConfigInfo(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (CodecGetConfigInfo(&device, &codecData) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t CodecSetConfigInfoTest(void) +{ + struct DaiData device; + struct CodecData codecData; + + (void)memset_s(&device, sizeof(struct DaiData), 0, sizeof(struct DaiData)); + (void)memset_s(&codecData, sizeof(struct CodecData), 0, sizeof(struct CodecData)); + if (CodecSetConfigInfo(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (CodecSetConfigInfo(&codecData, &device) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t CodecSetCtlFuncTest(void) +{ + struct CodecData codeData; + + if (CodecSetCtlFunc(NULL, NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (CodecSetCtlFunc(&codeData, NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} diff --git a/test/unittest/model/audio/src/audio_core_test.c b/test/unittest/model/audio/src/audio_core_test.c index 1c2c1a47b69910eb3d468c2b77935bd5415571ff..fd7eeb68ad699a205f1d333578eb7231024a93a6 100755 --- a/test/unittest/model/audio/src/audio_core_test.c +++ b/test/unittest/model/audio/src/audio_core_test.c @@ -8,318 +8,607 @@ #include "audio_core_test.h" #include "audio_core.h" +#include "audio_parse.h" +#include "devsvc_manager_clnt.h" #define HDF_LOG_TAG audio_core_test -int32_t AudioSocTestRegisterDai(void) +static struct AudioMixerControl g_audioTestReg = { + .reg = 0x2004, /* [0] output volume */ + .rreg = 0x2004, /* register value */ + .shift = 0x8, /* reg offset */ + .rshift = 0x8, /* right reg offset */ + .min = 0x28, /* min value */ + .max = 0x7F, /* max value */ + .mask = 0x7F, /* mask value */ + .invert = 0, /* invert */ +}; + +static int32_t AudioDeviceReadRegMock(unsigned long virtualAddress, uint32_t reg, uint32_t *value) +{ + return HDF_SUCCESS; +} + +static int32_t AudioDeviceWriteRegMock(unsigned long virtualAddress, uint32_t reg, uint32_t value) +{ + return HDF_SUCCESS; +} + +int32_t AudioDeviceReadRegTest(void) +{ + int value; + HDF_LOGI("%s: enter", __func__); + return AudioDeviceReadRegMock(0, 0, &value); +} + +int32_t AudioDeviceWriteRegTest(void) +{ + HDF_LOGI("%s: enter", __func__); + return AudioDeviceWriteRegMock(0, 0, 0); +} + +int32_t AudioSocRegisterPlatformTest(void) { - int32_t ret; struct HdfDeviceObject *device = NULL; - struct DaiData *data = NULL; + struct PlatformData platformData; HDF_LOGI("%s: enter", __func__); - ret = AudioSocRegisterDai(device, data); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioSocRegisterDai fail ret = %d", __func__, ret); + if (AudioSocRegisterPlatform(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocRegisterPlatform fail", __func__, __LINE__); + return HDF_FAILURE; } + device = DevSvcManagerClntGetDeviceObject("hdf_audio_codec_dev0"); + (void)memset_s(&platformData, sizeof(struct PlatformData), 0, sizeof(struct PlatformData)); + platformData.drvPlatformName = "dma_service_0"; + if (AudioSocRegisterPlatform(device, &platformData) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocRegisterPlatform fail", __func__); + return HDF_FAILURE; + } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } - -int32_t AudioSocTestRegisterPlatform(void) +int32_t AudioSocRegisterDaiTest(void) { - int32_t ret; struct HdfDeviceObject *device = NULL; - struct PlatformData *data = NULL; + struct DaiData data; HDF_LOGI("%s: enter", __func__); - ret = AudioSocRegisterPlatform(device, data); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioSocRegisterPlatform fail ret = %d", __func__, ret); + if (AudioSocRegisterDai(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocRegisterDai fail", __func__, __LINE__); + return HDF_FAILURE; + } + + device = DevSvcManagerClntGetDeviceObject("hdf_audio_codec_dev0"); + (void)memset_s(&data, sizeof(struct DaiData), 0, sizeof(struct DaiData)); + data.drvDaiName = "dai_service"; + if (AudioSocRegisterDai(device, &data) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocRegisterDai fail", __func__, __LINE__); + return HDF_FAILURE; } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestRegisterCodec(void) +int32_t AudioRegisterDspTest(void) { - int32_t ret; struct HdfDeviceObject *device = NULL; - struct CodecData *codecData = NULL; - struct DaiData *daiData = NULL; + struct DaiData daiData; + struct DspData dspData; HDF_LOGI("%s: enter", __func__); - ret = AudioRegisterCodec(device, codecData, daiData); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioRegisterCodec fail ret = %d", __func__, ret); + if (AudioRegisterDsp(NULL, NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocRegisterDsp fail", __func__, __LINE__); + return HDF_FAILURE; + } + + device = DevSvcManagerClntGetDeviceObject("hdf_audio_codec_dev0"); + (void)memset_s(&daiData, sizeof(struct DspData), 0, sizeof(struct DspData)); + (void)memset_s(&daiData, sizeof(struct DaiData), 0, sizeof(struct DaiData)); + dspData.drvDspName = "dsp_service_0", + daiData.drvDaiName = "dai_service"; + if (AudioRegisterDsp(device, &dspData, &daiData) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioSocRegisterDsp fail", __func__, __LINE__); + return HDF_FAILURE; } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestBindDaiLink(void) +int32_t AudioRegisterCodecTest(void) { - int32_t ret; - struct AudioCard *audioCard = NULL; - struct AudioConfigData *configData = NULL; + struct HdfDeviceObject *device = NULL; + struct DaiData daiData; + struct CodecData codecData; HDF_LOGI("%s: enter", __func__); - ret = AudioBindDaiLink(audioCard, configData); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioBindDaiLink fail ret = %d", __func__, ret); + if (AudioRegisterCodec(NULL, NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioRegisterCodec fail", __func__, __LINE__); + return HDF_FAILURE; + } + + device = DevSvcManagerClntGetDeviceObject("hdf_audio_codec_dev0"); + (void)memset_s(&codecData, sizeof(struct CodecData), 0, sizeof(struct CodecData)); + (void)memset_s(&daiData, sizeof(struct DaiData), 0, sizeof(struct DaiData)); + codecData.drvCodecName = "codec_dai"; + daiData.drvDaiName = "dai_service"; + if (AudioRegisterCodec(device, &codecData, &daiData) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioRegisterCodec fail", __func__, __LINE__); + return HDF_FAILURE; } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestSocDeviceRegister(void) +int32_t AudioRegisterAccessoryTest(void) { - int32_t ret; - void *data = NULL; - enum AudioDeviceType deviceType; struct HdfDeviceObject *device = NULL; + struct DaiData daiData; + struct AccessoryData accessoryData; HDF_LOGI("%s: enter", __func__); - ret = AudioSocDeviceRegister(device, data, deviceType); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioSocDeviceRegister fail ret = %d", __func__, ret); + if (AudioRegisterAccessory(NULL, NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioRegisterAccessory fail", __func__, __LINE__); + return HDF_FAILURE; + } + + device = DevSvcManagerClntGetDeviceObject("hdf_audio_codec_dev0"); + (void)memset_s(&accessoryData, sizeof(struct AccessoryData), 0, sizeof(struct AccessoryData)); + (void)memset_s(&daiData, sizeof(struct DaiData), 0, sizeof(struct DaiData)); + accessoryData.drvAccessoryName = "accessory_dai"; + daiData.drvDaiName = "dai_service"; + if (AudioRegisterAccessory(device, &accessoryData, &daiData) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioRegisterAccessory fail", __func__, __LINE__); + return HDF_FAILURE; } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestSocRegisterDsp(void) +int32_t AudioBindDaiLinkTest(void) { - int32_t ret; - struct HdfDeviceObject *device = NULL; - struct DaiData *data = NULL; HDF_LOGI("%s: enter", __func__); - ret = AudioSocRegisterDsp(device, data); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioSocRegisterDsp fail ret = %d", __func__, ret); + if (AudioBindDaiLink(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioBindDaiLink fail", __func__, __LINE__); + return HDF_FAILURE; } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestRegisterAccessory(void) +int32_t AudioUpdateCodecRegBitsTest(void) { - int32_t ret; - struct HdfDeviceObject *device = NULL; - struct AccessoryData *data = NULL; - struct DaiData *daiData = NULL; + struct CodecData codecData; + struct CodecDevice codec; HDF_LOGI("%s: enter", __func__); - ret = AudioRegisterAccessory(device, data, daiData); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioRegisterAccessory fail ret = %d", __func__, ret); + if (AudioUpdateCodecRegBits(NULL, NULL, 0) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioUpdateCodecRegBits fail", __func__, __LINE__); + return HDF_FAILURE; } + (void)memset_s(&codecData, sizeof(struct CodecData), 0, sizeof(struct CodecData)); + (void)memset_s(&codec, sizeof(struct CodecDevice), 0, sizeof(struct CodecDevice)); + codecData.Read = AudioDeviceReadRegMock; + codecData.Write = AudioDeviceWriteRegMock, + codec.devCodecName = "codec_service_0"; + OsalMutexInit(&codec.mutex); + codec.devData = &codecData; + if (AudioUpdateCodecRegBits(&codec, &g_audioTestReg, g_audioTestReg.min + 1) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioUpdateCodecRegBits fail", __func__, __LINE__); + OsalMutexDestroy(&codec.mutex); + return HDF_FAILURE; + } + + OsalMutexDestroy(&codec.mutex); HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestUpdateRegBits(void) +int32_t AudioUpdateAccessoryRegBitsTest(void) { - int32_t codecRet; - int32_t accessoryRet; - int32_t value; - void *device = NULL; - struct AudioMixerControl *mixerControl = NULL; + struct AccessoryDevice accessory; HDF_LOGI("%s: enter", __func__); - codecRet = AudioUpdateRegBits(AUDIO_CODEC_DEVICE, device, mixerControl, value); - accessoryRet = AudioUpdateRegBits(AUDIO_ACCESSORY_DEVICE, device, mixerControl, value); - if (codecRet != HDF_SUCCESS || accessoryRet != HDF_SUCCESS) { - HDF_LOGE("%s: AudioUpdateRegBits fail codecRet = %d, accessoryRet = %d", __func__, codecRet, accessoryRet); + if (AudioUpdateAccessoryRegBits(NULL, NULL, 0) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioUpdateAccessoryRegBits fail", __func__, __LINE__); + return HDF_FAILURE; } + (void)memset_s(&accessory, sizeof(struct AccessoryDevice), 0, sizeof(struct AccessoryDevice)); + accessory.devAccessoryName = "codec_service_1"; + OsalMutexInit(&accessory.mutex); + if (AudioUpdateAccessoryRegBits(&accessory, &g_audioTestReg, g_audioTestReg.min + 1) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioUpdateAccessoryRegBits fail", __func__, __LINE__); + OsalMutexDestroy(&accessory.mutex); + } + + OsalMutexDestroy(&accessory.mutex); HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestAiaoUpdateRegBits(void) +int32_t AudioUpdateDaiRegBitsTest(void) { - uint32_t reg; - uint32_t mask; - uint32_t shift; - int32_t value; - int32_t ret; - struct CodecDevice *codec = NULL; + struct DaiDevice dai; HDF_LOGI("%s: enter", __func__); - ret = AudioAiaoUpdateRegBits(codec, reg, mask, shift, value); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioAiaoUpdateRegBits fail ret = %d", __func__, ret); + if (AudioUpdateDaiRegBits(NULL, NULL, 0) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioUpdateDaiRegBits fail", __func__, __LINE__); + return HDF_FAILURE; + } + + (void)memset_s(&dai, sizeof(struct DaiDevice), 0, sizeof(struct DaiDevice)); + dai.devDaiName = "dai_service"; + if (AudioUpdateDaiRegBits(&dai, &g_audioTestReg, g_audioTestReg.min + 1) != HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioUpdateAccessoryRegBits fail", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestKcontrolGetCodec(void) +int32_t AudioKcontrolGetCpuDaiTest(void) { - struct CodecDevice *codecDevice = NULL; - const struct AudioKcontrol *kcontrol = NULL; + struct AudioKcontrol *kcontrol = NULL; HDF_LOGI("%s: enter", __func__); - codecDevice = AudioKcontrolGetCodec(kcontrol); - if (codecDevice == NULL) { - HDF_LOGE("%s: AudioKcontrolGetCodec fail!", __func__); + if (AudioKcontrolGetCpuDai(kcontrol) == NULL) { + HDF_LOGE("%s_[%d] AudioKcontrolGetCpuDai fail!", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestAddControls(void) +int32_t AudioKcontrolGetCodecTest(void) { - struct AudioCard *audioCard = NULL; - const struct AudioKcontrol *controls = NULL; - int32_t controlMaxNum = 0; - int32_t ret; + struct AudioKcontrol *kcontrol = NULL; HDF_LOGI("%s: enter", __func__); - ret = AudioAddControls(audioCard, controls, controlMaxNum); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioAddControls fail ret = %d", __func__, ret); + if (AudioKcontrolGetCodec(kcontrol) == NULL) { + HDF_LOGE("%s_[%d] AudioKcontrolGetCodec fail!", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestAddControl(void) +int32_t AudioKcontrolGetAccessoryTest(void) +{ + struct AudioKcontrol *kcontrol = NULL; + HDF_LOGI("%s: enter", __func__); + + if (AudioKcontrolGetAccessory(kcontrol) == NULL) { + HDF_LOGE("%s_[%d] AudioKcontrolGetAccessory fail!", __func__, __LINE__); + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioAddControlsTest(void) +{ + HDF_LOGI("%s: enter", __func__); + + if (AudioAddControls(NULL, NULL, 0) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioUpdateDaiRegBits fail", __func__, __LINE__); + return HDF_FAILURE; + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioAddControlTest(void) { struct AudioCard *audioCard = NULL; - const struct AudioKcontrol *control = NULL; - struct AudioKcontrol *audioKcontrol = NULL; + struct AudioKcontrol control; + HDF_LOGI("%s: enter", __func__); + + audioCard = GetCardInstance("hdf_audio_codec_dev0"); + (void)memset_s(&control, sizeof(struct AudioKcontrol), 0, sizeof(struct AudioKcontrol)); + if (AudioAddControl(audioCard, &control) == NULL) { + HDF_LOGE("%s_[%d] AudioAddControl fail!", __func__, __LINE__); + } + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioGetCtrlOpsRRegTest(void) +{ + struct AudioCtrlElemValue elemValue; + struct AudioMixerControl mixerCtrl; + HDF_LOGI("%s: enter", __func__); + + (void)memset_s(&elemValue, sizeof(struct AudioCtrlElemValue), 0, sizeof(struct AudioCtrlElemValue)); + (void)memset_s(&mixerCtrl, sizeof(struct AudioMixerControl), 0, sizeof(struct AudioMixerControl)); + AudioGetCtrlOpsRReg(&elemValue, &mixerCtrl, 0); + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioGetCtrlOpsRegTest(void) +{ + struct AudioCtrlElemValue elemValue; + struct AudioMixerControl mixerCtrl; + HDF_LOGI("%s: enter", __func__); + + (void)memset_s(&elemValue, sizeof(struct AudioCtrlElemValue), 0, sizeof(struct AudioCtrlElemValue)); + (void)memset_s(&mixerCtrl, sizeof(struct AudioMixerControl), 0, sizeof(struct AudioMixerControl)); + AudioGetCtrlOpsReg(&elemValue, &mixerCtrl, 0); + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioSetCtrlOpsRegTest(void) +{ + uint32_t value; + struct AudioKcontrol kcontrol; + struct AudioCtrlElemValue elemValue; + struct AudioMixerControl mixerCtrl; + HDF_LOGI("%s: enter", __func__); + + (void)memset_s(&kcontrol, sizeof(struct AudioKcontrol), 0, sizeof(struct AudioKcontrol)); + (void)memset_s(&elemValue, sizeof(struct AudioCtrlElemValue), 0, sizeof(struct AudioCtrlElemValue)); + (void)memset_s(&mixerCtrl, sizeof(struct AudioMixerControl), 0, sizeof(struct AudioMixerControl)); + AudioSetCtrlOpsReg(&kcontrol, &elemValue, &mixerCtrl, &value); + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioSetCtrlOpsRRegTest(void) +{ + uint32_t value; + bool updateRReg; + struct AudioCtrlElemValue elemValue; + struct AudioMixerControl mixerCtrl; + HDF_LOGI("%s: enter", __func__); + + (void)memset_s(&elemValue, sizeof(struct AudioCtrlElemValue), 0, sizeof(struct AudioCtrlElemValue)); + (void)memset_s(&mixerCtrl, sizeof(struct AudioMixerControl), 0, sizeof(struct AudioMixerControl)); + AudioSetCtrlOpsRReg(&elemValue, &mixerCtrl, &value, &updateRReg); + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioDaiReadRegTest(void) +{ + uint32_t val; + struct DaiDevice dai; HDF_LOGI("%s: enter", __func__); - audioKcontrol = AudioAddControl(audioCard, control); - if (audioKcontrol == NULL) { - HDF_LOGE("%s: AudioAddControl fail!", __func__); + (void)memset_s(&dai, sizeof(struct DaiDevice), 0, sizeof(struct DaiDevice)); + if (AudioDaiReadReg(&dai, 0, &val) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioDaiReadReg fail", __func__, __LINE__); + return HDF_FAILURE; } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestDeviceReadReg(void) +int32_t AudioDaiWriteRegTest(void) { - int32_t codecRet; - int32_t acccessoryRet; - uint32_t reg = 0; - struct CodecDevice *codec = NULL; - struct AccessoryDevice *accessory = NULL; + struct DaiDevice dai; HDF_LOGI("%s: enter", __func__); - codecRet = AudioCodecDeviceReadReg(codec, reg); - acccessoryRet = AudioAccessoryDeviceReadReg(accessory, reg); - if (codecRet != HDF_SUCCESS || acccessoryRet != HDF_SUCCESS) { - HDF_LOGE("%s: AudioDeviceReadReg fail codecRet = %d, acccessoryRet = %d", __func__, codecRet, acccessoryRet); + (void)memset_s(&dai, sizeof(struct DaiDevice), 0, sizeof(struct DaiDevice)); + if (AudioDaiWriteReg(&dai, 0, 0) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioDaiWriteReg fail", __func__, __LINE__); + return HDF_FAILURE; } + HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestAiaoDeviceReadReg(void) +int32_t AudioCodecReadRegTest(void) { - int32_t ret; - uint32_t reg = 0; - struct CodecDevice *codec = NULL; + uint32_t val; + struct CodecDevice codec; HDF_LOGI("%s: enter", __func__); - ret = AudioAiaoDeviceReadReg(codec, reg); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioAiaoDeviceReadReg fail ret = %d", __func__, ret); + (void)memset_s(&codec, sizeof(struct CodecDevice), 0, sizeof(struct CodecDevice)); + if (AudioCodecReadReg(&codec, 0, &val) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioCodecReadReg fail", __func__, __LINE__); + return HDF_FAILURE; } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestInfoCtrlSw(void) +int32_t AudioCodecWriteRegTest(void) { - int32_t ret; - struct AudioKcontrol *kcontrol = NULL; - struct AudioCtrlElemInfo *elemInfo = NULL; + struct CodecDevice codec; HDF_LOGI("%s: enter", __func__); - ret = AudioInfoCtrlSw(kcontrol, elemInfo); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioInfoCtrlSw fail ret = %d", __func__, ret); + (void)memset_s(&codec, sizeof(struct CodecDevice), 0, sizeof(struct CodecDevice)); + if (AudioCodecWriteReg(&codec, 0, 0) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioCodecWriteReg fail", __func__, __LINE__); + return HDF_FAILURE; } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestGetCtrlSw(void) +int32_t AudioAccessoryReadRegTest(void) { - int32_t ret; - struct AudioKcontrol *kcontrol = NULL; - struct AudioCtrlElemValue *elemValue = NULL; + uint32_t val; + struct AccessoryDevice accessory; HDF_LOGI("%s: enter", __func__); - ret = AudioGetCtrlSw(kcontrol, elemValue); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioGetCtrlSw fail ret = %d", __func__, ret); + (void)memset_s(&accessory, sizeof(struct AccessoryDevice), 0, sizeof(struct AccessoryDevice)); + if (AudioAccessoryReadReg(&accessory, 0, &val) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioAccessoryReadReg fail", __func__, __LINE__); + return HDF_FAILURE; } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AudioTestPutCtrlSw(void) +int32_t AudioAccessoryWriteRegTest(void) { - int32_t ret; - struct AudioKcontrol *kcontrol = NULL; - struct AudioCtrlElemValue *elemValue = NULL; + struct AccessoryDevice accessory; HDF_LOGI("%s: enter", __func__); - ret = AudioPutCtrlSw(kcontrol, elemValue); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AudioPutCtrlSw fail ret = %d", __func__, ret); + (void)memset_s(&accessory, sizeof(struct AccessoryDevice), 0, sizeof(struct AccessoryDevice)); + if (AudioAccessoryWriteReg(&accessory, 0, 0) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioAccessoryWriteReg fail", __func__, __LINE__); + return HDF_FAILURE; } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AiaoTestGetCtrlSw(void) +int32_t AudioInfoCtrlOpsTest(void) { - int32_t ret; - struct AudioKcontrol *kcontrol = NULL; - struct AudioCtrlElemValue *elemValue = NULL; + struct AudioKcontrol kcontrol; + struct AudioCtrlElemInfo elemInfo; HDF_LOGI("%s: enter", __func__); - ret = AiaoGetCtrlSw(kcontrol, elemValue); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AiaoGetCtrlSw fail ret = %d", __func__, ret); + if (AudioInfoCtrlOps(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioInfoCtrlOps fail", __func__, __LINE__); + return HDF_FAILURE; + } + (void)memset_s(&kcontrol, sizeof(struct AudioKcontrol), 0, sizeof(struct AudioKcontrol)); + (void)memset_s(&elemInfo, sizeof(struct AudioCtrlElemInfo), 0, sizeof(struct AudioCtrlElemInfo)); + if (AudioInfoCtrlOps(&kcontrol, &elemInfo) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioInfoCtrlOps fail", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t AiaoTestPutCtrlSw(void) +int32_t AudioCodecGetCtrlOpsTest(void) { - int32_t ret; - struct AudioKcontrol *kcontrol = NULL; - struct AudioCtrlElemValue *elemValue = NULL; + struct AudioKcontrol kcontrol; + struct AudioCtrlElemValue elemValue; + HDF_LOGI("%s: enter", __func__); + + if (AudioCodecGetCtrlOps(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioCodecGetCtrlOps fail", __func__, __LINE__); + return HDF_FAILURE; + } + (void)memset_s(&kcontrol, sizeof(struct AudioKcontrol), 0, sizeof(struct AudioKcontrol)); + (void)memset_s(&elemValue, sizeof(struct AudioCtrlElemValue), 0, sizeof(struct AudioCtrlElemValue)); + if (AudioCodecGetCtrlOps(&kcontrol, &elemValue) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioCodecGetCtrlOps fail", __func__, __LINE__); + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioCodecSetCtrlOpsTest(void) +{ + struct AudioKcontrol kcontrol; + struct AudioCtrlElemValue elemValue; + HDF_LOGI("%s: enter", __func__); + + if (AudioCodecSetCtrlOps(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioCodecSetCtrlOps fail", __func__, __LINE__); + return HDF_FAILURE; + } + (void)memset_s(&kcontrol, sizeof(struct AudioKcontrol), 0, sizeof(struct AudioKcontrol)); + (void)memset_s(&elemValue, sizeof(struct AudioCtrlElemValue), 0, sizeof(struct AudioCtrlElemValue)); + if (AudioCodecSetCtrlOps(&kcontrol, &elemValue) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioCodecSetCtrlOps fail", __func__, __LINE__); + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioAccessoryGetCtrlOpsTest(void) +{ + struct AudioKcontrol kcontrol; + struct AudioCtrlElemValue elemValue; + HDF_LOGI("%s: enter", __func__); + + if (AudioAccessoryGetCtrlOps(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioAccessoryGetCtrlOps fail", __func__, __LINE__); + return HDF_FAILURE; + } + (void)memset_s(&kcontrol, sizeof(struct AudioKcontrol), 0, sizeof(struct AudioKcontrol)); + (void)memset_s(&elemValue, sizeof(struct AudioCtrlElemValue), 0, sizeof(struct AudioCtrlElemValue)); + if (AudioAccessoryGetCtrlOps(&kcontrol, &elemValue) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioAccessoryGetCtrlOps fail", __func__, __LINE__); + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioAccessorySetCtrlOpsTset(void) +{ + struct AudioKcontrol kcontrol; + struct AudioCtrlElemValue elemValue; HDF_LOGI("%s: enter", __func__); - ret = AiaoPutCtrlSw(kcontrol, elemValue); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: AiaoPutCtrlSw fail ret = %d", __func__, ret); + if (AudioAccessorySetCtrlOps(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioAccessorySetCtrlOps fail", __func__, __LINE__); + return HDF_FAILURE; + } + (void)memset_s(&kcontrol, sizeof(struct AudioKcontrol), 0, sizeof(struct AudioKcontrol)); + (void)memset_s(&elemValue, sizeof(struct AudioCtrlElemValue), 0, sizeof(struct AudioCtrlElemValue)); + if (AudioAccessorySetCtrlOps(&kcontrol, &elemValue) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioAccessorySetCtrlOps fail", __func__, __LINE__); + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioCpuDaiSetCtrlOpsTest(void) +{ + struct AudioKcontrol kcontrol; + struct AudioCtrlElemValue elemValue; + HDF_LOGI("%s: enter", __func__); + + if (AudioCpuDaiSetCtrlOps(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioCpuDaiSetCtrlOps fail", __func__, __LINE__); + return HDF_FAILURE; + } + (void)memset_s(&kcontrol, sizeof(struct AudioKcontrol), 0, sizeof(struct AudioKcontrol)); + (void)memset_s(&elemValue, sizeof(struct AudioCtrlElemValue), 0, sizeof(struct AudioCtrlElemValue)); + if (AudioCpuDaiSetCtrlOps(&kcontrol, &elemValue) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioCpuDaiSetCtrlOps fail", __func__, __LINE__); + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioCpuDaiGetCtrlOpsTest(void) +{ + struct AudioKcontrol kcontrol; + struct AudioCtrlElemValue elemValue; + HDF_LOGI("%s: enter", __func__); + + if (AudioCpuDaiGetCtrlOps(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioCpuDaiGetCtrlOps fail", __func__, __LINE__); + return HDF_FAILURE; + } + (void)memset_s(&kcontrol, sizeof(struct AudioKcontrol), 0, sizeof(struct AudioKcontrol)); + (void)memset_s(&elemValue, sizeof(struct AudioCtrlElemValue), 0, sizeof(struct AudioCtrlElemValue)); + if (AudioCpuDaiGetCtrlOps(&kcontrol, &elemValue) == HDF_SUCCESS) { + HDF_LOGE("%s_[%d] AudioCpuDaiGetCtrlOps fail", __func__, __LINE__); } HDF_LOGI("%s: success", __func__); diff --git a/test/unittest/model/audio/src/audio_dai_base_test.c b/test/unittest/model/audio/src/audio_dai_base_test.c new file mode 100644 index 0000000000000000000000000000000000000000..245338b768a97a8ccd588d88e5df6b0a3b5cef3d --- /dev/null +++ b/test/unittest/model/audio/src/audio_dai_base_test.c @@ -0,0 +1,68 @@ +/* + * Copyright (c) 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 "audio_dai_base_test.h" +#include "audio_dai_base.h" +#include "audio_driver_log.h" + +#define HDF_LOG_TAG audio_dai_base_test + +int32_t DaiDataFromCardTest(void) +{ + struct AudioCard card; + if (DaiDataFromCard(NULL) != NULL) { + return HDF_FAILURE; + } + + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + if (DaiDataFromCard(&card) != NULL) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t DaiGetConfigInfoTest(void) +{ + struct HdfDeviceObject device; + struct DaiData data; + if (DaiGetConfigInfo(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (DaiGetConfigInfo(&device, &data) == HDF_SUCCESS) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t DaiCheckSampleRateTest(void) +{ + if (DaiCheckSampleRate(0) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (DaiCheckSampleRate(AUDIO_SAMPLE_RATE_8000) != HDF_SUCCESS) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t DaiSetConfigInfoTest(void) +{ + struct DaiData data; + if (DaiSetConfigInfo(NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + (void)memset_s(&data, sizeof(struct DaiData), 0, sizeof(struct DaiData)); + if (DaiSetConfigInfo(&data) == HDF_SUCCESS) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + diff --git a/test/unittest/model/audio/src/audio_dma_base_test.c b/test/unittest/model/audio/src/audio_dma_base_test.c new file mode 100644 index 0000000000000000000000000000000000000000..12560fb154cf8ed4ddd3f39ba3c28bfec1f88526 --- /dev/null +++ b/test/unittest/model/audio/src/audio_dma_base_test.c @@ -0,0 +1,169 @@ +/* + * Copyright (c) 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 "audio_dma_base_test.h" +#include "audio_platform_if.h" +#include "audio_dma_base.h" +#include "audio_driver_log.h" + +#define HDF_LOG_TAG audio_dma_base_test + +int32_t AudioDmaBufAllocTest(void) +{ + struct PlatformData data; + + (void)memset_s(&data, sizeof(struct PlatformData), 0, sizeof(struct PlatformData)); + + if (AudioDmaBufAlloc(NULL, 0) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioDmaBufAlloc(&data, 0) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioDmaBufFreeTest(void) +{ + struct PlatformData data; + + (void)memset_s(&data, sizeof(struct PlatformData), 0, sizeof(struct PlatformData)); + + if (AudioDmaBufFree(NULL, 0) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioDmaBufFree(&data, 0) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioDmaRequestChannelTest(void) +{ + struct PlatformData data; + (void)memset_s(&data, sizeof(struct PlatformData), 0, sizeof(struct PlatformData)); + if (AudioDmaRequestChannel(NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioDmaRequestChannel(&data) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioDmaConfigChannelTest(void) +{ + struct PlatformData data; + (void)memset_s(&data, sizeof(struct PlatformData), 0, sizeof(struct PlatformData)); + if (AudioDmaConfigChannel(NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioDmaConfigChannel(&data) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioDmaPrepTest(void) +{ + struct PlatformData data; + (void)memset_s(&data, sizeof(struct PlatformData), 0, sizeof(struct PlatformData)); + if (AudioDmaPrep(NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioDmaPrep(&data) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioDmaSubmitTest(void) +{ + struct PlatformData data; + (void)memset_s(&data, sizeof(struct PlatformData), 0, sizeof(struct PlatformData)); + if (AudioDmaSubmit(NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioDmaSubmit(&data) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioDmaPendingTest(void) +{ + struct PlatformData data; + (void)memset_s(&data, sizeof(struct PlatformData), 0, sizeof(struct PlatformData)); + if (AudioDmaPending(NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioDmaPending(&data) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioDmaPauseTest(void) +{ + struct PlatformData data; + (void)memset_s(&data, sizeof(struct PlatformData), 0, sizeof(struct PlatformData)); + if (AudioDmaPause(NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioDmaPause(&data) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioDmaResumeTest(void) +{ + struct PlatformData data; + (void)memset_s(&data, sizeof(struct PlatformData), 0, sizeof(struct PlatformData)); + if (AudioDmaResume(NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioDmaResume(&data) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioDmaPointerTest(void) +{ + struct PlatformData data; + uint32_t pointer = 0; + (void)memset_s(&data, sizeof(struct PlatformData), 0, sizeof(struct PlatformData)); + if (AudioDmaPointer(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioDmaPointer(&data, &pointer) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} diff --git a/test/unittest/model/audio/src/audio_dsp_base_test.c b/test/unittest/model/audio/src/audio_dsp_base_test.c new file mode 100644 index 0000000000000000000000000000000000000000..8b1601045fcf9c1bedc828256bcf223d8d2b28f1 --- /dev/null +++ b/test/unittest/model/audio/src/audio_dsp_base_test.c @@ -0,0 +1,60 @@ +/* + * Copyright (c) 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 "audio_dsp_base_test.h" +#include "audio_dsp_base.h" +#include "audio_driver_log.h" + +#define HDF_LOG_TAG audio_dsp_base_test +#define KCONTROL_TEST_SERVICE_NAME "dsp_service_0" + +int32_t DspGetServiceNameTest(void) +{ + struct DeviceResourceAttr attr; + struct DeviceResourceNode node; + struct HdfDeviceObject device; + if (DspGetServiceName(NULL, NULL) == HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("TestDspGetServiceName fail"); + return HDF_FAILURE; + } + + attr.value = KCONTROL_TEST_SERVICE_NAME; + attr.name = "serviceName"; + node.attrData = &attr; + device.property = &node; + if (DspGetServiceName(&device, NULL) == HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("TestDspGetServiceName fail"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t DspGetDaiNameTest(void) +{ + struct DeviceResourceNode node; + struct HdfDeviceObject device; + struct DeviceResourceAttr attr; + + if (DspGetDaiName(NULL, NULL) == HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("TestDspGetDaiName fail"); + return HDF_FAILURE; + } + + attr.value = KCONTROL_TEST_SERVICE_NAME; + attr.name = "dspDaiName"; + node.attrData = &attr; + device.property = &node; + if (DspGetDaiName(&device, NULL) == HDF_SUCCESS) { + AUDIO_DRIVER_LOG_ERR("TestDspGetDaiName fail"); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + diff --git a/test/unittest/model/audio/src/audio_host_test.c b/test/unittest/model/audio/src/audio_host_test.c index ef4d81c2a9243941ad150581b14e8903ecab8fbd..56dcf3cfe55ae4a7e4a8d94f7883f98a76befb59 100755 --- a/test/unittest/model/audio/src/audio_host_test.c +++ b/test/unittest/model/audio/src/audio_host_test.c @@ -8,57 +8,55 @@ #include "audio_host_test.h" #include "audio_host.h" +#include "devsvc_manager_clnt.h" #define HDF_LOG_TAG audio_host_test -int32_t AudioKcontrolTestGetCodec(void) +const static char *g_audioServiceName[] = { + "codec_service_0", + "codec_service_1", + "dma_service_0", + "dai_service", + "audio_service_0", + "audio_service_1", + "render_service", + "capture_service", + "control_service", +}; + +int32_t AudioHostCreateAndBindTest(void) { + int i; struct HdfDeviceObject *device = NULL; - struct AudioHost *audioHost = NULL; HDF_LOGI("%s: enter", __func__); - audioHost = AudioHostCreateAndBind(device); - if (audioHost != NULL) { - HDF_LOGE("%s: codecDevice is not NULL", __func__); + if (AudioHostCreateAndBind(NULL) != NULL) { + HDF_LOGE("%s_[%d] codecDevice is not NULL", __func__, __LINE__); return HDF_FAILURE; } + for (i = 0; i < sizeof(g_audioServiceName) / sizeof(g_audioServiceName[0]); ++i) { + device = DevSvcManagerClntGetDeviceObject(g_audioServiceName[i]); + if (AudioHostCreateAndBind(device) == NULL) { + HDF_LOGE("audiohost:%s create and bind fail!", g_audioServiceName[i]); + } + } + HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } -int32_t GetCardTestInstance(void) +int32_t GetCardInstanceTest(void) { int i; - const char *audioServiceName[] = { - "codec_service_0", - "codec_service_1", - "dma_service_0", - "dai_service", - "audio_service_0", - "audio_service_1", - "render_service", - "capture_service", - "control_service", - }; HDF_LOGI("%s: enter", __func__); - for (i = 0; i < sizeof(audioServiceName) / sizeof(audioServiceName[0]); ++i) { - if (GetCardInstance(audioServiceName[i]) == NULL) { - HDF_LOGE("%s: get %s fail!", __func__, audioServiceName[i]); + for (i = 0; i < sizeof(g_audioServiceName) / sizeof(g_audioServiceName[0]); ++i) { + if (GetCardInstance(g_audioServiceName[i]) == NULL) { + HDF_LOGE("%s: get %s fail!", __func__, g_audioServiceName[i]); } } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } - -int32_t AudioHostTestDestroy(void) -{ - struct AudioHost *host = NULL; - HDF_LOGI("%s: enter", __func__); - - AudioHostDestroy(host); - HDF_LOGI("%s: success", __func__); - return HDF_SUCCESS; -} diff --git a/test/unittest/model/audio/src/audio_parse_test.c b/test/unittest/model/audio/src/audio_parse_test.c index 74c61c61e427734d0b168c32999a8b64d1b2a997..d324e681506049f14ac9933c874e7d042a9beb55 100755 --- a/test/unittest/model/audio/src/audio_parse_test.c +++ b/test/unittest/model/audio/src/audio_parse_test.c @@ -5,25 +5,49 @@ * the GPL, or the BSD license, at your option. * See the LICENSE file in the root of this repository for complete details. */ - #include "audio_parse_test.h" #include "audio_parse.h" +#include "devsvc_manager_clnt.h" #define HDF_LOG_TAG audio_parse_test -int32_t AudioFillTestConfigData(void) +int32_t AudioFillConfigDataTest(void) { - int32_t ret; struct HdfDeviceObject *device = NULL; - struct AudioConfigData *configData = NULL; - HDF_LOGI("%s: enter", __func__); + struct AudioConfigData configData; + HDF_LOGI("enter"); + + if (AudioFillConfigData(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("AudioFillConfigData fail"); + return HDF_FAILURE; + } - ret = AudioFillConfigData(device, configData); - if (ret == HDF_SUCCESS) { - HDF_LOGE("%s: AudioFillConfigData fail! ret = %d", __func__, ret); + device = DevSvcManagerClntGetDeviceObject("hdf_audio_codec_dev0"); + if (AudioFillConfigData(device, &configData) != HDF_SUCCESS) { + HDF_LOGE("AudioFillConfigData fail"); return HDF_FAILURE; } - HDF_LOGI("%s: success", __func__); + HDF_LOGI("success"); + return HDF_SUCCESS; +} + +int32_t CodecGetRegConfigTest(void) +{ + struct HdfDeviceObject *device = NULL; + struct AudioRegCfgData regCfgData; + HDF_LOGI("enter"); + + if (CodecGetRegConfig(NULL, NULL) == HDF_SUCCESS) { + HDF_LOGE("AudioFillConfigData fail"); + return HDF_FAILURE; + } + + device = DevSvcManagerClntGetDeviceObject("hdf_audio_codec_dev0"); + if (CodecGetRegConfig(device, ®CfgData) != HDF_SUCCESS) { + HDF_LOGE("AudioFillConfigData fail"); + } + + HDF_LOGI("success"); return HDF_SUCCESS; } diff --git a/test/unittest/model/audio/src/audio_platform_base_test.c b/test/unittest/model/audio/src/audio_platform_base_test.c new file mode 100644 index 0000000000000000000000000000000000000000..bffa0ae00994c54232410c04e9f465fb8dfa1be8 --- /dev/null +++ b/test/unittest/model/audio/src/audio_platform_base_test.c @@ -0,0 +1,402 @@ +/* + * Copyright (c) 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 "audio_platform_base_test.h" +#include "audio_stream_dispatch.h" +#include "audio_platform_base.h" +#include "audio_driver_log.h" + +#define HDF_LOG_TAG audio_dsp_base_test + +int32_t PlatformDataFromCardTest(void) +{ + struct AudioCard card; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + + if (PlatformDataFromCard(NULL) != NULL) { + return HDF_FAILURE; + } + + if (PlatformDataFromCard(&card) != NULL) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioBytesToFramesTest(void) +{ + if (AudioBytesToFrames(0, 0) != 0) { + return HDF_FAILURE; + } + + if (AudioBytesToFrames(1, 1) != 1) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioDataBigEndianChangeTest(void) +{ + const int dataLen = 32; // test data lenth + char test[dataLen]; + (void)memset_s(&test, dataLen, 1, dataLen); + + if (AudioDataBigEndianChange(NULL, 0, 0) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioDataBigEndianChange(test, dataLen, DATA_BIT_WIDTH8) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioDataBigEndianChange(test, dataLen, DATA_BIT_WIDTH24) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioDataBigEndianChange(test, dataLen, DATA_BIT_WIDTH16) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioFramatToBitWidthTest(void) +{ + unsigned int bitWidth = 0; + + if (AudioFramatToBitWidth(1, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioFramatToBitWidth(AUDIO_FORMAT_PCM_16_BIT, &bitWidth) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (bitWidth != DATA_BIT_WIDTH16) { + return HDF_FAILURE; + } + + bitWidth = 0; + if (AudioFramatToBitWidth(AUDIO_FORMAT_PCM_24_BIT, &bitWidth) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (bitWidth != DATA_BIT_WIDTH24) { + return HDF_FAILURE; + } + + if (AudioFramatToBitWidth(AUDIO_FORMAT_AAC_HE_V1, &bitWidth) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioSetPcmInfoTest(void) +{ + struct PlatformData platformData; + struct AudioPcmHwParams param; + (void)memset_s(&platformData, sizeof(struct PlatformData), 0, sizeof(struct PlatformData)); + (void)memset_s(¶m, sizeof(struct AudioPcmHwParams), 0, sizeof(struct AudioPcmHwParams)); + + if (AudioSetPcmInfo(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioSetPcmInfo(&platformData, ¶m) != HDF_SUCCESS) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioSetRenderBufInfoTest(void) +{ + struct PlatformData data; + struct AudioPcmHwParams param; + (void)memset_s(&data, sizeof(struct PlatformData), 0, sizeof(struct PlatformData)); + (void)memset_s(¶m, sizeof(struct AudioPcmHwParams), 0, sizeof(struct AudioPcmHwParams)); + + if (AudioSetRenderBufInfo(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioSetRenderBufInfo(&data, ¶m) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioSetCaptureBufInfoTest(void) +{ + struct PlatformData data; + struct AudioPcmHwParams param; + (void)memset_s(&data, sizeof(struct PlatformData), 0, sizeof(struct PlatformData)); + (void)memset_s(¶m, sizeof(struct AudioPcmHwParams), 0, sizeof(struct AudioPcmHwParams)); + + if (AudioSetCaptureBufInfo(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioSetCaptureBufInfo(&data, ¶m) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioPcmWriteTest(void) +{ + struct AudioCard card; + struct AudioTxData txData; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + (void)memset_s(&txData, sizeof(struct AudioTxData), 0, sizeof(struct AudioTxData)); + + if (AudioPcmWrite(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioPcmWrite(&card, &txData) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioPcmReadTest(void) +{ + struct AudioCard card; + struct AudioRxData rxData; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + (void)memset_s(&rxData, sizeof(struct AudioRxData), 0, sizeof(struct AudioRxData)); + + if (AudioPcmRead(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioPcmRead(&card, &rxData) == HDF_SUCCESS) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioPcmMmapWriteTest(void) +{ + struct AudioCard card; + struct AudioMmapData txMmapData; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + (void)memset_s(&txMmapData, sizeof(struct AudioMmapData), 0, sizeof(struct AudioMmapData)); + + if (AudioPcmMmapWrite(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioPcmMmapWrite(&card, &txMmapData) == HDF_SUCCESS) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioPcmMmapReadTest(void) +{ + struct AudioCard card; + struct AudioMmapData rxMmapData; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + (void)memset_s(&rxMmapData, sizeof(struct AudioMmapData), 0, sizeof(struct AudioMmapData)); + + if (AudioPcmMmapRead(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioPcmMmapRead(&card, &rxMmapData) == HDF_SUCCESS) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderOpenTest(void) +{ + struct AudioCard card; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + + if (AudioRenderOpen(NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioRenderOpen(&card) == HDF_SUCCESS) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureOpenTest(void) +{ + struct AudioCard card; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + + if (AudioCaptureOpen(NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioCaptureOpen(&card) == HDF_SUCCESS) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioRenderCloseTest(void) +{ + struct AudioCard card; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + + if (AudioRenderClose(NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioRenderClose(&card) == HDF_SUCCESS) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioPcmPointerTest(void) +{ + uint32_t pointer = 0; + struct AudioCard card; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + + if (AudioPcmPointer(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioPcmPointer(&card, &pointer) == HDF_SUCCESS) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioCaptureCloseTest(void) +{ + struct AudioCard card; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + + if (AudioCaptureClose(NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioCaptureClose(&card) == HDF_SUCCESS) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + +int32_t AudioHwParamsTest(void) +{ + struct AudioCard card; + struct AudioPcmHwParams param; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + (void)memset_s(¶m, sizeof(struct AudioPcmHwParams), 0, sizeof(struct AudioPcmHwParams)); + + if (AudioHwParams(NULL, NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioHwParams(&card, ¶m) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioRenderPrepareTest(void) +{ + struct AudioCard card; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + + if (AudioRenderPrepare(NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioRenderPrepare(&card) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioCapturePrepareTest(void) +{ + struct AudioCard card; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + + if (AudioCapturePrepare(NULL) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioCapturePrepare(&card) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioRenderTriggerTest(void) +{ + struct AudioCard card; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + + if (AudioRenderTrigger(NULL, AUDIO_DRV_PCM_IOCTL_RENDER_START) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioRenderTrigger(&card, AUDIO_DRV_PCM_IOCTL_RENDER_START) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioRenderTrigger(&card, AUDIO_DRV_PCM_IOCTL_RENDER_STOP) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioRenderTrigger(&card, AUDIO_DRV_PCM_IOCTL_RENDER_PAUSE) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioRenderTrigger(&card, AUDIO_DRV_PCM_IOCTL_RENDER_RESUME) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t AudioCaptureTriggerTest(void) +{ + struct AudioCard card; + (void)memset_s(&card, sizeof(struct AudioCard), 0, sizeof(struct AudioCard)); + + if (AudioCaptureTrigger(NULL, AUDIO_DRV_PCM_IOCTL_CAPTURE_START) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioCaptureTrigger(&card, AUDIO_DRV_PCM_IOCTL_CAPTURE_START) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioCaptureTrigger(&card, AUDIO_DRV_PCM_IOCTL_CAPTURE_STOP) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioCaptureTrigger(&card, AUDIO_DRV_PCM_IOCTL_CAPTURE_PAUSE) == HDF_SUCCESS) { + return HDF_FAILURE; + } + + if (AudioCaptureTrigger(&card, AUDIO_DRV_PCM_IOCTL_CAPTURE_RESUME) == HDF_SUCCESS) { + return HDF_FAILURE; + } + return HDF_SUCCESS; +} + diff --git a/test/unittest/model/audio/src/audio_sapm_test.c b/test/unittest/model/audio/src/audio_sapm_test.c index 40a20d48cc64d9f2d7915db2306792280c73a0dd..999cd9533cc242bfd858a9039d63274bd4634558 100755 --- a/test/unittest/model/audio/src/audio_sapm_test.c +++ b/test/unittest/model/audio/src/audio_sapm_test.c @@ -10,7 +10,7 @@ #define HDF_LOG_TAG audio_host_test -int32_t AudioSapmTestNewComponents(void) +int32_t AudioSapmNewComponentsTest(void) { struct AudioCard *audioCard = NULL; struct AudioSapmComponent *component = NULL; @@ -27,7 +27,7 @@ int32_t AudioSapmTestNewComponents(void) return HDF_SUCCESS; } -int32_t AudioSapmTestAddRoutes(void) +int32_t AudioSapmAddRoutesTest(void) { struct AudioCard *audioCard = NULL; struct AudioSapmRoute *route = NULL; @@ -44,7 +44,7 @@ int32_t AudioSapmTestAddRoutes(void) return HDF_SUCCESS; } -int32_t AudioSapmTestNewControls(void) +int32_t AudioSapmNewControlsTest(void) { struct AudioCard *audioCard = NULL; int32_t ret; @@ -58,35 +58,111 @@ int32_t AudioSapmTestNewControls(void) HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } +int32_t AudioSapmSleepTest(void) +{ + struct AudioCard *audioCard = NULL; + int32_t ret; + HDF_LOGI("%s: enter", __func__); -int32_t AudioSapmTestPowerComponents(void) + ret = AudioSapmSleep(audioCard); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: AudioSapmSleep is NULL", __func__); + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioSampPowerUpTest(void) { struct AudioCard *audioCard = NULL; int32_t ret; HDF_LOGI("%s: enter", __func__); - ret = AudioSapmPowerComponents(audioCard); + ret = AudioSampPowerUp(audioCard); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: audioCard is NULL", __func__); + HDF_LOGE("%s: AudioSampPowerUp is NULL", __func__); } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } +int32_t AudioSampSetPowerMonitorTest(void) +{ + struct AudioCard *audioCard = NULL; + int32_t ret; + HDF_LOGI("%s: enter", __func__); + + ret = AudioSampSetPowerMonitor(audioCard, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: AudioSampSetPowerMonitor is NULL", __func__); + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} -int32_t AudioSapmTestRefreshTime(void) +int32_t AudioCodecSapmSetCtrlOpsTest(void) { - bool bRefresh = true; - u64 time; + int32_t ret; + struct AudioKcontrol *kcontrol = NULL; + struct AudioCtrlElemValue *elemValue = NULL; HDF_LOGI("%s: enter", __func__); - time = AudioSapmRefreshTime(bRefresh); - if (time == 0) { - HDF_LOGE("%s: error", __func__); + ret = AudioCodecSapmSetCtrlOps(kcontrol, elemValue); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: AudioCodecSapmSetCtrlOps is NULL", __func__); } HDF_LOGI("%s: success", __func__); return HDF_SUCCESS; } +int32_t AudioCodecSapmGetCtrlOpsTest(void) +{ + int32_t ret; + struct AudioKcontrol *kcontrol = NULL; + struct AudioCtrlElemValue *elemValue = NULL; + HDF_LOGI("%s: enter", __func__); + + ret = AudioCodecSapmGetCtrlOps(kcontrol, elemValue); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: AudioCodecSapmGetCtrlOps is NULL", __func__); + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioAccessorySapmSetCtrlOpsTest(void) +{ + int32_t ret; + struct AudioKcontrol *kcontrol = NULL; + struct AudioCtrlElemValue *elemValue = NULL; + HDF_LOGI("%s: enter", __func__); + + ret = AudioAccessorySapmSetCtrlOps(kcontrol, elemValue); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: AudioAccessorySapmSetCtrlOps is NULL", __func__); + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +int32_t AudioAccessorySapmGetCtrlOpsTest(void) +{ + int32_t ret; + struct AudioKcontrol *kcontrol = NULL; + struct AudioCtrlElemValue *elemValue = NULL; + HDF_LOGI("%s: enter", __func__); + + ret = AudioAccessorySapmGetCtrlOps(kcontrol, elemValue); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: AudioAccessorySapmGetCtrlOps is NULL", __func__); + } + + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} diff --git a/test/unittest/model/audio/src/audio_stream_dispatch_test.c b/test/unittest/model/audio/src/audio_stream_dispatch_test.c deleted file mode 100755 index 4d9d138c3c831c05d0de02198c586d3cbf4ed9ec..0000000000000000000000000000000000000000 --- a/test/unittest/model/audio/src/audio_stream_dispatch_test.c +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright (c) 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 "audio_stream_dispatch_test.h" -#include "audio_stream_dispatch.h" - -#define HDF_LOG_TAG audio_host_test - -int32_t AudioControlDispatchTestStreamDispatch(void) -{ - struct HdfDeviceIoClient *client = NULL; - struct HdfSBuf *data = NULL; - struct HdfSBuf *reply = NULL; - int32_t cmdId = 0; - int32_t ret; - HDF_LOGI("%s: enter", __func__); - - ret = StreamDispatch(client, cmdId, data, reply); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: (client || cmdId || data ||reply) is NULL", __func__); - } - - HDF_LOGI("%s: success", __func__); - return HDF_SUCCESS; -} - -int32_t AudioControlDispatchTestStreamHostDestroy(void) -{ - struct StreamHost *host = NULL; - HDF_LOGI("%s: enter", __func__); - - StreamHostDestroy(host); - - HDF_LOGI("%s: success", __func__); - return HDF_SUCCESS; -} diff --git a/test/unittest/model/audio/src/hdf_audio_test.c b/test/unittest/model/audio/src/hdf_audio_test.c index 72114884b47c7339eac7a41ed31535a063bbecd2..fb094602616bf1d38286d689c1a3965d357191f4 100755 --- a/test/unittest/model/audio/src/hdf_audio_test.c +++ b/test/unittest/model/audio/src/hdf_audio_test.c @@ -12,42 +12,125 @@ #include "audio_core_test.h" #include "audio_parse_test.h" #include "audio_sapm_test.h" -#include "audio_stream_dispatch_test.h" +#include "audio_dai_base_test.h" +#include "audio_dma_base_test.h" +#include "audio_dsp_base_test.h" +#include "audio_codec_base_test.h" +#include "audio_platform_base_test.h" +#include "audio_accessory_base_test.h" #define HDF_LOG_TAG hdf_audio_test // add test case entry static HdfTestCaseList g_hdfAudioTestCaseList[] = { - {AUDIO_DRIVER_TESTGETCODEC, AudioKcontrolTestGetCodec}, - {AUDIO_DRIVER_TESTGETCARDINSTANCE, GetCardTestInstance}, - {AUDIO_DRIVER_TESTHOSTDESTROY, AudioHostTestDestroy}, - {AUDIO_DRIVER_TESTGETCCNFIGDATA, AudioFillTestConfigData}, - {AUDIO_DRIVER_TESTREGISTERDAI, AudioSocTestRegisterDai}, - {AUDIO_DRIVER_TESTREGISTERPLATFORM, AudioSocTestRegisterPlatform}, - {AUDIO_DRIVER_TESTREGISTERCODEC, AudioTestRegisterCodec}, - {AUDIO_DRIVER_TESTBINDDAILINK, AudioTestBindDaiLink}, - {AUDIO_DRIVER_TESTDEVICEREGISTER, AudioTestSocDeviceRegister}, - {AUDIO_DRIVER_TESTREGISTERDSP, AudioTestSocRegisterDsp}, - {AUDIO_DRIVER_TESTREGISTERACCESSORY, AudioTestRegisterAccessory}, - {AUDIO_DRIVER_TESTUPDATEREGBITS, AudioTestUpdateRegBits}, - {AUDIO_DRIVER_TESTAIAOUPDATEREGBITS, AudioTestAiaoUpdateRegBits}, - {AUDIO_DRIVER_TESTKCONTROLGETCODEC, AudioTestKcontrolGetCodec}, - {AUDIO_DRIVER_TESTADDCONTROLS, AudioTestAddControls}, - {AUDIO_DRIVER_TESTADDCONTROL, AudioTestAddControl}, - {AUDIO_DRIVER_TESTDEVICEREADREG, AudioTestDeviceReadReg}, - {AUDIO_DRIVER_TESTAIAODEVICEREADREG, AudioTestAiaoDeviceReadReg}, - {AUDIO_DRIVER_TESTINFOCTRLSW, AudioTestInfoCtrlSw}, - {AUDIO_DRIVER_TESTGETCTRLSW, AudioTestGetCtrlSw}, - {AUDIO_DRIVER_TESTPUTCTRLSW, AudioTestPutCtrlSw}, - {AUDIO_DRIVER_TESTAIAOGETCTRLSW, AiaoTestGetCtrlSw}, - {AUDIO_DRIVER_TESTAIAOPUTCTRLSW, AiaoTestPutCtrlSw}, - {AUDIO_DRIVER_TESTNEWCOMPONENT, AudioSapmTestNewComponents}, - {AUDIO_DRIVER_TESTADDROUTES, AudioSapmTestAddRoutes}, - {AUDIO_DRIVER_TESTNEWCONTROLS, AudioSapmTestNewControls}, - {AUDIO_DRIVER_TESTPOWERCOMPONET, AudioSapmTestPowerComponents}, - {AUDIO_DRIVER_TESTREFRESHTIME, AudioSapmTestRefreshTime}, - {AUDIO_DRIVER_TESTSTREAMDISPATCH, AudioControlDispatchTestStreamDispatch}, - {AUDIO_DRIVER_TESTSTREAMDESTORY, AudioControlDispatchTestStreamHostDestroy}, + {AUDIO_ADM_TEST_AUDIOHOSTCREATEANDBIND, AudioHostCreateAndBindTest}, // audio ADM audio_host + {AUDIO_ADM_TEST_GETCARDINSTANCE, GetCardInstanceTest}, // audio ADM audio_host + + {AUDIO_ADM_TEST_AUDIOFILLCONFIGDATA, AudioFillConfigDataTest}, // audio ADM audio_parse + {AUDIO_ADM_TEST_CODECGETREGCONFIG, CodecGetRegConfigTest}, // audio ADM audio_parse + + {AUDIO_ADM_TEST_AUDIODEVICEREADREG, AudioDeviceReadRegTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIODEVICEWRITEREG, AudioDeviceWriteRegTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOSOCREGISTERPLATFORM, AudioSocRegisterPlatformTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOSOCREGISTERDAI, AudioSocRegisterDaiTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOREGISTERDSP, AudioRegisterDspTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOREGISTERCODEC, AudioRegisterCodecTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOREGISTERACCESSORY, AudioRegisterAccessoryTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOBINDDAILINK, AudioBindDaiLinkTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOUPDATECODECREGBITS, AudioUpdateCodecRegBitsTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOUPDATEACCESSORYREGBITS, AudioUpdateAccessoryRegBitsTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOUPDATEDAIREGBITS, AudioUpdateDaiRegBitsTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOKCONTROLGETCPUDAI, AudioKcontrolGetCpuDaiTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOKCONTROLGETCODEC, AudioKcontrolGetCodecTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOKCONTROLGETACCESSORY, AudioKcontrolGetAccessoryTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOADDCONTROLS, AudioAddControlsTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOADDCONTROL, AudioAddControlTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOGETCTRLOPSRREG, AudioGetCtrlOpsRRegTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOGETCTRLOPSREG, AudioGetCtrlOpsRegTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOSETCTRLOPSREG, AudioSetCtrlOpsRegTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOSETCTRLOPSRREG, AudioSetCtrlOpsRRegTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIODAIREADREG, AudioDaiReadRegTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIODAIWRITEREG, AudioDaiWriteRegTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOCODECREADREG, AudioCodecReadRegTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOCODECWRITEREG, AudioCodecWriteRegTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOACCESSORYREADREG, AudioAccessoryReadRegTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOACCESSORYWRITEREG, AudioAccessoryWriteRegTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOINFOCTRLOPS, AudioInfoCtrlOpsTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOCODECGETCTRLOPS, AudioCodecGetCtrlOpsTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOCODECSETCTRLOPS, AudioCodecSetCtrlOpsTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOACCESSORYGETCTRLOPS, AudioAccessoryGetCtrlOpsTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOACCESSORYSETCTRLOPS, AudioAccessorySetCtrlOpsTset}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOCPUDAISETCTRLOPS, AudioCpuDaiSetCtrlOpsTest}, // audio ADM audio_core + {AUDIO_ADM_TEST_AUDIOCPUDAIGETCTRLOPS, AudioCpuDaiGetCtrlOpsTest}, // audio ADM audio_core + + {AUDIO_ADM_TEST_AUDIOSAPMNEWCOMPONENTS, AudioSapmNewComponentsTest}, // audio ADM audio_sapm + {AUDIO_ADM_TEST_AUDIOSAPMADDROUTES, AudioSapmAddRoutesTest}, // audio ADM audio_sapm + {AUDIO_ADM_TEST_AUDIOSAPMNEWCONTROLS, AudioSapmNewControlsTest}, // audio ADM audio_sapm + {AUDIO_ADM_TEST_AUDIOSAPMSLEEP, AudioSapmSleepTest}, // audio ADM audio_sapm + {AUDIO_ADM_TEST_AUDIOSAMPPOWERUP, AudioSampPowerUpTest}, // audio ADM audio_sapm + {AUDIO_ADM_TEST_AUDIOSAMPSETPOWERMONITOR, AudioSampSetPowerMonitorTest}, // audio ADM audio_sapm + {AUDIO_ADM_TEST_AUDIOCODECSAPMSETCTRLOPS, AudioCodecSapmSetCtrlOpsTest}, // audio ADM audio_sapm + {AUDIO_ADM_TEST_AUDIOCODECSAPMGETCTRLOPS, AudioCodecSapmGetCtrlOpsTest}, // audio ADM audio_sapm + {AUDIO_ADM_TEST_AUDIOACCESSORYSAPMSETCTRLOPS, AudioAccessorySapmSetCtrlOpsTest}, // audio ADM audio_sapm + {AUDIO_ADM_TEST_AUDIOACCESSORYSAPMGETCTRLOPS, AudioAccessorySapmGetCtrlOpsTest}, // audio ADM audio_sapm + + {AUDIO_ADM_TEST_I2CREADWRITE, AccessoryI2cReadWriteTest}, + {AUDIO_ADM_TEST_REGBITSREAD, AccessoryRegBitsReadTest}, + {AUDIO_ADM_TEST_REGBITSUPDATE, AccessoryRegBitsUpdateTest}, + {AUDIO_ADM_TEST_DEVICEFREQUENCYPARSE, AcessoryDeviceFrequencyParseTest}, + {AUDIO_ADM_TEST_DAIPARAMSUPDATE, AccessoryDaiParamsUpdateTest}, + {AUDIO_ADM_TEST_DEVICECFGGET, AccessoryDeviceCfgGetTest}, + {AUDIO_ADM_TEST_DEVICECTRLREGINIT, AccessoryDeviceCtrlRegInitTest}, + {AUDIO_ADM_TEST_DEVICEREGREAD, AccessoryDeviceRegReadTest}, + {AUDIO_ADM_TEST_DEVICEREGWRITE, AccessoryDeviceRegWriteTest}, + {AUDIO_ADM_TEST_AGETCONFIGINFO, AccessoryGetConfigInfoTest}, + + {AUDIO_ADM_TEST_GETSERVICENAME, CodecGetServiceNameTest}, + {AUDIO_ADM_TEST_GETDAINAME, CodecGetDaiNameTest}, + {AUDIO_ADM_TEST_GETCONFIGINFO, CodecGetConfigInfoTest}, + {AUDIO_ADM_TEST_SETCONFIGINFO, CodecSetConfigInfoTest}, + {AUDIO_ADM_TEST_SETCTLFUNC, CodecSetCtlFuncTest}, + + {AUDIO_ADM_TEST_DAIDATAFROMCARD, DaiDataFromCardTest}, + {AUDIO_ADM_TEST_DAIGETCONFIGINFO, DaiGetConfigInfoTest}, + {AUDIO_ADM_TEST_DAICHECKSAMPLERATE, DaiCheckSampleRateTest}, + {AUDIO_ADM_TEST_DAISETCONFIGINFO, DaiSetConfigInfoTest}, + + {AUDIO_ADM_TEST_DMABUFALLOC, AudioDmaBufAllocTest}, + {AUDIO_ADM_TEST_DMABUFFREE, AudioDmaBufFreeTest}, + {AUDIO_ADM_TEST_DMAREQUESTCHANNEL, AudioDmaRequestChannelTest}, + {AUDIO_ADM_TEST_DMACONFIGCHANNEL, AudioDmaConfigChannelTest}, + {AUDIO_ADM_TEST_DMAPREP, AudioDmaPrepTest}, + {AUDIO_ADM_TEST_DMASUBMIT, AudioDmaSubmitTest}, + {AUDIO_ADM_TEST_DMAPENDING, AudioDmaPendingTest}, + {AUDIO_ADM_TEST_DMAPAUSE, AudioDmaPauseTest}, + {AUDIO_ADM_TEST_DMARESUME, AudioDmaResumeTest}, + {AUDIO_ADM_TEST_DMAPOINTER, AudioDmaPointerTest}, + + {AUDIO_ADM_TEST_DSPGETSERVICENAME, DspGetServiceNameTest}, + {AUDIO_ADM_TEST_DSPGETDAINAME, DspGetDaiNameTest}, + + {AUDIO_ADM_TEST_DATAFROMCARD, PlatformDataFromCardTest}, + {AUDIO_ADM_TEST_BYTESTOFRAMES, AudioBytesToFramesTest}, + {AUDIO_ADM_TEST_DATABIGENDIANCHANGE, AudioDataBigEndianChangeTest}, + {AUDIO_ADM_TEST_FRAMATTOBITWIDTH, AudioFramatToBitWidthTest}, + {AUDIO_ADM_TEST_SETPCMINFO, AudioSetPcmInfoTest}, + {AUDIO_ADM_TEST_SETRENDERBUFINFO, AudioSetRenderBufInfoTest}, + {AUDIO_ADM_TEST_SETCAPTUREBUFINFO, AudioSetCaptureBufInfoTest}, + {AUDIO_ADM_TEST_PCMWRITE, AudioPcmWriteTest}, + {AUDIO_ADM_TEST_PCMREAD, AudioPcmReadTest}, + {AUDIO_ADM_TEST_PCMMMAPWRITE, AudioPcmMmapWriteTest}, + {AUDIO_ADM_TEST_PCMMMAPREAD, AudioPcmMmapReadTest}, + {AUDIO_ADM_TEST_RENDEROPEN, AudioRenderOpenTest}, + {AUDIO_ADM_TEST_CAPTUREOPEN, AudioCaptureOpenTest}, + {AUDIO_ADM_TEST_RENDERCLOSE, AudioRenderCloseTest}, + {AUDIO_ADM_TEST_PCMPOINTER, AudioPcmPointerTest}, + {AUDIO_ADM_TEST_CAPTURECLOSE, AudioCaptureCloseTest}, + {AUDIO_ADM_TEST_HWPARAMS, AudioHwParamsTest}, + {AUDIO_ADM_TEST_RENDERPREPARE, AudioRenderPrepareTest}, + {AUDIO_ADM_TEST_CAPTUREPREPARE, AudioCapturePrepareTest}, + {AUDIO_ADM_TEST_RENDERTRIGGER, AudioRenderTriggerTest}, + {AUDIO_ADM_TEST_CAPTURETRIGGER, AudioCaptureTriggerTest} }; int32_t HdfAudioEntry(HdfTestMsg *msg) diff --git a/test/unittest/model/network/wifi/unittest/message/hdf_queue_test.c b/test/unittest/model/network/wifi/unittest/message/hdf_queue_test.c index 04b2f5ccd110ed9875114a986257e99cf4acd038..af57a8ed13df3c36b26db2b59dad163e111d206f 100644 --- a/test/unittest/model/network/wifi/unittest/message/hdf_queue_test.c +++ b/test/unittest/model/network/wifi/unittest/message/hdf_queue_test.c @@ -27,6 +27,7 @@ int32_t MessageQueueTest001(void) int c = 3; int d = 4; int32_t errCode; + void *p = NULL; PriorityQueue *queue = CreatePriorityQueue(TEST_QUEUE_SIZE, NO_PRIORITY); if (queue == NULL) { HDF_LOGE("%s:Create queue failed!", __func__); @@ -45,7 +46,7 @@ int32_t MessageQueueTest001(void) errCode = PushPriorityQueue(queue, 0, &d); MSG_BREAK_IF_NOT_SUCCESS(errCode); - void *p = PopPriorityQueue(queue, 0); + p = PopPriorityQueue(queue, 0); MSG_BREAK_IF(errCode, p == NULL); MSG_BREAK_IF(errCode, p != &a); @@ -75,7 +76,9 @@ int32_t MessageQueueTest002(void) int c = 3; int d = 4; int32_t errCode; - PriorityQueue *queue = CreatePriorityQueue(TEST_QUEUE_SIZE, MUTI_PRIORITY); + void *p = NULL; + PriorityQueue *queue = NULL; + queue = CreatePriorityQueue(TEST_QUEUE_SIZE, MUTI_PRIORITY); if (queue == NULL) { HDF_LOGE("%s:Create queue failed!", __func__); return -1; @@ -93,7 +96,7 @@ int32_t MessageQueueTest002(void) errCode = PushPriorityQueue(queue, 0, &d); MSG_BREAK_IF_NOT_SUCCESS(errCode); - void *p = PopPriorityQueue(queue, 0); + p = PopPriorityQueue(queue, 0); MSG_BREAK_IF(errCode, p == NULL); MSG_BREAK_IF(errCode, p != &a); @@ -130,20 +133,22 @@ static int RunPushQueue(void *para) int32_t MessageQueueTest003(void) { int32_t errCode = HDF_SUCCESS; - PriorityQueue *queue = CreatePriorityQueue(TEST_QUEUE_SIZE, NO_PRIORITY); + void *p = NULL; + PriorityQueue *queue = NULL; + int32_t status; + struct OsalThreadParam config; + OSAL_DECLARE_THREAD(pushThread); + queue = CreatePriorityQueue(TEST_QUEUE_SIZE, NO_PRIORITY); if (queue == NULL) { HDF_LOGE("%s:Create queue failed!", __func__); return -1; } - OSAL_DECLARE_THREAD(pushThread); + do { - struct OsalThreadParam config = { - .name = "PushQueueWithDelay", - .priority = OSAL_THREAD_PRI_DEFAULT, - .stackSize = 0x1000, - }; - - int32_t status = OsalThreadCreate(&pushThread, RunPushQueue, queue); + config.name = "PushQueueWithDelay"; + config.priority = OSAL_THREAD_PRI_DEFAULT; + config.stackSize = 0x1000; + status = OsalThreadCreate(&pushThread, RunPushQueue, queue); if (status != HDF_SUCCESS) { HDF_LOGE("%s:OsalThreadCreate failed!status=%d", __func__, status); errCode = HDF_FAILURE; @@ -157,7 +162,7 @@ int32_t MessageQueueTest003(void) break; } - void *p = PopPriorityQueue(queue, POP_TIMEOUT); + p = PopPriorityQueue(queue, POP_TIMEOUT); MSG_BREAK_IF(errCode, p == NULL); MSG_BREAK_IF(errCode, p != &g_testValue); } while (false); diff --git a/test/unittest/model/network/wifi/unittest/message/hdf_single_node_message_test.c b/test/unittest/model/network/wifi/unittest/message/hdf_single_node_message_test.c index dc017718f8a12ccfa79e1251174283b8bd9bfec9..92c875e9d0f3930e368c29a5c0fad584b1764a5e 100644 --- a/test/unittest/model/network/wifi/unittest/message/hdf_single_node_message_test.c +++ b/test/unittest/model/network/wifi/unittest/message/hdf_single_node_message_test.c @@ -16,7 +16,7 @@ const uint32_t SEND_MESSAGE_COUNT = 40000; const uint32_t SYNC_MESSAGE_TIMEOUT = 2; -const uint32_t ASYNC_MESSAGE_TIMEOUT = 2; +const uint32_t ASYNC_MESSAGE_TIMEOUT = 8; #define COMMON_SEM_TIMEOUT 300 enum ServiceList { diff --git a/test/unittest/model/network/wifi/unittest/module/hdf_module_test.c b/test/unittest/model/network/wifi/unittest/module/hdf_module_test.c index 858bff8fa35ca4a0cf60ddec42295eb26e05825e..cf4255f7e86cd3c8c348a6ad32b2932ccaa72ff0 100644 --- a/test/unittest/model/network/wifi/unittest/module/hdf_module_test.c +++ b/test/unittest/model/network/wifi/unittest/module/hdf_module_test.c @@ -76,12 +76,13 @@ static int32_t WiFiModuleTestSetEnv(void) int32_t WiFiModuleTestCreateModule(void) { int32_t ret; + struct WifiModule *module = NULL; ret = WiFiModuleTestSetEnv(); if (ret != HDF_SUCCESS) { HDF_LOGE("%s:WiFiModuleTestSetEnv failed.ret=%d", __func__, ret); return ret; } - struct WifiModule *module = OsalMemCalloc(sizeof(struct WifiModule)); + module = OsalMemCalloc(sizeof(struct WifiModule)); if (module == NULL) { HDF_LOGE("%s fail WifiModuleCreate FAIL ", __func__); return HDF_FAILURE; diff --git a/test/unittest/model/network/wifi/unittest/net/hdf_netbuf_test.c b/test/unittest/model/network/wifi/unittest/net/hdf_netbuf_test.c index e82ab80d54e1727dcd8f988b873e862f5f4da7cc..fc8c15724f106371babd7aab7850839aa5484b01 100644 --- a/test/unittest/model/network/wifi/unittest/net/hdf_netbuf_test.c +++ b/test/unittest/model/network/wifi/unittest/net/hdf_netbuf_test.c @@ -16,8 +16,8 @@ #define DEFAULT_TAIL_SIZE 20 #define DEFAULT_MAPPING_QUEUE 10 #define DEFAULT_TRIM_SIZE 3 -#define DEFAULT_SECTION_SIZE 3 - +#define DEFAULT_SECTION_SIZE 10 + #define MAX_MEM_ALLOC_SIZE 0x7fffffff typedef int32_t (*pTestCaseFunc)(void); diff --git a/test/unittest/model/usb/device/include/usb_device_lite_cdcacm_test.h b/test/unittest/model/usb/device/include/usb_device_lite_cdcacm_test.h old mode 100644 new mode 100755 index e28d2ad985e9988584bc64dd5858608db83e405d..68e8ca4c40b89214a7906dffcc860f6c89d9f00e --- a/test/unittest/model/usb/device/include/usb_device_lite_cdcacm_test.h +++ b/test/unittest/model/usb/device/include/usb_device_lite_cdcacm_test.h @@ -31,9 +31,9 @@ #define WAIT_100MS 100 #define SYNC_5000MS 5000 #define CDC_ACM -#define QUEUE_SIZE 8 +#define QUEUE_SIZE 8 #define PORT_RATE 9600 -#define CHAR_FORMAT 8 +#define DATA_BIT 8 #define SS_MAX_PACKET_SIZE 1024 #define MAX_PACKET_SIZE 512 @@ -52,6 +52,8 @@ #define ACM_DATA_IDX 2 #define ACM_IAD_IDX 3 +#define REQUEST_ALLOC_PIPE ((uint8_t)(0x20)) +#define REQUEST_ALLOC_LENGTH ((uint32_t)(0x0800)) struct Serial { struct AcmDevice *acm; @@ -126,13 +128,13 @@ struct CtrlInfo { struct AcmDevice *acm; }; -extern struct UsbFnDeviceDesc g_acmFnDevice; struct AcmDevice *SetUpAcmDevice(void); void ReleaseAcmDevice(struct AcmDevice *acm); void AcmEventCallback(struct UsbFnEvent *event); void AcmDeviceRelease(struct AcmDevice *acmDevice); int remove_usb_device(void); +struct AcmDevice *UsbGetAcmDevice(void); int32_t UsbFnDviceTestCreate(void); int32_t UsbFnDviceTestCreate002(void); int32_t UsbFnDviceTestCreate003(void); diff --git a/test/unittest/model/usb/device/src/usb_device_lite_cdcacm_test.c b/test/unittest/model/usb/device/src/usb_device_lite_cdcacm_test.c index 841d89300ba89c3fa3fa7857db85e4086892d9f8..a6254e7785917fbb1221064a98a88f5825436cd6 100755 --- a/test/unittest/model/usb/device/src/usb_device_lite_cdcacm_test.c +++ b/test/unittest/model/usb/device/src/usb_device_lite_cdcacm_test.c @@ -329,19 +329,48 @@ static struct Serial *SerialAlloc(void) DListHeadInit(&port->writePool); port->lineCoding.dwDTERate = CpuToLe32(PORT_RATE); - port->lineCoding.bCharFormat = CHAR_FORMAT; + port->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS; port->lineCoding.bParityType = USB_CDC_NO_PARITY; - port->lineCoding.bDataBits = USB_CDC_1_STOP_BITS; + port->lineCoding.bDataBits = DATA_BIT; return port; } +static void ParsePipes(struct AcmDevice *acmDevice, const struct UsbFnInterface *fnIface, UsbFnInterfaceHandle handle) +{ + uint32_t j; + int ret; + struct UsbFnPipeInfo pipeInfo = {0}; + for (j = 0; j < fnIface->info.numPipes; j++) { + ret = UsbFnGetInterfacePipeInfo((struct UsbFnInterface *)fnIface, j, &pipeInfo); + if (ret != HDF_SUCCESS) { + return; + } + if (pipeInfo.type == USB_PIPE_TYPE_INTERRUPT) { + acmDevice->notifyPipe.id = pipeInfo.id; + acmDevice->notifyPipe.maxPacketSize = pipeInfo.maxPacketSize; + acmDevice->ctrlIface.fn = (struct UsbFnInterface *)fnIface; + acmDevice->ctrlIface.handle = handle; + } else if (pipeInfo.type == USB_PIPE_TYPE_BULK) { + if (pipeInfo.dir == USB_PIPE_DIRECTION_IN) { + acmDevice->dataInPipe.id = pipeInfo.id; + acmDevice->dataInPipe.maxPacketSize = pipeInfo.maxPacketSize; + acmDevice->dataIface.fn = (struct UsbFnInterface *)fnIface; + acmDevice->dataIface.handle = handle; + } else { + acmDevice->dataOutPipe.id = pipeInfo.id; + acmDevice->dataOutPipe.maxPacketSize = pipeInfo.maxPacketSize; + acmDevice->dataIface.fn = (struct UsbFnInterface *)fnIface; + acmDevice->dataIface.handle = handle; + } + } + } +} + static int ParseInterfaces(struct AcmDevice *acmDevice) { uint32_t i; - uint32_t j; struct UsbFnInterface *fnIface = NULL; - UsbFnInterfaceHandle handle = NULL; - int ret; + UsbFnInterfaceHandle handle; for (i = 0; i < acmDevice->fnDev->numInterfaces; i++) { fnIface = (struct UsbFnInterface *)UsbFnGetInterface(acmDevice->fnDev, i); @@ -352,45 +381,20 @@ static int ParseInterfaces(struct AcmDevice *acmDevice) if (handle == NULL) { return -1; } - for (j = 0; j < fnIface->info.numPipes; j++) { - struct UsbFnPipeInfo pipeInfo; - ret = UsbFnGetInterfacePipeInfo(fnIface, j, &pipeInfo); - if (ret != HDF_SUCCESS) { - return -1; - } - if (pipeInfo.type == USB_PIPE_TYPE_INTERRUPT) { - acmDevice->notifyPipe.id = pipeInfo.id; - acmDevice->notifyPipe.maxPacketSize = pipeInfo.maxPacketSize; - acmDevice->ctrlIface.fn = fnIface; - acmDevice->ctrlIface.handle = handle; - } else if (pipeInfo.type == USB_PIPE_TYPE_BULK) { - if (pipeInfo.dir == USB_PIPE_DIRECTION_IN) { - acmDevice->dataInPipe.id = pipeInfo.id; - acmDevice->dataInPipe.maxPacketSize = pipeInfo.maxPacketSize; - acmDevice->dataIface.fn = fnIface; - acmDevice->dataIface.handle = handle; - } else { - acmDevice->dataOutPipe.id = pipeInfo.id; - acmDevice->dataOutPipe.maxPacketSize = pipeInfo.maxPacketSize; - acmDevice->dataIface.fn = fnIface; - acmDevice->dataIface.handle = handle; - } - } - } + ParsePipes(acmDevice, fnIface, handle); } return 0; } static void CtrlComplete(uint8_t pipe, struct UsbFnRequest *req) { - struct CtrlInfo *ctrlInfo = (struct CtrlInfo *)req->context; - struct AcmDevice *acm = ctrlInfo->acm; - if (req == NULL) { return; } + struct CtrlInfo *ctrlInfo = (struct CtrlInfo *)req->context; + struct AcmDevice *acm = ctrlInfo->acm; if (USB_REQUEST_COMPLETED != req->status) { - goto out; + goto OUT; } if (ctrlInfo->request == USB_DDK_CDC_REQ_SET_LINE_CODING) { @@ -400,7 +404,7 @@ static void CtrlComplete(uint8_t pipe, struct UsbFnRequest *req) } acm->connect = true; } -out: +OUT: DListInsertTail(&req->list, &acm->ctrlPool); } @@ -436,12 +440,16 @@ static int AllocCtrlRequests(struct AcmDevice *acmDevice) } static int32_t SendNotifyRequest(struct AcmDevice *acm, uint8_t type, - uint16_t value, void *data, uint32_t length) + uint16_t value, const uint16_t *data, uint32_t length) { - struct UsbFnRequest *req = acm->notifyReq; + struct UsbFnRequest *req = NULL; struct UsbCdcNotification *notify = NULL; int ret; - if (acm == NULL || req->buf) { + if ((data == NULL) || (acm == NULL) || (acm->ctrlIface.fn == NULL)) { + return -1; + } + req = acm->notifyReq; + if ((req == NULL) || (req->buf == NULL)) { return -1; } acm->notifyReq = NULL; @@ -454,7 +462,13 @@ static int32_t SendNotifyRequest(struct AcmDevice *acm, uint8_t type, notify->wValue = CpuToLe16(value); notify->wIndex = CpuToLe16(acm->ctrlIface.fn->info.index); notify->wLength = CpuToLe16(length); - memcpy_s((void *)(notify + 1), length, data, length); + if (((void *)(notify + 1) == NULL) || (length == 0)) { + return HDF_FAILURE; + } + ret = memcpy_s((void *)(notify + 1), length, data, length); + if (ret != EOK) { + HDF_LOGE("%s: memcpy_s fail, ret=%d", __func__, ret); + } ret = UsbFnSubmitRequestAsync(req); return ret; @@ -587,7 +601,7 @@ static struct UsbFnRequest *GetCtrlReq(struct AcmDevice *acm) return req; } -static void Setup(struct AcmDevice *acm, struct UsbFnCtrlRequest *setup) +static int Setup(struct AcmDevice *acm, const struct UsbFnCtrlRequest *setup) { struct UsbFnRequest *req = NULL; struct CtrlInfo *ctrlInfo = NULL; @@ -596,12 +610,12 @@ static void Setup(struct AcmDevice *acm, struct UsbFnCtrlRequest *setup) int ret = 0; req = GetCtrlReq(acm); if (req == NULL) { - return; + return ret; } switch (setup->request) { case USB_DDK_CDC_REQ_SET_LINE_CODING: if (length != sizeof(struct UsbCdcLineCoding)) { - goto out; + goto OUT; } ret = length; break; @@ -611,7 +625,9 @@ static void Setup(struct AcmDevice *acm, struct UsbFnCtrlRequest *setup) if (acm->lineCoding.dwDTERate == 0) { acm->lineCoding = acm->port->lineCoding; } - memcpy_s(req->buf, req->length, &acm->lineCoding, ret); + if (memcpy_s(req->buf, req->length, &acm->lineCoding, ret) != EOK) { + HDF_LOGE("%s:%d memcpy_s fail", __func__, __LINE__); + } break; case USB_DDK_CDC_REQ_SET_CONTROL_LINE_STATE: ret = 0; @@ -621,11 +637,12 @@ static void Setup(struct AcmDevice *acm, struct UsbFnCtrlRequest *setup) break; } -out: +OUT: ctrlInfo = (struct CtrlInfo *)req->context; ctrlInfo->request = setup->request; req->length = ret; ret = UsbFnSubmitRequestAsync(req); + return ret; } static void Suspend(struct AcmDevice *acm) diff --git a/test/unittest/model/usb/device/src/usb_device_lite_sdk_if_test.c b/test/unittest/model/usb/device/src/usb_device_lite_sdk_if_test.c old mode 100644 new mode 100755 index 3a2e38ac24ffab11fe549a3c20962224a185af68..9f46ec60cbc0507e3f66cd33ab97bd1937291361 --- a/test/unittest/model/usb/device/src/usb_device_lite_sdk_if_test.c +++ b/test/unittest/model/usb/device/src/usb_device_lite_sdk_if_test.c @@ -17,9 +17,13 @@ #define HDF_LOG_TAG usb_device_sdk_test -static struct AcmDevice *g_acmDevice = NULL; +struct AcmDevice *g_acmDevice = NULL; +extern struct UsbFnDeviceDesc g_acmFnDevice; -#include "usb_device_lite_sdk_io_test.c" +struct AcmDevice *UsbGetAcmDevice(void) +{ + return g_acmDevice; +} int32_t UsbFnDviceTestCreate(void) { @@ -945,6 +949,10 @@ int32_t UsbFnDviceTestAllocCtrlRequest005(void) struct UsbFnRequest *req = NULL; UsbFnInterfaceHandle handle = NULL; + if (g_acmDevice == NULL) { + HDF_LOGE("%s: dataIface.handle is invail", __func__); + return HDF_FAILURE; + } req = UsbFnAllocCtrlRequest(handle, g_acmDevice->notifyPipe.maxPacketSize); if (req != NULL) { @@ -1092,6 +1100,10 @@ int32_t UsbFnDviceTestAllocRequest004(void) struct UsbFnRequest *req = NULL; UsbFnInterfaceHandle handle = NULL; + if (g_acmDevice == NULL) { + HDF_LOGE("%s: dataIface.handle is invail", __func__); + return HDF_FAILURE; + } req = UsbFnAllocRequest(handle, g_acmDevice->notifyPipe.id, 0x800); if (req != NULL) { HDF_LOGE("%s: alloc req success!!", __func__); @@ -1113,7 +1125,7 @@ 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, REQUEST_ALLOC_PIPE, REQUEST_ALLOC_LENGTH); if (req != NULL) { HDF_LOGE("%s: alloc req success!!", __func__); ret = UsbFnFreeRequest(req); @@ -1174,12 +1186,13 @@ int32_t UsbFnDviceTestAllocRequest008(void) { int ret; struct UsbFnRequest *req = NULL; + uint32_t length; if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { HDF_LOGE("%s: ctrlIface.handle is invail", __func__); return HDF_FAILURE; } - req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, - 0x20, g_acmDevice->dataOutPipe.maxPacketSize); + length = g_acmDevice->dataOutPipe.maxPacketSize; + req = UsbFnAllocRequest(g_acmDevice->dataIface.handle, REQUEST_ALLOC_PIPE, length); if (req != NULL) { HDF_LOGE("%s: alloc req success!!", __func__); ret = UsbFnFreeRequest(req); @@ -1593,6 +1606,11 @@ int32_t UsbFnDviceTestStartReceEvent003(void) { int ret; struct UsbFnInterface *fn = NULL; + + if (g_acmDevice == NULL) { + HDF_LOGE("%s: dataIface.handle is invail", __func__); + return HDF_FAILURE; + } ret = UsbFnStartRecvInterfaceEvent(fn, 0xff, EventCallBack, g_acmDevice); if (HDF_SUCCESS == ret) { @@ -1817,6 +1835,10 @@ int32_t UsbFnDviceTestCloseInterface003(void) { int ret; + if (g_acmDevice == NULL) { + HDF_LOGE("%s: dataIface.handle is invail", __func__); + return HDF_FAILURE; + } ret = UsbFnCloseInterface(g_acmDevice->ctrlIface.handle); if (HDF_SUCCESS == ret) { HDF_LOGE("%s: close interface success!!", __func__); @@ -1830,6 +1852,10 @@ int32_t UsbFnDviceTestCloseInterface004(void) { int ret; + if (g_acmDevice == NULL) { + HDF_LOGE("%s: dataIface.handle is invail", __func__); + return HDF_FAILURE; + } ret = UsbFnCloseInterface(g_acmDevice->dataIface.handle); if (HDF_SUCCESS == ret) { HDF_LOGE("%s: close interface success!!", __func__); 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 old mode 100644 new mode 100755 index a806584e8d1ed91da05fcd97c8b16d1b5779344f..a2532a60622879297f0d8ef5487bb8f6dc3050c3 --- 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 @@ -12,10 +12,14 @@ * See the License for the specific language governing permissions and * limitations under the License. */ +#include "usb_device_lite_cdcacm_test.h" + +#define HDF_LOG_TAG usb_device_sdk_test static void ReadComplete(uint8_t pipe, struct UsbFnRequest *req) { - if (NULL == req) { + struct AcmDevice *acmDevice = UsbGetAcmDevice(); + if ((req == NULL) || (acmDevice == NULL)) { return; } if (req->actual) { @@ -24,10 +28,10 @@ static void ReadComplete(uint8_t pipe, struct UsbFnRequest *req) 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; + acmDevice->submitExit = 1; } } - g_acmDevice->submit = 1; + acmDevice->submit = 1; } int32_t UsbFnDviceTestRequestAsync(void) @@ -48,31 +52,32 @@ int32_t UsbFnDviceTestRequestAsync002(void) struct UsbFnRequest *req = NULL; int ret = HDF_SUCCESS; int ret1; - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + struct AcmDevice *acmDevice = UsbGetAcmDevice(); + if (acmDevice == NULL || 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); + req = UsbFnAllocRequest(acmDevice->dataIface.handle, acmDevice->dataOutPipe.id, + 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) { + req->context = acmDevice; + while (acmDevice->connect == false) { OsalMSleep(WAIT_100MS); } while (1) { - g_acmDevice->submit = 0; + 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) { + while (acmDevice->submit == 0) { OsalMSleep(WAIT_100MS); } if (req->actual > 0) { @@ -92,32 +97,33 @@ int32_t UsbFnDviceTestRequestAsync003(void) struct UsbFnRequest *req = NULL; int ret = HDF_SUCCESS; int ret1; - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + struct AcmDevice *acmDevice = UsbGetAcmDevice(); + if (acmDevice == NULL || 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); + req = UsbFnAllocRequest(acmDevice->dataIface.handle, acmDevice->dataOutPipe.id, + 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) { + req->context = acmDevice; + while (acmDevice->connect == false) { OsalMSleep(WAIT_100MS); } - g_acmDevice->submitExit = 0; - while (g_acmDevice->submitExit == 0) { - g_acmDevice->submit = 0; + acmDevice->submitExit = 0; + while (acmDevice->submitExit == 0) { + 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) { + while (acmDevice->submit == 0) { OsalMSleep(WAIT_100MS); } } @@ -131,40 +137,54 @@ int32_t UsbFnDviceTestRequestAsync003(void) static void WriteComplete(uint8_t pipe, struct UsbFnRequest *req) { + struct AcmDevice *acmDevice = UsbGetAcmDevice(); + if (acmDevice == NULL) { + return; + } dprintf("write data status = %d\n", req->status); - g_acmDevice->submit = 1; + acmDevice->submit = 1; } int32_t UsbFnDviceTestRequestAsync004(void) { struct UsbFnRequest *req = NULL; int ret; + struct AcmDevice *acmDevice = UsbGetAcmDevice(); - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + if (acmDevice == NULL || 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); + req = UsbFnAllocRequest(acmDevice->dataIface.handle, acmDevice->dataInPipe.id, + 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; + req->context = acmDevice; + acmDevice->submit = 0; dprintf("------send \"abc\" to host------\n"); - memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "abc", strlen("abc")); + if (acmDevice->dataInPipe.maxPacketSize < strlen("abc")) { + ret = UsbFnFreeRequest(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: free Request error", __func__); + } + return HDF_FAILURE; + } + if (memcpy_s(req->buf, acmDevice->dataInPipe.maxPacketSize, "abc", strlen("abc")) != EOK) { + HDF_LOGE("%s:%d memcpy_s fail", __func__, __LINE__); + } 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) { + while (acmDevice->submit == 0) { OsalMSleep(1); } - g_acmDevice->submit = 0; + acmDevice->submit = 0; ret = UsbFnFreeRequest(req); if (HDF_SUCCESS != ret) { HDF_LOGE("%s: free Request error", __func__); @@ -178,33 +198,36 @@ int32_t UsbFnDviceTestRequestAsync005(void) struct UsbFnRequest *req = NULL; int loopTime = TEST_TIMES; int ret; + struct AcmDevice *acmDevice = UsbGetAcmDevice(); - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + if (acmDevice == NULL || 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); + req = UsbFnAllocRequest(acmDevice->dataIface.handle, acmDevice->dataInPipe.id, + 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->context = acmDevice; + acmDevice->submit = 0; + if (memcpy_s(req->buf, acmDevice->dataInPipe.maxPacketSize, "xyz", strlen("xyz")) != EOK) { + HDF_LOGE("%s:%d memcpy_s fail", __func__, __LINE__); + } 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) { + while (acmDevice->submit == 0) { OsalMSleep(1); } - g_acmDevice->submit = 0; + acmDevice->submit = 0; ret = UsbFnFreeRequest(req); if (HDF_SUCCESS != ret) { HDF_LOGE("%s: free Request error", __func__); @@ -236,13 +259,14 @@ int32_t UsbFnDviceTestRequestSync002(void) struct UsbFnRequest *req = NULL; int ret; uint8_t *data = NULL; - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + struct AcmDevice *acmDevice = UsbGetAcmDevice(); + if (acmDevice == NULL || 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); + req = UsbFnAllocRequest(acmDevice->dataIface.handle, acmDevice->dataOutPipe.id, + acmDevice->dataOutPipe.maxPacketSize); if (req == NULL) { HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; @@ -269,13 +293,14 @@ int32_t UsbFnDviceTestRequestSync003(void) int ret; int submitExit = 0; uint8_t *data = NULL; - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + struct AcmDevice *acmDevice = UsbGetAcmDevice(); + if (acmDevice == NULL || 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); + req = UsbFnAllocRequest(acmDevice->dataIface.handle, acmDevice->dataOutPipe.id, + acmDevice->dataOutPipe.maxPacketSize); if (req == NULL) { HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; @@ -306,19 +331,22 @@ int32_t UsbFnDviceTestRequestSync004(void) { struct UsbFnRequest *req = NULL; int ret; + struct AcmDevice *acmDevice = UsbGetAcmDevice(); - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + if (acmDevice == NULL || 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); + req = UsbFnAllocRequest(acmDevice->dataIface.handle, acmDevice->dataInPipe.id, + 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")); + if (memcpy_s(req->buf, acmDevice->dataInPipe.maxPacketSize, "abc", strlen("abc")) != EOK) { + HDF_LOGE("%s:%d memcpy_s fail", __func__, __LINE__); + } req->length = strlen("abc"); ret = UsbFnSubmitRequestSync(req, 0); if (HDF_SUCCESS != ret || (req->actual != strlen("abc")) || \ @@ -339,20 +367,23 @@ int32_t UsbFnDviceTestRequestSync005(void) struct UsbFnRequest *req = NULL; int loopTime = TEST_TIMES; int ret; + struct AcmDevice *acmDevice = UsbGetAcmDevice(); - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + if (acmDevice == NULL || 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); + req = UsbFnAllocRequest(acmDevice->dataIface.handle, acmDevice->dataInPipe.id, + 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")); + if (memcpy_s(req->buf, acmDevice->dataInPipe.maxPacketSize, "abcdefg", strlen("abcdefg")) != EOK) { + HDF_LOGE("%s:%d memcpy_s fail", __func__, __LINE__); + } req->length = strlen("abcdefg"); ret = UsbFnSubmitRequestSync(req, 0); if (HDF_SUCCESS != ret || (req->actual != strlen("abcdefg")) || \ @@ -373,13 +404,14 @@ int32_t UsbFnDviceTestRequestSync006(void) { struct UsbFnRequest *req = NULL; int ret; - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + struct AcmDevice *acmDevice = UsbGetAcmDevice(); + if (acmDevice == NULL || 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); + req = UsbFnAllocRequest(acmDevice->dataIface.handle, acmDevice->dataOutPipe.id, + acmDevice->dataOutPipe.maxPacketSize); if (req == NULL) { HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; @@ -412,8 +444,12 @@ int32_t UsbFnDviceTestRequestSync007(void) 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; + struct AcmDevice *acmDevice = UsbGetAcmDevice(); + if (acmDevice == NULL) { + return; + } + + acmDevice->havedSubmit = true; } int32_t UsbFnDviceTestCancelRequest(void) @@ -432,12 +468,13 @@ int32_t UsbFnDviceTestCancelRequest002(void) { int ret; struct UsbFnRequest *req = NULL; + struct AcmDevice *acmDevice = UsbGetAcmDevice(); - if (g_acmDevice == NULL || g_acmDevice->ctrlIface.handle == NULL) { + if (acmDevice == NULL || acmDevice->ctrlIface.handle == NULL) { HDF_LOGE("%s: CtrlIface.handle is invail", __func__); return HDF_FAILURE; } - req = UsbFnAllocCtrlRequest(g_acmDevice->ctrlIface.handle, + req = UsbFnAllocCtrlRequest(acmDevice->ctrlIface.handle, sizeof(struct UsbCdcNotification)); if (req == NULL) { HDF_LOGE("%s: alloc req fail", __func__); @@ -465,13 +502,14 @@ int32_t UsbFnDviceTestCancelRequest003(void) { int ret; struct UsbFnRequest *req = NULL; + struct AcmDevice *acmDevice = UsbGetAcmDevice(); - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + if (acmDevice == NULL || 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); + req = UsbFnAllocRequest(acmDevice->dataIface.handle, acmDevice->dataInPipe.id, + acmDevice->dataInPipe.maxPacketSize); if (req == NULL) { HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; @@ -498,13 +536,14 @@ int32_t UsbFnDviceTestCancelRequest004(void) { int ret; struct UsbFnRequest *req = NULL; + struct AcmDevice *acmDevice = UsbGetAcmDevice(); - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + if (acmDevice == NULL || 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); + req = UsbFnAllocRequest(acmDevice->dataIface.handle, acmDevice->dataInPipe.id, + acmDevice->dataInPipe.maxPacketSize); if (req == NULL) { HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; @@ -531,29 +570,32 @@ int32_t UsbFnDviceTestCancelRequest005(void) { int ret; struct UsbFnRequest *req = NULL; + struct AcmDevice *acmDevice = UsbGetAcmDevice(); - if (g_acmDevice == NULL || g_acmDevice->dataIface.handle == NULL) { + if (acmDevice == NULL || 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); + req = UsbFnAllocRequest(acmDevice->dataIface.handle, acmDevice->dataInPipe.id, + acmDevice->dataInPipe.maxPacketSize); if (req == NULL) { HDF_LOGE("%s: alloc req fail", __func__); return HDF_FAILURE; } - g_acmDevice->havedSubmit = false; + acmDevice->havedSubmit = false; req->complete = TestCancelComplete; - req->context = g_acmDevice; + req->context = acmDevice; dprintf("------send \"abc\" to host------\n"); - memcpy_s(req->buf, g_acmDevice->dataInPipe.maxPacketSize, "abc", strlen("abc")); + if (memcpy_s(req->buf, acmDevice->dataInPipe.maxPacketSize, "abc", strlen("abc")) != EOK) { + HDF_LOGE("%s:%d memcpy_s fail", __func__, __LINE__); + } 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) { + while (acmDevice->havedSubmit == 0) { OsalMSleep(1); } ret = UsbFnCancelRequest(req); @@ -561,7 +603,7 @@ int32_t UsbFnDviceTestCancelRequest005(void) dprintf("%s: cancel request error", __func__); return HDF_FAILURE; } - g_acmDevice->havedSubmit = false; + acmDevice->havedSubmit = false; ret = UsbFnFreeRequest(req); if (HDF_SUCCESS != ret) { HDF_LOGE("%s: free Request error", __func__); @@ -570,40 +612,9 @@ int32_t UsbFnDviceTestCancelRequest005(void) return HDF_SUCCESS; } -int32_t UsbFnDviceTestCancelRequest006(void) +int32_t TestCancelRequest(struct UsbFnRequest *req, struct UsbFnRequest *req2) { 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__); @@ -632,3 +643,41 @@ int32_t UsbFnDviceTestCancelRequest006(void) return HDF_SUCCESS; } +int32_t UsbFnDviceTestCancelRequest006(void) +{ + int ret; + struct UsbFnRequest *req = NULL; + struct UsbFnRequest *req2 = NULL; + struct AcmDevice *acmDevice = UsbGetAcmDevice(); + + if (acmDevice == NULL || acmDevice->dataIface.handle == NULL) { + HDF_LOGE("%s: dataIface.handle is invail", __func__); + return HDF_FAILURE; + } + req = UsbFnAllocRequest(acmDevice->dataIface.handle, acmDevice->dataOutPipe.id, + acmDevice->dataOutPipe.maxPacketSize); + if (req == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + acmDevice->havedSubmit = false; + req->complete = TestCancelComplete; + req->context = acmDevice; + + req2 = UsbFnAllocRequest(acmDevice->dataIface.handle, acmDevice->dataOutPipe.id, + acmDevice->dataOutPipe.maxPacketSize); + if (req2 == NULL) { + HDF_LOGE("%s: alloc req fail", __func__); + return HDF_FAILURE; + } + acmDevice->submit = false; + req2->complete = ReadComplete; + req2->context = acmDevice; + ret = UsbFnSubmitRequestAsync(req); + if (HDF_SUCCESS != ret) { + HDF_LOGE("%s: request async error", __func__); + return HDF_FAILURE; + } + return TestCancelRequest(req, req2); +} + diff --git a/test/unittest/model/usb/host/include/usb_raw_test.h b/test/unittest/model/usb/host/include/usb_raw_test.h index b02a0fa0e70d78d508598e160e23f7e45fc99552..40f9bd4009a34c145144d0fa2bbc58d568841f84 100755 --- a/test/unittest/model/usb/host/include/usb_raw_test.h +++ b/test/unittest/model/usb/host/include/usb_raw_test.h @@ -13,7 +13,7 @@ #include "hdf_device_desc.h" #include "hdf_platform.h" #include "implementation/global_implementation.h" -#include "usb_interface.h" +#include "usb_ddk_interface.h" #include "usb_raw_api.h" enum UsbRawTestCmd { @@ -161,7 +161,7 @@ enum UsbRawTestCmd { #define USB_CTRL_REQ_SIZE 256 #define DATARATE 9600 -#define CHARFORMAT 8 +#define DATA_BITS_LENGTH 8 #define ACM_NW 16 #define ACM_NR 16 #define READ_BUF_SIZE 8192 @@ -352,13 +352,12 @@ struct UsbFillRequestData { UsbRequestCallback userCallback; }; -extern struct AcmRawDevice *g_acm; - struct UsbRawTestFunc { enum UsbRawTestCmd type; int32_t (*Func)(void); }; +struct AcmRawDevice *UsbGetIoAcm(void); int UsbParseConfigDescriptor(struct AcmRawDevice *acm, struct UsbRawConfigDescriptor *config); int AcmWriteBufAlloc(struct AcmRawDevice *acm); void AcmNotifyReqCallback(const void *requestArg); diff --git a/test/unittest/model/usb/host/include/usb_test.h b/test/unittest/model/usb/host/include/usb_test.h index d3188fad89ae3560da8193a7c3d6eb3a637362dc..c2f7d388ca3444cecafc0856832d086b4636a762 100755 --- a/test/unittest/model/usb/host/include/usb_test.h +++ b/test/unittest/model/usb/host/include/usb_test.h @@ -14,7 +14,7 @@ #include "hdf_platform.h" #include "implementation/global_implementation.h" #include "usb_ddk.h" -#include "usb_interface.h" +#include "usb_ddk_interface.h" enum UsbTestCmd { USB_WRITE_TEST = 0, @@ -120,7 +120,7 @@ enum UsbTestCmd { #define REQUEST_TYPE_MASK 0x3 #define DATARATE 9600 -#define CHARFORMAT 8 +#define DATA_BITS_LENGTH 8 #define ACM_NW 16 #define ACM_NR 16 #define READ_BUF_SIZE 8192 diff --git a/test/unittest/model/usb/host/src/usb_raw_io.c b/test/unittest/model/usb/host/src/usb_raw_io.c index ac9cbe35d28d2d064888bc99b2add070ca04c758..45212bf9bbb7f02fdd402b855352f33ef90b5d78 100755 --- a/test/unittest/model/usb/host/src/usb_raw_io.c +++ b/test/unittest/model/usb/host/src/usb_raw_io.c @@ -15,7 +15,7 @@ #include "hdf_log.h" #include "osal_mem.h" #include "osal_time.h" -#include "usb_interface.h" +#include "usb_ddk_interface.h" #ifdef LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY #include "usb_pnp_notify.h" #endif @@ -30,12 +30,17 @@ int g_activeConfig; bool g_initFlag; bool g_stopIoThreadFlag = false; +struct AcmRawDevice *UsbGetIoAcm(void) +{ + return g_acm; +} + int UsbIoThread(void *data) { int ret; struct AcmRawDevice *acm = (struct AcmRawDevice *)data; - for (; ;) { + while (true) { printf("%s:%d\n", __func__, __LINE__); if (acm == NULL) { printf("%s:%d acm is NULL\n", __func__, __LINE__); @@ -167,7 +172,6 @@ void AcmReadBulkCallback(const void *requestArg) if (size) { uint8_t *data = req->buffer; printf("rcv:%s\n", (char *)data); - } break; case USB_REQUEST_CANCELLED: @@ -207,28 +211,38 @@ void AcmNotifyReqCallback(const void *requestArg) printf("Irqstatus:%d,actualLength:%u\n", req->status, currentSize); } -int AcmWriteBufAlloc(struct AcmRawDevice *acm) +static int AcmWriteBufAllocHandle(const 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; + struct RawWb *wb; + for (wb = (struct RawWb *)&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; } - g_writeBufFlag = true; + return -HDF_ERR_MALLOC_FAIL; } + g_writeBufFlag = true; } + return HDF_SUCCESS; } +int AcmWriteBufAlloc(struct AcmRawDevice *acm) +{ + int ret = HDF_SUCCESS; + + if (!g_writeBufFlag) { + ret = AcmWriteBufAllocHandle(acm); + } + + return ret; +} + void AcmWriteBufFree(struct AcmRawDevice *acm) { int i; @@ -248,22 +262,58 @@ void AcmCtrlReqCallback(const void *requestArg) printf("%s:%d entry!", __func__, __LINE__); } +static void AcmParaseInterfaceClass( + struct AcmRawDevice * const acm, const struct UsbRawInterface *interface, uint8_t number) +{ + uint8_t ifaceClass; + uint8_t numEndpoints; + + ifaceClass = interface->altsetting->interfaceDescriptor.bInterfaceClass; + numEndpoints = interface->altsetting->interfaceDescriptor.bNumEndpoints; + + switch (ifaceClass) { + case USB_DDK_CLASS_COMM: + acm->ctrlIface = number; + /* 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 = number; + for (uint8_t 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; + } +} + 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); @@ -272,36 +322,7 @@ int UsbParseConfigDescriptor(struct AcmRawDevice *acm, struct UsbRawConfigDescri 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; - } + AcmParaseInterfaceClass(acm, interface, i); } 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 index 423dcc99edb78ac262a8e98429e80f5d72ba2c3a..67946378096bcf5d0e281518c995a90c08f95a63 100755 --- a/test/unittest/model/usb/host/src/usb_raw_test.c +++ b/test/unittest/model/usb/host/src/usb_raw_test.c @@ -15,7 +15,7 @@ #include "hdf_log.h" #include "osal_mem.h" #include "osal_time.h" -#include "usb_interface.h" +#include "usb_ddk_interface.h" #ifdef LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY #include "usb_pnp_notify.h" #endif @@ -52,8 +52,9 @@ int32_t CheckRawSdkIfClaimInterface001(void) int32_t CheckRawSdkIfClaimInterface005(void) { int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbParseConfigDescriptor(g_acm, g_acm->config); + ret = UsbParseConfigDescriptor(rawAcm, rawAcm->config); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -65,8 +66,9 @@ int32_t CheckRawSdkIfClaimInterface005(void) int32_t CheckRawSdkIfReleaseInterface001(void) { int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawReleaseInterface(NULL, g_acm->ctrlIface); + ret = UsbRawReleaseInterface(NULL, rawAcm->ctrlIface); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -78,8 +80,9 @@ int32_t CheckRawSdkIfReleaseInterface001(void) int32_t CheckRawSdkIfReleaseInterface002(void) { int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawReleaseInterface(g_acm->devHandle, g_acm->ctrlIface); + ret = UsbRawReleaseInterface(rawAcm->devHandle, rawAcm->ctrlIface); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -91,8 +94,9 @@ int32_t CheckRawSdkIfReleaseInterface002(void) int32_t CheckRawSdkIfReleaseInterface003(void) { int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawReleaseInterface(NULL, g_acm->dataIface); + ret = UsbRawReleaseInterface(NULL, rawAcm->dataIface); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -104,8 +108,9 @@ int32_t CheckRawSdkIfReleaseInterface003(void) int32_t CheckRawSdkIfReleaseInterface004(void) { int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawReleaseInterface(g_acm->devHandle, g_acm->dataIface); + ret = UsbRawReleaseInterface(rawAcm->devHandle, rawAcm->dataIface); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -117,8 +122,9 @@ int32_t CheckRawSdkIfReleaseInterface004(void) int32_t CheckRawSdkIfClaimInterface006(void) { int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbParseConfigDescriptor(g_acm, g_acm->config); + ret = UsbParseConfigDescriptor(rawAcm, rawAcm->config); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -131,17 +137,18 @@ int32_t CheckRawSdkIfAllocRequest001(void) { int i; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = AcmWriteBufAlloc(g_acm); + ret = AcmWriteBufAlloc(rawAcm); 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) { + rawAcm->wb[i].request = UsbRawAllocRequest(NULL, 0, rawAcm->dataOutEp.maxPacketSize); + rawAcm->wb[i].instance = rawAcm; + if (rawAcm->wb[i].request) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } @@ -154,21 +161,22 @@ int32_t CheckRawSdkIfAllocRequest002(void) { int i; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = AcmWriteBufAlloc(g_acm); + ret = AcmWriteBufAlloc(rawAcm); 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) { + rawAcm->wb[i].request = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->dataOutEp.maxPacketSize); + rawAcm->wb[i].instance = rawAcm; + if (rawAcm->wb[i].request == NULL) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } + ((struct UsbHostRequest *)(rawAcm->wb[i].request))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle; } HDF_LOGE("%s: success", __func__); return HDF_SUCCESS; @@ -177,10 +185,11 @@ int32_t CheckRawSdkIfAllocRequest002(void) int32_t CheckRawSdkIfAllocRequest003(void) { int i; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); for (i = 0; i < ACM_NR; i++) { - g_acm->readReq[i] = UsbRawAllocRequest(NULL, 0, g_acm->dataInEp.maxPacketSize); - if (g_acm->readReq[i]) { + rawAcm->readReq[i] = UsbRawAllocRequest(NULL, 0, rawAcm->dataInEp.maxPacketSize); + if (rawAcm->readReq[i]) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } @@ -192,14 +201,15 @@ int32_t CheckRawSdkIfAllocRequest003(void) int32_t CheckRawSdkIfAllocRequest004(void) { int i; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); 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) { + rawAcm->readReq[i] = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->dataInEp.maxPacketSize); + if (rawAcm->readReq[i] == NULL) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } + ((struct UsbHostRequest *)(rawAcm->readReq[i]))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle; } HDF_LOGE("%s: success", __func__); return HDF_SUCCESS; @@ -207,8 +217,9 @@ int32_t CheckRawSdkIfAllocRequest004(void) int32_t CheckRawSdkIfAllocRequest005(void) { - g_acm->ctrlReq = UsbRawAllocRequest(NULL, 0, USB_CTRL_REQ_SIZE); - if (g_acm->ctrlReq) { + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + rawAcm->ctrlReq = UsbRawAllocRequest(NULL, 0, USB_CTRL_REQ_SIZE); + if (rawAcm->ctrlReq) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } @@ -218,20 +229,22 @@ int32_t CheckRawSdkIfAllocRequest005(void) 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) { + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + rawAcm->ctrlReq = UsbRawAllocRequest(rawAcm->devHandle, 0, USB_CTRL_REQ_SIZE); + if (rawAcm->ctrlReq == NULL) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } + ((struct UsbHostRequest *)(rawAcm->ctrlReq))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle; 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) { + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + rawAcm->notifyReq = UsbRawAllocRequest(NULL, 0, rawAcm->notifyEp.maxPacketSize); + if (rawAcm->notifyReq) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } @@ -241,34 +254,37 @@ int32_t CheckRawSdkIfAllocRequest007(void) 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) { + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + rawAcm->notifyReq = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->notifyEp.maxPacketSize); + if (rawAcm->notifyReq == NULL) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } + ((struct UsbHostRequest *)(rawAcm->notifyReq))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle; 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) { + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + rawAcm->isoReq = UsbRawAllocRequest(NULL, USB_ISO_PACKAT_CNT, rawAcm->isoEp.maxPacketSize); + if (rawAcm->isoReq == NULL) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } - ((struct UsbHostRequest *)(g_acm->isoReq))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle; + ((struct UsbHostRequest *)(rawAcm->isoReq))->devHandle = (struct UsbDeviceHandle *)rawAcm->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) { + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + rawAcm->isoReq = UsbRawAllocRequest(rawAcm->devHandle, USB_ISO_PACKAT_CNT, rawAcm->isoEp.maxPacketSize); + if (rawAcm->isoReq == NULL) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } - ((struct UsbHostRequest *)(g_acm->isoReq))->devHandle = (struct UsbDeviceHandle *)g_acm->devHandle; + ((struct UsbHostRequest *)(rawAcm->isoReq))->devHandle = (struct UsbDeviceHandle *)rawAcm->devHandle; HDF_LOGE("%s: success", __func__); return HDF_SUCCESS; } @@ -276,13 +292,14 @@ int32_t CheckRawSdkIfAllocRequest011(void) int32_t CheckRawSdkIfFreeRequest006(void) { int32_t ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawFreeRequest(g_acm->isoReq); + ret = UsbRawFreeRequest(rawAcm->isoReq); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } - g_acm->isoReq = NULL; + rawAcm->isoReq = NULL; HDF_LOGE("%s: success", __func__); return HDF_SUCCESS; } @@ -294,17 +311,18 @@ int32_t CheckRawSdkIfFillIsoRequest001(void) int i; uint32_t size; char sendData[] = {"abcde\0"}; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); size = strlen(sendData) + 1; printf("---size:%d\n", size); - size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size; + size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size; for (i = 0; i < 1; i++) { - reqData.endPoint = g_acm->isoEp.addr; + reqData.endPoint = rawAcm->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); + ret = UsbRawFillIsoRequest(rawAcm->isoReq, rawAcm->devHandle, &reqData); if (ret) { printf("%s: error++ret=%d\n", __func__, ret); return HDF_FAILURE; @@ -321,17 +339,18 @@ int32_t CheckRawSdkIfFillIsoRequest002(void) int i; uint32_t size; char sendData[] = {"abcde\0"}; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); size = strlen(sendData) + 1; printf("---size:%d\n", size); - size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size; + size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size; for (i = 0; i < 1; i++) { - reqData.endPoint = g_acm->isoEp.addr; + reqData.endPoint = rawAcm->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); + ret = UsbRawFillIsoRequest(NULL, rawAcm->devHandle, &reqData); if (ret) { printf("%s: error++ret=%d\n", __func__, ret); return HDF_FAILURE; @@ -348,17 +367,18 @@ int32_t CheckRawSdkIfFillIsoRequest003(void) int i; uint32_t size; char sendData[] = {"abcde\0"}; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); size = strlen(sendData) + 1; printf("---size:%d\n", size); - size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size; + size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size; for (i = 0; i < 1; i++) { - reqData.endPoint = g_acm->isoEp.addr; + reqData.endPoint = rawAcm->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); + ret = UsbRawFillIsoRequest(rawAcm->isoReq, rawAcm->devHandle, NULL); if (ret) { printf("%s: error++ret=%d\n", __func__, ret); return HDF_FAILURE; @@ -375,17 +395,18 @@ int32_t CheckRawSdkIfFillIsoRequest004(void) int i; uint32_t size; char sendData[] = {"abcde\0"}; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); size = strlen(sendData) + 1; printf("---size:%d\n", size); - size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size; + size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size; for (i = 0; i < 1; i++) { - reqData.endPoint = g_acm->isoEp.addr; + reqData.endPoint = rawAcm->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); + ret = UsbRawFillIsoRequest(rawAcm->isoReq, NULL, &reqData); if (ret) { printf("%s: error++ret=%d\n", __func__, ret); return HDF_FAILURE; @@ -402,11 +423,12 @@ int32_t CheckRawSdkIfFillIsoRequest005(void) int i; uint32_t size; char sendData[] = {"abcde\0"}; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); size = strlen(sendData) + 1; printf("---size:%d\n", size); - size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size; + size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size; for (i = 0; i < 1; i++) { - reqData.endPoint = g_acm->isoEp.addr; + reqData.endPoint = rawAcm->isoEp.addr; reqData.numIsoPackets = USB_ISO_PACKAT_CNT; reqData.callback = AcmWriteIsoCallback; reqData.timeout = USB_CTRL_SET_TIMEOUT; @@ -429,11 +451,12 @@ int32_t CheckRawSdkIfFillIsoRequest006(void) int i; uint32_t size; char sendData[] = {"abcde\0"}; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); size = strlen(sendData) + 1; printf("---size:%d\n", size); - size = (size > g_acm->isoEp.maxPacketSize) ? g_acm->isoEp.maxPacketSize : size; + size = (size > rawAcm->isoEp.maxPacketSize) ? rawAcm->isoEp.maxPacketSize : size; for (i = 0; i < 1; i++) { - reqData.endPoint = g_acm->isoEp.addr; + reqData.endPoint = rawAcm->isoEp.addr; reqData.numIsoPackets = USB_ISO_PACKAT_CNT; reqData.callback = AcmWriteIsoCallback; reqData.timeout = USB_CTRL_SET_TIMEOUT; @@ -452,16 +475,17 @@ int32_t CheckRawSdkIfFreeRequest001(void) { int32_t ret; int i; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); for (i = 0; i < ACM_NW; i++) { - ret = UsbRawFreeRequest(g_acm->wb[i].request); + ret = UsbRawFreeRequest(rawAcm->wb[i].request); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } - g_acm->wb[i].request = NULL; + rawAcm->wb[i].request = NULL; } - AcmWriteBufFree(g_acm); + AcmWriteBufFree(rawAcm); HDF_LOGE("%s: success", __func__); return HDF_SUCCESS; } @@ -470,14 +494,15 @@ int32_t CheckRawSdkIfFreeRequest002(void) { int32_t ret; int i; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); for (i = 0; i < ACM_NW; i++) { - ret = UsbRawFreeRequest(g_acm->readReq[i]); + ret = UsbRawFreeRequest(rawAcm->readReq[i]); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } - g_acm->readReq[i] = NULL; + rawAcm->readReq[i] = NULL; } HDF_LOGE("%s: success", __func__); return HDF_SUCCESS; @@ -486,13 +511,14 @@ int32_t CheckRawSdkIfFreeRequest002(void) int32_t CheckRawSdkIfFreeRequest003(void) { int32_t ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawFreeRequest(g_acm->ctrlReq); + ret = UsbRawFreeRequest(rawAcm->ctrlReq); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } - g_acm->ctrlReq = NULL; + rawAcm->ctrlReq = NULL; HDF_LOGE("%s: success", __func__); return HDF_SUCCESS; } @@ -500,13 +526,14 @@ int32_t CheckRawSdkIfFreeRequest003(void) int32_t CheckRawSdkIfFreeRequest004(void) { int32_t ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawFreeRequest(g_acm->notifyReq); + ret = UsbRawFreeRequest(rawAcm->notifyReq); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } - g_acm->notifyReq = NULL; + rawAcm->notifyReq = NULL; HDF_LOGE("%s: success", __func__); return HDF_SUCCESS; } @@ -528,38 +555,39 @@ int32_t CheckRawSdkIfAllocRequest009(void) { int i; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = AcmWriteBufAlloc(g_acm); + ret = AcmWriteBufAlloc(rawAcm); 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) { + rawAcm->wb[i].request = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->dataOutEp.maxPacketSize); + rawAcm->wb[i].instance = rawAcm; + if (rawAcm->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) { + rawAcm->readReq[i] = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->dataInEp.maxPacketSize); + if (rawAcm->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) { + rawAcm->ctrlReq = UsbRawAllocRequest(rawAcm->devHandle, 0, USB_CTRL_REQ_SIZE); + if (rawAcm->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) { + rawAcm->notifyReq = UsbRawAllocRequest(rawAcm->devHandle, 0, rawAcm->notifyEp.maxPacketSize); + if (rawAcm->notifyReq == NULL) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; } @@ -572,6 +600,7 @@ int32_t CheckRawSdkIfGetDescriptor001(void) struct UsbRawDescriptorParam param; unsigned char *data = NULL; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); data = OsalMemCalloc(USB_BUFFER_MAX_SIZE); if (data == NULL) { @@ -579,15 +608,15 @@ int32_t CheckRawSdkIfGetDescriptor001(void) return HDF_ERR_MALLOC_FAIL; } - ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, ¶m, data); + ret = UsbRawGetDescriptor(NULL, rawAcm->devHandle, ¶m, data); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); ret = HDF_FAILURE; - goto error; + goto ERROR; } HDF_LOGE("%s: success", __func__); ret = HDF_SUCCESS; -error: +ERROR: OsalMemFree(data); data = NULL; @@ -599,6 +628,7 @@ int32_t CheckRawSdkIfGetDescriptor002(void) struct UsbRawDescriptorParam param; unsigned char *data = NULL; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); data = OsalMemCalloc(USB_BUFFER_MAX_SIZE); if (data == NULL) { @@ -606,15 +636,15 @@ int32_t CheckRawSdkIfGetDescriptor002(void) return HDF_ERR_MALLOC_FAIL; } - ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, ¶m, data); + ret = UsbRawGetDescriptor(rawAcm->ctrlReq, NULL, ¶m, data); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); ret = HDF_FAILURE; - goto error; + goto ERROR; } HDF_LOGE("%s: success", __func__); ret = HDF_SUCCESS; -error: +ERROR: OsalMemFree(data); data = NULL; @@ -637,11 +667,11 @@ int32_t CheckRawSdkIfGetDescriptor003(void) if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); ret = HDF_FAILURE; - goto error; + goto ERROR; } HDF_LOGE("%s: success", __func__); ret = HDF_SUCCESS; -error: +ERROR: OsalMemFree(data); data = NULL; @@ -652,6 +682,7 @@ int32_t CheckRawSdkIfGetDescriptor004(void) { unsigned char *data = NULL; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); data = OsalMemCalloc(USB_BUFFER_MAX_SIZE); if (data == NULL) { @@ -659,15 +690,15 @@ int32_t CheckRawSdkIfGetDescriptor004(void) return HDF_ERR_MALLOC_FAIL; } - ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, NULL, data); + ret = UsbRawGetDescriptor(rawAcm->ctrlReq, rawAcm->devHandle, NULL, data); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); ret = HDF_FAILURE; - goto error; + goto ERROR; } HDF_LOGE("%s: success", __func__); ret = HDF_SUCCESS; -error: +ERROR: OsalMemFree(data); data = NULL; @@ -678,8 +709,9 @@ int32_t CheckRawSdkIfGetDescriptor005(void) { struct UsbRawDescriptorParam param; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, ¶m, NULL); + ret = UsbRawGetDescriptor(rawAcm->ctrlReq, rawAcm->devHandle, ¶m, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -693,6 +725,7 @@ int32_t CheckRawSdkIfGetDescriptor006(void) struct UsbRawDescriptorParam param; unsigned char *data = NULL; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); data = OsalMemCalloc(USB_BUFFER_MAX_SIZE); if (data == NULL) { @@ -704,15 +737,15 @@ int32_t CheckRawSdkIfGetDescriptor006(void) param.descIndex = 0; param.length = USB_BUFFER_MAX_SIZE; - ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, ¶m, data); + ret = UsbRawGetDescriptor(rawAcm->ctrlReq, rawAcm->devHandle, ¶m, data); if (ret < 0) { HDF_LOGE("%s: error", __func__); ret = HDF_FAILURE; - goto error; + goto ERROR; } HDF_LOGE("%s: success", __func__); ret = HDF_SUCCESS; -error: +ERROR: OsalMemFree(data); data = NULL; @@ -723,6 +756,7 @@ int32_t CheckRawSdkIfGetDescriptor007(void) { unsigned char *data = NULL; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); data = OsalMemCalloc(USB_BUFFER_MAX_SIZE); if (data == NULL) { @@ -730,15 +764,15 @@ int32_t CheckRawSdkIfGetDescriptor007(void) return HDF_ERR_MALLOC_FAIL; } - ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, NULL, data); + ret = UsbRawGetDescriptor(rawAcm->ctrlReq, NULL, NULL, data); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); ret = HDF_FAILURE; - goto error; + goto ERROR; } HDF_LOGE("%s: success", __func__); ret = HDF_SUCCESS; -error: +ERROR: OsalMemFree(data); data = NULL; @@ -748,8 +782,9 @@ error: int32_t CheckRawSdkIfGetDescriptor008(void) { int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawGetDescriptor(g_acm->ctrlReq, g_acm->devHandle, NULL, NULL); + ret = UsbRawGetDescriptor(rawAcm->ctrlReq, rawAcm->devHandle, NULL, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -762,6 +797,7 @@ int32_t CheckRawSdkIfGetDescriptor009(void) { unsigned char *data = NULL; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); data = OsalMemCalloc(USB_BUFFER_MAX_SIZE); if (data == NULL) { @@ -769,15 +805,15 @@ int32_t CheckRawSdkIfGetDescriptor009(void) return HDF_ERR_MALLOC_FAIL; } - ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, NULL, data); + ret = UsbRawGetDescriptor(NULL, rawAcm->devHandle, NULL, data); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); ret = HDF_FAILURE; - goto error; + goto ERROR; } HDF_LOGE("%s: success", __func__); ret = HDF_SUCCESS; -error: +ERROR: OsalMemFree(data); data = NULL; @@ -789,12 +825,13 @@ int32_t CheckRawSdkIfGetDescriptor010(void) struct UsbRawDescriptorParam param; unsigned char data[100]; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); param.descType = 0; param.descIndex = 0; param.length = sizeof(data); - ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, ¶m, NULL); + ret = UsbRawGetDescriptor(NULL, rawAcm->devHandle, ¶m, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -808,12 +845,13 @@ int32_t CheckRawSdkIfGetDescriptor011(void) struct UsbRawDescriptorParam param; unsigned char data[100]; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); param.descType = 0; param.descIndex = 0; param.length = sizeof(data); - ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, ¶m, NULL); + ret = UsbRawGetDescriptor(rawAcm->ctrlReq, NULL, ¶m, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -837,11 +875,11 @@ int32_t CheckRawSdkIfGetDescriptor012(void) if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); ret = HDF_FAILURE; - goto error; + goto ERROR; } HDF_LOGE("%s: success", __func__); ret = HDF_SUCCESS; -error: +ERROR: OsalMemFree(data); data = NULL; @@ -870,8 +908,9 @@ int32_t CheckRawSdkIfGetDescriptor013(void) int32_t CheckRawSdkIfGetDescriptor014(void) { int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawGetDescriptor(NULL, g_acm->devHandle, NULL, NULL); + ret = UsbRawGetDescriptor(NULL, rawAcm->devHandle, NULL, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -883,8 +922,9 @@ int32_t CheckRawSdkIfGetDescriptor014(void) int32_t CheckRawSdkIfGetDescriptor015(void) { int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawGetDescriptor(g_acm->ctrlReq, NULL, NULL, NULL); + ret = UsbRawGetDescriptor(rawAcm->ctrlReq, NULL, NULL, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -913,29 +953,30 @@ int32_t CheckRawSdkIfFillBulkRequest001(void) int i; uint32_t size; char sendData[] = {"abcde\0"}; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); size = strlen(sendData) + 1; printf("---size:%d\n", size); - size = (size > g_acm->dataOutEp.maxPacketSize) ? g_acm->dataOutEp.maxPacketSize : size; + size = (size > rawAcm->dataOutEp.maxPacketSize) ? rawAcm->dataOutEp.maxPacketSize : size; for (i = 0; i < 1; i++) { - struct RawWb *snd = &g_acm->wb[i]; + struct RawWb *snd = &rawAcm->wb[i]; snd->len = size; - ret = memcpy_s(snd->buf, g_acm->dataOutEp.maxPacketSize, sendData, size); + ret = memcpy_s(snd->buf, rawAcm->dataOutEp.maxPacketSize, sendData, size); if (ret) { printf("memcpy_s fial"); } - g_acm->transmitting++; + rawAcm->transmitting++; - reqData.endPoint = g_acm->dataOutEp.addr; + reqData.endPoint = rawAcm->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); + printf("maxPacketSize:%d+snd->request:%p\n", rawAcm->dataOutEp.maxPacketSize, snd->request); + ret = UsbRawFillBulkRequest(snd->request, rawAcm->devHandle, &reqData); if (ret) { printf("%s: error++ret=%d\n", __func__, ret); return HDF_FAILURE; @@ -950,17 +991,18 @@ int32_t CheckRawSdkIfFillBulkRequest002(void) struct UsbRawFillRequestData reqData; int32_t ret; int i; - int size = g_acm->dataInEp.maxPacketSize; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + int size = rawAcm->dataInEp.maxPacketSize; for (i = 0; i < 1; i++) { - reqData.endPoint = g_acm->dataInEp.addr; + reqData.endPoint = rawAcm->dataInEp.addr; reqData.numIsoPackets = 0; reqData.callback = AcmReadBulkCallback; - reqData.userData = (void *)g_acm; + reqData.userData = (void *)rawAcm; reqData.timeout = USB_CTRL_SET_TIMEOUT; reqData.length = size; - ret = UsbRawFillBulkRequest(g_acm->readReq[i], g_acm->devHandle, &reqData); + ret = UsbRawFillBulkRequest(rawAcm->readReq[i], rawAcm->devHandle, &reqData); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -974,16 +1016,17 @@ int32_t CheckRawSdkIfFillInterruptRequest001(void) { struct UsbRawFillRequestData fillRequestData; int32_t ret; - int size = g_acm->notifyEp.maxPacketSize; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + int size = rawAcm->notifyEp.maxPacketSize; - fillRequestData.endPoint = g_acm->notifyEp.addr; + fillRequestData.endPoint = rawAcm->notifyEp.addr; fillRequestData.length = size; fillRequestData.numIsoPackets = 0; fillRequestData.callback = AcmNotifyReqCallback; - fillRequestData.userData = (void *)g_acm; + fillRequestData.userData = (void *)rawAcm; fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; - ret = UsbRawFillInterruptRequest(g_acm->notifyReq, g_acm->devHandle, &fillRequestData); + ret = UsbRawFillInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, &fillRequestData); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -996,16 +1039,17 @@ int32_t CheckRawSdkIfFillInterruptRequest002(void) { struct UsbRawFillRequestData fillRequestData; int32_t ret; - int size = g_acm->notifyEp.maxPacketSize; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + int size = rawAcm->notifyEp.maxPacketSize; - fillRequestData.endPoint = g_acm->notifyEp.addr; + fillRequestData.endPoint = rawAcm->notifyEp.addr; fillRequestData.length = size; fillRequestData.numIsoPackets = 0; fillRequestData.callback = AcmNotifyReqCallback; - fillRequestData.userData = (void *)g_acm; + fillRequestData.userData = (void *)rawAcm; fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; - ret = UsbRawFillInterruptRequest(NULL, g_acm->devHandle, &fillRequestData); + ret = UsbRawFillInterruptRequest(NULL, rawAcm->devHandle, &fillRequestData); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1018,16 +1062,17 @@ int32_t CheckRawSdkIfFillInterruptRequest003(void) { struct UsbRawFillRequestData fillRequestData; int32_t ret; - int size = g_acm->notifyEp.maxPacketSize; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + int size = rawAcm->notifyEp.maxPacketSize; - fillRequestData.endPoint = g_acm->notifyEp.addr; + fillRequestData.endPoint = rawAcm->notifyEp.addr; fillRequestData.length = size; fillRequestData.numIsoPackets = 0; fillRequestData.callback = AcmNotifyReqCallback; - fillRequestData.userData = (void *)g_acm; + fillRequestData.userData = (void *)rawAcm; fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; - ret = UsbRawFillInterruptRequest(g_acm->notifyReq, NULL, &fillRequestData); + ret = UsbRawFillInterruptRequest(rawAcm->notifyReq, NULL, &fillRequestData); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1040,16 +1085,17 @@ int32_t CheckRawSdkIfFillInterruptRequest004(void) { struct UsbRawFillRequestData fillRequestData; int32_t ret; - int size = g_acm->notifyEp.maxPacketSize; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + int size = rawAcm->notifyEp.maxPacketSize; - fillRequestData.endPoint = g_acm->notifyEp.addr; + fillRequestData.endPoint = rawAcm->notifyEp.addr; fillRequestData.length = size; fillRequestData.numIsoPackets = 0; fillRequestData.callback = AcmNotifyReqCallback; - fillRequestData.userData = (void *)g_acm; + fillRequestData.userData = (void *)rawAcm; fillRequestData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; - ret = UsbRawFillInterruptRequest(g_acm->notifyReq, g_acm->devHandle, NULL); + ret = UsbRawFillInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1063,12 +1109,13 @@ int32_t CheckRawSdkIfFillControlRequest001(void) struct UsbRawFillRequestData fillRequestData; int ret; int completed = 0; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); fillRequestData.callback = AcmCtrlReqCallback; fillRequestData.userData = &completed; fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; - ret = UsbRawFillControlRequest(g_acm->ctrlReq, g_acm->devHandle, &fillRequestData); + ret = UsbRawFillControlRequest(rawAcm->ctrlReq, rawAcm->devHandle, &fillRequestData); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1082,12 +1129,13 @@ int32_t CheckRawSdkIfFillControlRequest002(void) struct UsbRawFillRequestData fillRequestData; int ret; int completed = 0; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); fillRequestData.callback = AcmCtrlReqCallback; fillRequestData.userData = &completed; fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; - ret = UsbRawFillControlRequest(NULL, g_acm->devHandle, &fillRequestData); + ret = UsbRawFillControlRequest(NULL, rawAcm->devHandle, &fillRequestData); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1101,12 +1149,13 @@ int32_t CheckRawSdkIfFillControlRequest003(void) struct UsbRawFillRequestData fillRequestData; int ret; int completed = 0; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); fillRequestData.callback = AcmCtrlReqCallback; fillRequestData.userData = &completed; fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; - ret = UsbRawFillControlRequest(g_acm->ctrlReq, NULL, &fillRequestData); + ret = UsbRawFillControlRequest(rawAcm->ctrlReq, NULL, &fillRequestData); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1120,12 +1169,13 @@ int32_t CheckRawSdkIfFillControlRequest004(void) struct UsbRawFillRequestData fillRequestData; int ret; int completed = 0; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); fillRequestData.callback = AcmCtrlReqCallback; fillRequestData.userData = &completed; fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; - ret = UsbRawFillControlRequest(g_acm->ctrlReq, g_acm->devHandle, NULL); + ret = UsbRawFillControlRequest(rawAcm->ctrlReq, rawAcm->devHandle, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1139,12 +1189,13 @@ int32_t CheckRawSdkIfFillControlRequest005(void) struct UsbRawFillRequestData fillRequestData; int ret; int completed = 0; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); fillRequestData.callback = AcmCtrlReqCallback; fillRequestData.userData = &completed; fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; - ret = UsbRawFillControlRequest(NULL, g_acm->devHandle, NULL); + ret = UsbRawFillControlRequest(NULL, rawAcm->devHandle, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1158,12 +1209,13 @@ int32_t CheckRawSdkIfFillControlRequest006(void) struct UsbRawFillRequestData fillRequestData; int ret; int completed = 0; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); fillRequestData.callback = AcmCtrlReqCallback; fillRequestData.userData = &completed; fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; - ret = UsbRawFillControlRequest(g_acm->ctrlReq, NULL, NULL); + ret = UsbRawFillControlRequest(rawAcm->ctrlReq, NULL, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1214,17 +1266,18 @@ int32_t CheckRawSdkIfFillControlSetup001(void) { struct UsbControlRequestData ctrlReq; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - 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; + rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + rawAcm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS; + rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY; + rawAcm->lineCoding.bDataBits = DATA_BITS_LENGTH; 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.data = (unsigned char *)&rawAcm->lineCoding; ctrlReq.length = sizeof(struct UsbCdcLineCoding); ctrlReq.timeout = USB_CTRL_SET_TIMEOUT; @@ -1252,11 +1305,11 @@ int32_t CheckRawSdkIfFillControlSetup002(void) if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); ret = HDF_FAILURE; - goto error; + goto ERROR; } HDF_LOGE("%s: success", __func__); ret = HDF_SUCCESS; -error: +ERROR: OsalMemFree(setup); setup = NULL; @@ -1281,17 +1334,18 @@ int32_t CheckRawSdkIfFillControlSetup004(void) struct UsbControlRequestData ctrlReq; unsigned char *setup = NULL; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - 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; + rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + rawAcm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS; + rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY; + rawAcm->lineCoding.bDataBits = DATA_BITS_LENGTH; 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.data = (unsigned char *)&rawAcm->lineCoding; ctrlReq.length = sizeof(struct UsbCdcLineCoding); ctrlReq.timeout = USB_CTRL_SET_TIMEOUT; @@ -1305,11 +1359,11 @@ int32_t CheckRawSdkIfFillControlSetup004(void) if (ret) { HDF_LOGE("%s: error", __func__); ret = HDF_FAILURE; - goto error; + goto ERROR; } HDF_LOGE("%s: success", __func__); -error: +ERROR: OsalMemFree(setup); setup = NULL; @@ -1320,20 +1374,21 @@ int32_t CheckRawSdkIfSendControlRequest001(void) { struct UsbControlRequestData ctrlReq; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - 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; + rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + rawAcm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS; + rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY; + rawAcm->lineCoding.bDataBits = DATA_BITS_LENGTH; 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.data = (unsigned char *)&rawAcm->lineCoding; ctrlReq.length = sizeof(struct UsbCdcLineCoding); ctrlReq.timeout = USB_CTRL_SET_TIMEOUT; - ret = UsbRawSendControlRequest(NULL, g_acm->devHandle, &ctrlReq); + ret = UsbRawSendControlRequest(NULL, rawAcm->devHandle, &ctrlReq); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1346,20 +1401,21 @@ int32_t CheckRawSdkIfSendControlRequest002(void) { struct UsbControlRequestData ctrlReq; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - 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; + rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + rawAcm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS; + rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY; + rawAcm->lineCoding.bDataBits = DATA_BITS_LENGTH; 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.data = (unsigned char *)&rawAcm->lineCoding; ctrlReq.length = sizeof(struct UsbCdcLineCoding); ctrlReq.timeout = USB_CTRL_SET_TIMEOUT; - ret = UsbRawSendControlRequest(g_acm->ctrlReq, NULL, &ctrlReq); + ret = UsbRawSendControlRequest(rawAcm->ctrlReq, NULL, &ctrlReq); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1371,7 +1427,8 @@ int32_t CheckRawSdkIfSendControlRequest002(void) int32_t CheckRawSdkIfSendControlRequest003(void) { int ret; - ret = UsbRawSendControlRequest(g_acm->ctrlReq, g_acm->devHandle, NULL); + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + ret = UsbRawSendControlRequest(rawAcm->ctrlReq, rawAcm->devHandle, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1384,20 +1441,21 @@ int32_t CheckRawSdkIfSendControlRequest004(void) { struct UsbControlRequestData ctrlReq; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - 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; + rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + rawAcm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS; + rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY; + rawAcm->lineCoding.bDataBits = DATA_BITS_LENGTH; 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.data = (unsigned char *)&rawAcm->lineCoding; ctrlReq.length = sizeof(struct UsbCdcLineCoding); ctrlReq.timeout = USB_CTRL_SET_TIMEOUT; - ret = UsbRawSendControlRequest(g_acm->ctrlReq, g_acm->devHandle, &ctrlReq); + ret = UsbRawSendControlRequest(rawAcm->ctrlReq, rawAcm->devHandle, &ctrlReq); if (ret < 0) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1410,16 +1468,17 @@ int32_t CheckRawSdkIfSendControlRequest005(void) { struct UsbControlRequestData ctrlReq; int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - 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; + rawAcm->lineCoding.dwDTERate = CpuToLe32(DATARATE); + rawAcm->lineCoding.bCharFormat = USB_CDC_1_STOP_BITS; + rawAcm->lineCoding.bParityType = USB_CDC_NO_PARITY; + rawAcm->lineCoding.bDataBits = DATA_BITS_LENGTH; 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.data = (unsigned char *)&rawAcm->lineCoding; ctrlReq.length = sizeof(struct UsbCdcLineCoding); ctrlReq.timeout = USB_CTRL_SET_TIMEOUT; @@ -1435,8 +1494,9 @@ int32_t CheckRawSdkIfSendControlRequest005(void) int32_t CheckRawSdkIfSendControlRequest006(void) { int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawSendControlRequest(NULL, g_acm->devHandle, NULL); + ret = UsbRawSendControlRequest(NULL, rawAcm->devHandle, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1448,8 +1508,9 @@ int32_t CheckRawSdkIfSendControlRequest006(void) int32_t CheckRawSdkIfSendControlRequest007(void) { int ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawSendControlRequest(g_acm->ctrlReq, NULL, NULL); + ret = UsbRawSendControlRequest(rawAcm->ctrlReq, NULL, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1465,20 +1526,21 @@ int32_t CheckRawSdkIfSendBulkRequest001(void) int i; uint32_t size; char sendData[] = {"abcd\0"}; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); size = strlen(sendData) + 1; - size = (size > g_acm->dataOutEp.maxPacketSize) ? g_acm->dataOutEp.maxPacketSize : size; + size = (size > rawAcm->dataOutEp.maxPacketSize) ? rawAcm->dataOutEp.maxPacketSize : size; for (i = 0; i < 1; i++) { - struct RawWb *snd = &g_acm->wb[i]; + struct RawWb *snd = &rawAcm->wb[i]; snd->len = size; - ret = memcpy_s(snd->buf, g_acm->dataOutEp.maxPacketSize, sendData, size); + ret = memcpy_s(snd->buf, rawAcm->dataOutEp.maxPacketSize, sendData, size); if (ret) { printf("memcpy_s fial"); } - g_acm->transmitting++; + rawAcm->transmitting++; - reqData.endPoint = g_acm->dataOutEp.addr; + reqData.endPoint = rawAcm->dataOutEp.addr; reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; reqData.data = snd->buf; reqData.length = snd->len; @@ -1486,9 +1548,9 @@ int32_t CheckRawSdkIfSendBulkRequest001(void) } for (i = 0; i < 1; i++) { - struct RawWb *snd = &g_acm->wb[i]; + struct RawWb *snd = &rawAcm->wb[i]; printf("UsbRawSendBulkRequest i = [%d]\n", i); - ret = UsbRawSendBulkRequest(snd->request, g_acm->devHandle, &reqData); + ret = UsbRawSendBulkRequest(snd->request, rawAcm->devHandle, &reqData); if (ret) { printf("%s: error+ret:%d", __func__, ret); return HDF_FAILURE; @@ -1503,19 +1565,20 @@ int32_t CheckRawSdkIfSendBulkRequest002(void) struct UsbRequestData reqData; int32_t ret; int i; - int size = g_acm->dataInEp.maxPacketSize; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + int size = rawAcm->dataInEp.maxPacketSize; for (i = 0; i < 1; i++) { - reqData.endPoint = g_acm->dataInEp.addr; + reqData.endPoint = rawAcm->dataInEp.addr; reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; reqData.length = size; - reqData.data = ((struct UsbRawRequest *)g_acm->readReq[i])->buffer; + reqData.data = ((struct UsbRawRequest *)rawAcm->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); + ret = UsbRawSendBulkRequest(rawAcm->readReq[i], rawAcm->devHandle, &reqData); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1530,19 +1593,20 @@ int32_t CheckRawSdkIfSendBulkRequest003(void) struct UsbRequestData reqData; int32_t ret; int i; - int size = g_acm->dataInEp.maxPacketSize; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + int size = rawAcm->dataInEp.maxPacketSize; for (i = 0; i < 1; i++) { - reqData.endPoint = g_acm->dataInEp.addr; + reqData.endPoint = rawAcm->dataInEp.addr; reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; reqData.length = size; - reqData.data = ((struct UsbRawRequest *)g_acm->readReq[i])->buffer; + reqData.data = ((struct UsbRawRequest *)rawAcm->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); + ret = UsbRawSendBulkRequest(NULL, rawAcm->devHandle, &reqData); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1557,18 +1621,19 @@ int32_t CheckRawSdkIfSendBulkRequest004(void) struct UsbRequestData reqData; int32_t ret; int i; - int size = g_acm->dataInEp.maxPacketSize; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + int size = rawAcm->dataInEp.maxPacketSize; for (i = 0; i < 1; i++) { - reqData.endPoint = g_acm->dataInEp.addr; + reqData.endPoint = rawAcm->dataInEp.addr; reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; reqData.length = size; - reqData.data = ((struct UsbRawRequest *)g_acm->readReq[i])->buffer; + reqData.data = ((struct UsbRawRequest *)rawAcm->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); + ret = UsbRawSendBulkRequest(rawAcm->readReq[i], NULL, &reqData); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1582,10 +1647,11 @@ int32_t CheckRawSdkIfSendBulkRequest005(void) { int32_t ret; int i; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); for (i = 0; i < 1; i++) { printf("UsbRawSendBulkRequest i = [%d]\n", i); - ret = UsbRawSendBulkRequest(g_acm->readReq[i], g_acm->devHandle, NULL); + ret = UsbRawSendBulkRequest(rawAcm->readReq[i], rawAcm->devHandle, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1599,14 +1665,15 @@ int32_t CheckRawSdkIfSendInterruptRequest001(void) { struct UsbRequestData reqData; int32_t ret; - int size = g_acm->notifyEp.maxPacketSize; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + int size = rawAcm->notifyEp.maxPacketSize; - reqData.endPoint = g_acm->notifyEp.addr; + reqData.endPoint = rawAcm->notifyEp.addr; reqData.length = size; reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; - reqData.data = ((struct UsbRawRequest *)g_acm->notifyReq)->buffer; + reqData.data = ((struct UsbRawRequest *)rawAcm->notifyReq)->buffer; reqData.requested = (int *)&size; - ret = UsbRawSendInterruptRequest(g_acm->notifyReq, g_acm->devHandle, &reqData); + ret = UsbRawSendInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, &reqData); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1619,15 +1686,16 @@ int32_t CheckRawSdkIfSendInterruptRequest002(void) { struct UsbRequestData reqData; int32_t ret; - int size = g_acm->notifyEp.maxPacketSize; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + int size = rawAcm->notifyEp.maxPacketSize; - reqData.endPoint = g_acm->notifyEp.addr; + reqData.endPoint = rawAcm->notifyEp.addr; reqData.length = size; reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; - reqData.data = ((struct UsbRawRequest *)g_acm->notifyReq)->buffer; + reqData.data = ((struct UsbRawRequest *)rawAcm->notifyReq)->buffer; reqData.requested = (int *)&size; - ret = UsbRawSendInterruptRequest(NULL, g_acm->devHandle, &reqData); + ret = UsbRawSendInterruptRequest(NULL, rawAcm->devHandle, &reqData); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1640,15 +1708,16 @@ int32_t CheckRawSdkIfSendInterruptRequest003(void) { struct UsbRequestData reqData; int32_t ret; - int size = g_acm->notifyEp.maxPacketSize; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + int size = rawAcm->notifyEp.maxPacketSize; - reqData.endPoint = g_acm->notifyEp.addr; + reqData.endPoint = rawAcm->notifyEp.addr; reqData.length = size; reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; - reqData.data = ((struct UsbRawRequest *)g_acm->notifyReq)->buffer; + reqData.data = ((struct UsbRawRequest *)rawAcm->notifyReq)->buffer; reqData.requested = (int *)&size; - ret = UsbRawSendInterruptRequest(g_acm->notifyReq, NULL, &reqData); + ret = UsbRawSendInterruptRequest(rawAcm->notifyReq, NULL, &reqData); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1660,8 +1729,9 @@ int32_t CheckRawSdkIfSendInterruptRequest003(void) int32_t CheckRawSdkIfSendInterruptRequest004(void) { int32_t ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawSendInterruptRequest(g_acm->notifyReq, g_acm->devHandle, NULL); + ret = UsbRawSendInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, NULL); if (ret != HDF_ERR_INVALID_PARAM) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1677,19 +1747,20 @@ int32_t CheckRawSdkIfFillBulkRequest003(void) int i; uint32_t size; char sendData[] = {"abcde\0"}; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); size = strlen(sendData) + 1; - size = (size > g_acm->dataOutEp.maxPacketSize) ? g_acm->dataOutEp.maxPacketSize : size; + size = (size > rawAcm->dataOutEp.maxPacketSize) ? rawAcm->dataOutEp.maxPacketSize : size; for (i = 0; i < ACM_NW; i++) { - struct RawWb *snd = &g_acm->wb[i]; + struct RawWb *snd = &rawAcm->wb[i]; snd->len = size; - ret = memcpy_s(snd->buf, g_acm->dataOutEp.maxPacketSize, sendData, size); + ret = memcpy_s(snd->buf, rawAcm->dataOutEp.maxPacketSize, sendData, size); if (ret) { printf("memcpy_s fial"); } - g_acm->transmitting++; + rawAcm->transmitting++; - reqData.endPoint = g_acm->dataOutEp.addr; + reqData.endPoint = rawAcm->dataOutEp.addr; reqData.numIsoPackets = 0; reqData.callback = AcmWriteBulkCallback; reqData.userData = (void *)snd; @@ -1697,7 +1768,7 @@ int32_t CheckRawSdkIfFillBulkRequest003(void) reqData.buffer = snd->buf; reqData.length = snd->len; - ret = UsbRawFillBulkRequest(snd->request, g_acm->devHandle, &reqData); + ret = UsbRawFillBulkRequest(snd->request, rawAcm->devHandle, &reqData); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1712,16 +1783,17 @@ int32_t CheckRawSdkIfFillBulkRequest004(void) struct UsbRawFillRequestData reqData; int32_t ret; int i; - int size = g_acm->dataInEp.maxPacketSize; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + int size = rawAcm->dataInEp.maxPacketSize; for (i = 0; i < ACM_NW; i++) { - reqData.endPoint = g_acm->dataInEp.addr; + reqData.endPoint = rawAcm->dataInEp.addr; reqData.numIsoPackets = 0; reqData.callback = AcmReadBulkCallback; - reqData.userData = (void *)g_acm; + reqData.userData = (void *)rawAcm; reqData.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; reqData.length = size; - ret = UsbRawFillBulkRequest(g_acm->readReq[i], g_acm->devHandle, &reqData); + ret = UsbRawFillBulkRequest(rawAcm->readReq[i], rawAcm->devHandle, &reqData); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1735,14 +1807,15 @@ int32_t CheckRawSdkIfFillInterruptRequest005(void) { struct UsbRawFillRequestData fillRequestData; int32_t ret; - int size = g_acm->notifyEp.maxPacketSize; - fillRequestData.endPoint = g_acm->notifyEp.addr; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); + int size = rawAcm->notifyEp.maxPacketSize; + fillRequestData.endPoint = rawAcm->notifyEp.addr; fillRequestData.length = size; fillRequestData.numIsoPackets = 0; fillRequestData.callback = AcmNotifyReqCallback; - fillRequestData.userData = (void *)g_acm; + fillRequestData.userData = (void *)rawAcm; fillRequestData.timeout = USB_CTRL_SET_TIMEOUT; - ret = UsbRawFillInterruptRequest(g_acm->notifyReq, g_acm->devHandle, &fillRequestData); + ret = UsbRawFillInterruptRequest(rawAcm->notifyReq, rawAcm->devHandle, &fillRequestData); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1755,9 +1828,10 @@ int32_t CheckRawSdkIfSubmitRequest001(void) { int32_t ret; int i; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); for (i = 0; i < ACM_NW; i++) { - struct RawWb *snd = &g_acm->wb[i]; + struct RawWb *snd = &rawAcm->wb[i]; printf("UsbRawSubmitRequest i = [%d]\n", i); ret = UsbRawSubmitRequest(snd->request); if (ret) { @@ -1773,10 +1847,11 @@ int32_t CheckRawSdkIfSubmitRequest002(void) { int32_t ret; int i; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); for (i = 0; i < ACM_NW; i++) { printf("UsbRawSubmitRequest i = [%d]\n", i); - ret = UsbRawSubmitRequest(g_acm->readReq[i]); + ret = UsbRawSubmitRequest(rawAcm->readReq[i]); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1789,8 +1864,9 @@ int32_t CheckRawSdkIfSubmitRequest002(void) int32_t CheckRawSdkIfSubmitRequest003(void) { int32_t ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawSubmitRequest(g_acm->notifyReq); + ret = UsbRawSubmitRequest(rawAcm->notifyReq); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; @@ -1816,9 +1892,10 @@ int32_t CheckRawSdkIfCancelRequest001(void) { int32_t ret; int i; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); for (i = 0; i < ACM_NW; i++) { - struct RawWb *snd = &g_acm->wb[i]; + struct RawWb *snd = &rawAcm->wb[i]; ret = UsbRawCancelRequest(snd->request); if (ret) { HDF_LOGE("%s: error", __func__); @@ -1833,9 +1910,10 @@ int32_t CheckRawSdkIfCancelRequest002(void) { int32_t ret; int i; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); for (i = 0; i < ACM_NR; i++) { - ret = UsbRawCancelRequest(g_acm->readReq[i]); + ret = UsbRawCancelRequest(rawAcm->readReq[i]); printf("%s+%d+ret:%d\n", __func__, __LINE__, ret); if (ret) { HDF_LOGE("%s: error", __func__); @@ -1849,8 +1927,9 @@ int32_t CheckRawSdkIfCancelRequest002(void) int32_t CheckRawSdkIfCancelRequest003(void) { int32_t ret; + struct AcmRawDevice *rawAcm = UsbGetIoAcm(); - ret = UsbRawCancelRequest(g_acm->notifyReq); + ret = UsbRawCancelRequest(rawAcm->notifyReq); if (ret) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; diff --git a/test/unittest/model/usb/host/src/usb_test.c b/test/unittest/model/usb/host/src/usb_test.c index 0cbf02c59238119c8206405fa63f0fdadc11b882..72494b68f629d29085fee80d25d65029570c21a9 100755 --- a/test/unittest/model/usb/host/src/usb_test.c +++ b/test/unittest/model/usb/host/src/usb_test.c @@ -13,7 +13,7 @@ #include "hdf_log.h" #include "osal_mem.h" #include "osal_time.h" -#include "usb_interface.h" +#include "usb_ddk_interface.h" #ifdef LOSCFG_DRIVERS_HDF_USB_PNP_NOTIFY #include "usb_pnp_notify.h" #endif @@ -21,7 +21,7 @@ #define HDF_LOG_TAG USB_TEST_C static struct UsbSession *g_session = NULL; -static struct AcmDevice g_deviceService; +static struct AcmDevice g_deviceService = {0}; static struct AcmDevice *g_acm = &g_deviceService; static struct UsbInterface *g_ecmDataIface = NULL; static struct UsbInterface *g_ecmIntIface = NULL; @@ -45,9 +45,9 @@ static void AcmReadBulk(struct UsbRequest *req) case -ESHUTDOWN: return; default: - goto exit; + goto EXIT; } -exit: +EXIT: return; } @@ -84,28 +84,38 @@ static void AcmWriteIsoCallback(struct UsbRequest *requestArg) printf("%s:%d status:%d\n", __func__, __LINE__, req->compInfo.status); } -static int AcmWriteBufAlloc(struct AcmDevice *acm) +static int AcmWriteBufAllocHandle(const 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; + struct AcmWb *wb; + for (wb = (struct AcmWb *)&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; } - g_writeBufFlag = true; + return -HDF_ERR_MALLOC_FAIL; } + g_writeBufFlag = true; } + return HDF_SUCCESS; } +static int AcmWriteBufAlloc(struct AcmDevice *acm) +{ + int ret = HDF_SUCCESS; + + if (!g_writeBufFlag) { + ret = AcmWriteBufAllocHandle(acm); + } + + return ret; +} + static void AcmWriteBufFree(struct AcmDevice *acm) { int i; @@ -1107,6 +1117,10 @@ static int32_t CheckHostSdkIfFreeRequest006(void) { int ret; + if (g_acm->isoReq == NULL) { + HDF_LOGE("%s: isoReq is NULL", __func__); + return HDF_FAILURE; + } ret = UsbFreeRequest(g_acm->isoReq); if (ret) { HDF_LOGE("%s: error", __func__); @@ -1120,7 +1134,7 @@ static int32_t CheckHostSdkIfFreeRequest006(void) static int32_t CheckHostSdkIfFillIsoRequest001(void) { int ret; - struct UsbRequestParams parmas; + struct UsbRequestParams parmas = {0}; int i; char sendData[] = {"abcde\0"}; uint32_t size = strlen(sendData) + 1; @@ -1132,6 +1146,7 @@ static int32_t CheckHostSdkIfFillIsoRequest001(void) parmas.pipeAddress = g_acm->isoPipe->pipeAddress; parmas.pipeId = g_acm->isoPipe->pipeId; parmas.callback = AcmWriteIsoCallback; + parmas.userData = NULL; parmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; parmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; parmas.dataReq.numIsoPackets = USB_ISO_PACKAT_CNT; @@ -1373,8 +1388,8 @@ static int32_t CheckHostSdkIfFillRequest001(void) readParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; readParmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; readParmas.dataReq.numIsoPackets = 0; - readParmas.dataReq.directon = (UsbRequestDirection)(((uint32_t)g_acm->dataInPipe->pipeDirection >> USB_DIR_OFFSET) - & DIRECTION_MASK); + readParmas.dataReq.directon = + (UsbRequestDirection)(((uint32_t)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) { @@ -1438,6 +1453,7 @@ static int32_t CheckHostSdkIfFillRequest003(void) intParmas.dataReq.directon = (UsbRequestDirection)(((uint32_t)g_acm->intPipe->pipeDirection >> USB_PIPE_DIR_OFFSET) & DIRECTION_MASK); intParmas.dataReq.length = g_acm->intSize; + intParmas.dataReq.buffer = NULL; ret = UsbFillRequest(g_acm->notifyReq, g_acm->int_devHandle, &intParmas); if (ret) { HDF_LOGE("%s: error", __func__); @@ -1461,9 +1477,9 @@ static int32_t CheckHostSdkIfFillRequest004(void) 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.bCharFormat = USB_CDC_1_STOP_BITS; g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY; - g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS; + g_acm->lineCoding.bDataBits = DATA_BITS_LENGTH; msgData.request = USB_DDK_CDC_REQ_SET_LINE_CODING; msgData.requestType = USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE; msgData.value = value; @@ -1471,6 +1487,7 @@ static int32_t CheckHostSdkIfFillRequest004(void) msgData.data = &g_acm->lineCoding; msgData.size = sizeof(struct UsbCdcLineCoding); parmas.ctrlReq = UsbControlMsg(msgData); + parmas.userData = NULL; ret = UsbFillRequest(g_acm->ctrlReq, g_acm->ctrl_devHandle, &parmas); if (ret) { HDF_LOGE("%s: error", __func__); @@ -1551,8 +1568,8 @@ static int32_t CheckHostSdkIfFillRequest005(void) readParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; readParmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; readParmas.dataReq.numIsoPackets = 0; - readParmas.dataReq.directon = (UsbRequestDirection)(((uint32_t)g_acm->dataInPipe->pipeDirection >> USB_DIR_OFFSET) - & DIRECTION_MASK); + readParmas.dataReq.directon = + (UsbRequestDirection)(((uint32_t)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) { @@ -1610,6 +1627,7 @@ static int32_t CheckHostSdkIfFillRequest007(void) intParmas.callback = AcmCtrlIrq; intParmas.requestType = USB_REQUEST_PARAMS_DATA_TYPE; intParmas.timeout = USB_RAW_REQUEST_TIME_ZERO_MS; + intParmas.dataReq.buffer = NULL; intParmas.dataReq.numIsoPackets = 0; intParmas.dataReq.directon = (UsbRequestDirection)(((uint32_t)g_acm->intPipe->pipeDirection >> USB_PIPE_DIR_OFFSET) & DIRECTION_MASK); @@ -1638,9 +1656,9 @@ static int32_t CheckHostSdkIfFillRequest008(void) 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.bCharFormat = USB_CDC_1_STOP_BITS; g_acm->lineCoding.bParityType = USB_CDC_NO_PARITY; - g_acm->lineCoding.bDataBits = USB_CDC_1_STOP_BITS; + g_acm->lineCoding.bDataBits = DATA_BITS_LENGTH; msgData.request = USB_DDK_CDC_REQ_SET_LINE_CODING; msgData.requestType = USB_DDK_TYPE_CLASS | USB_DDK_RECIP_INTERFACE; msgData.value = value; @@ -1648,6 +1666,7 @@ static int32_t CheckHostSdkIfFillRequest008(void) msgData.data = &g_acm->lineCoding; msgData.size = sizeof(struct UsbCdcLineCoding); parmas.ctrlReq = UsbControlMsg(msgData); + parmas.userData = NULL; ret = UsbFillRequest(g_acm->ctrlReq, g_acm->ctrl_devHandle, &parmas); if (ret) { HDF_LOGE("%s: error", __func__); diff --git a/test/unittest/osal/osal_all_test.c b/test/unittest/osal/osal_all_test.c index d07f050c57ab96c3c5415458ecf91e6890cfb6a1..d407b3900b3df4a8f56401f537381e3d6f1d0102 100644 --- a/test/unittest/osal/osal_all_test.c +++ b/test/unittest/osal/osal_all_test.c @@ -451,19 +451,19 @@ void OsaIrqTest(void) ret = OsalRegisterIrq(IRQ_NUM_TEST, 0, IRQHandle, "test", &g_irqData); UT_TEST_CHECK_RET(ret != retFlag, OSAL_IRQ_REG_NORMAL); ret = OsalDisableIrq(IRQ_NUM_TEST); - UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TEST_OTHER); + UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_IRQ_REG_NORMAL); ret = OsalEnableIrq(IRQ_NUM_TEST); - UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TEST_OTHER); + UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_IRQ_REG_NORMAL); #if defined(__LITEOS__) ret = OsalUnregisterIrq(IRQ_NUM_TEST, &g_irqData); UT_TEST_CHECK_RET(ret != retFlag, OSAL_IRQ_UNREG_NORMAL); #endif ret = OsalDisableIrq(IRQ_NUM_TEST); - UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TEST_OTHER); + UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_IRQ_REG_NORMAL); ret = OsalEnableIrq(IRQ_NUM_TEST); - UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TEST_OTHER); + UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_IRQ_REG_NORMAL); #if defined(__LITEOS__) ret = OsalUnregisterIrq(IRQ_NUM_TEST, &g_irqData); @@ -474,9 +474,9 @@ void OsaIrqTest(void) ret = OsalRegisterIrq(IRQ_NUM_TEST, 0, IRQHandle, "test", &g_irqData); UT_TEST_CHECK_RET(ret != retFlag, OSAL_IRQ_REG_NORMAL_STRESS); ret = OsalDisableIrq(IRQ_NUM_TEST); - UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TEST_OTHER); + UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_IRQ_REG_NORMAL_STRESS); ret = OsalEnableIrq(IRQ_NUM_TEST); - UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_TEST_OTHER); + UT_TEST_CHECK_RET(ret != HDF_SUCCESS, OSAL_IRQ_REG_NORMAL_STRESS); #if defined(__LITEOS__) ret = OsalUnregisterIrq(IRQ_NUM_TEST, &g_irqData); UT_TEST_CHECK_RET(ret != retFlag, OSAL_IRQ_UNREG_NORMAL_STRESS); @@ -701,11 +701,13 @@ static void OsaMemoryTest(void) static void OsaLogTest(void) { HDF_LOGI("[OSAL_UT_TEST]%s start", __func__); - HDF_LOGE("%s", __func__); - HDF_LOGW("%s", __func__); - HDF_LOGI("%s", __func__); + HDF_LOGE("{private}%{private}s %{private}d{private}", __func__, __LINE__); + HDF_LOGW("%{public}s %{public}d", __func__, __LINE__); + HDF_LOGI("%{public}s %{private}d", __func__, __LINE__); + HDF_LOGI("%{private}s %{public}d", __func__, __LINE__); HDF_LOGD("%s", __func__); HDF_LOGV("%s", __func__); + HDF_LOGI("[OSAL_UT_TEST]%{private}s end", __func__); HDF_LOGI("[OSAL_UT_TEST]%s end", __func__); } @@ -806,7 +808,7 @@ int OsaTestBegin(void) #ifndef __USER__ ret = OsalTestFileInit(); #else - ret = 0; + ret = 0; #endif OsalTestOther(ret); OsaTimeTest(); diff --git a/test/unittest/osal/osal_get_case_test.c b/test/unittest/osal/osal_get_case_test.c index 63729bbd86a5f0da3590931fb11657a428adecb4..fccdc5a68d405e5116d7781f365562648c673961 100644 --- a/test/unittest/osal/osal_get_case_test.c +++ b/test/unittest/osal/osal_get_case_test.c @@ -6,7 +6,6 @@ * See the LICENSE file in the root of this repository for complete details. */ -#include "hdf_log.h" #include "osal_case_cmd_test.h" int OsalGetTestResult(uint32_t cmd) diff --git a/test/unittest/osal/osal_work_test.c b/test/unittest/osal/osal_work_test.c index 8f9a5eba4c4d67fb1fbf21437701577e736907dc..d92636de887fe4533ee3ec338368d806e67110f8 100644 --- a/test/unittest/osal/osal_work_test.c +++ b/test/unittest/osal/osal_work_test.c @@ -83,7 +83,7 @@ void TestAddRoute(int cnt) HdfAddDelayedWork(&g_workQue, &g_delayWork, g_delayTime); } else if (cnt % MSG_SEND_PERIOD == TEST_ITEM_NO_EVENT) { UT_TEST_CHECK_RET(g_osalWorkStatus, OSAL_WORK_RUN_CHECK); - UT_TEST_CHECK_RET(g_osalDelayStatus, OSAL_TEST_OTHER); + UT_TEST_CHECK_RET(g_osalDelayStatus, OSAL_DELAY_WORK_RUN_CHECK); } else if (cnt % MSG_SEND_PERIOD == MSG_NOSEND_CHECK_CNT) { g_delayTime = DELAY_TIME_FOR_OUT; g_osalDelayStatus = true; diff --git a/test/unittest/platform/common/dac_driver_test.c b/test/unittest/platform/common/dac_driver_test.c new file mode 100644 index 0000000000000000000000000000000000000000..b83386dfb282c3e4440ceb436d7eb2d622645d27 --- /dev/null +++ b/test/unittest/platform/common/dac_driver_test.c @@ -0,0 +1,127 @@ +/* + * Copyright (c) 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 "dac_test.h" +#include "device_resource_if.h" +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "hdf_log.h" + +#define HDF_LOG_TAG dac_test_driver_c + +static struct DacTestConfig g_config; + +static int32_t DacTestDispatch(struct HdfDeviceIoClient *client, int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGD("%s: enter!", __func__); + + if (cmd == 0) { + if (reply == NULL) { + HDF_LOGE("%s: reply is null!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (!HdfSbufWriteBuffer(reply, &g_config, sizeof(g_config))) { + HDF_LOGE("%s: write reply failed", __func__); + return HDF_ERR_IO; + } + } else { + return HDF_ERR_NOT_SUPPORT; + } + + return HDF_SUCCESS; +} + +static int32_t DacTestReadConfig(struct DacTestConfig *config, const struct DeviceResourceNode *node) +{ + int32_t ret; + struct DeviceResourceIface *drsOps = NULL; + + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetUint32 == NULL) { + HDF_LOGE("%s: invalid drs ops", __func__); + return HDF_FAILURE; + } + + ret = drsOps->GetUint32(node, "devNum", &config->devNum, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read devNum failed", __func__); + return ret; + } + + ret = drsOps->GetUint32(node, "channel", &config->channel, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read channel failed", __func__); + return ret; + } + + ret = drsOps->GetUint32(node, "maxChannel", &config->maxChannel, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read maxChannel failed", __func__); + return ret; + } + + ret = drsOps->GetUint32(node, "dataWidth", &config->dataWidth, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read dataWidth failed", __func__); + return ret; + } + + ret = drsOps->GetUint32(node, "rate", &config->rate, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read rate failed", __func__); + return ret; + } + + return HDF_SUCCESS; +} + +static int32_t DacTestBind(struct HdfDeviceObject *device) +{ + int32_t ret; + static struct IDeviceIoService service; + + if (device == NULL || device->property == NULL) { + HDF_LOGE("%s: device or config is null!", __func__); + return HDF_ERR_IO; + } + + ret = DacTestReadConfig(&g_config, device->property); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read config failed", __func__); + return ret; + } + service.Dispatch = DacTestDispatch; + device->service = &service; + HDF_LOGI("%s: Done!", __func__); + return HDF_SUCCESS; +} + +static int32_t DacTestInit(struct HdfDeviceObject *device) +{ + (void)device; + HDF_LOGI("%s: Done!", __func__); + return HDF_SUCCESS; +} + +static void DacTestRelease(struct HdfDeviceObject *device) +{ + if (device != NULL) { + device->service = NULL; + } + HDF_LOGI("%s: Done!", __func__); + return; +} + +struct HdfDriverEntry g_dacTestEntry = { + .moduleVersion = 1, + .Bind = DacTestBind, + .Init = DacTestInit, + .Release = DacTestRelease, + .moduleName = "PLATFORM_DAC_TEST", +}; +HDF_INIT(g_dacTestEntry); diff --git a/test/unittest/platform/common/dac_test.c b/test/unittest/platform/common/dac_test.c new file mode 100644 index 0000000000000000000000000000000000000000..6789ad16c90919db3b1b26bf28d43ae79d042109 --- /dev/null +++ b/test/unittest/platform/common/dac_test.c @@ -0,0 +1,241 @@ +/* + * Copyright (c) 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 "dac_test.h" +#include "dac_if.h" +#include "hdf_base.h" +#include "hdf_io_service_if.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "osal_thread.h" +#include "osal_time.h" +#include "securec.h" + +#define HDF_LOG_TAG dac_test_c +#define DAC_TEST_WAIT_TIMES 100 +#define TEST_DAC_VAL_NUM 50 +#define DAC_TEST_STACK_SIZE (1024 * 64) + +static int32_t DacTestGetConfig(struct DacTestConfig *config) +{ + int32_t ret; + struct HdfSBuf *reply = NULL; + struct HdfIoService *service = NULL; + const void *buf = NULL; + uint32_t len; + + service = HdfIoServiceBind("DAC_TEST"); + if (service == NULL) { + return HDF_ERR_NOT_SUPPORT; + } + + reply = HdfSBufObtain(sizeof(*config) + sizeof(uint64_t)); + if (reply == NULL) { + HDF_LOGE("%s: failed to obtain reply", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + ret = service->dispatcher->Dispatch(&service->object, 0, NULL, reply); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: remote dispatch failed", __func__); + return ret; + } + + if (!HdfSbufReadBuffer(reply, &buf, &len)) { + HDF_LOGE("%s: read buf failed", __func__); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + + if (len != sizeof(*config)) { + HDF_LOGE("%s: config size:%zu, read size:%u", __func__, sizeof(*config), len); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + + if (memcpy_s(config, sizeof(*config), buf, sizeof(*config)) != EOK) { + HDF_LOGE("%s: memcpy buf failed", __func__); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + HdfSBufRecycle(reply); + HDF_LOGD("%s: exit", __func__); + return HDF_SUCCESS; +} + +struct DacTester *DacTesterGet(void) +{ + int32_t ret; + static struct DacTester tester; + static bool hasInit = false; + + if (hasInit) { + return &tester; + } + ret = DacTestGetConfig(&tester.config); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: write config failed:%d", __func__, ret); + return NULL; + } + tester.handle = DacOpen(tester.config.devNum); + if (tester.handle == NULL) { + HDF_LOGE("%s: open dac device:%u failed", __func__, tester.config.devNum); + return NULL; + } + hasInit = true; + return &tester; +} + +int32_t DacTestWrite(void) +{ + struct DacTester *tester = NULL; + uint32_t value[TEST_DAC_VAL_NUM]; + int32_t ret; + int i; + + tester = DacTesterGet(); + if (tester == NULL || tester->handle == NULL) { + HDF_LOGE("%s: get tester failed", __func__); + return HDF_ERR_INVALID_OBJECT; + } + for (i = 0; i < TEST_DAC_VAL_NUM; i++) { + value[i] = 0; + ret = DacWrite(tester->handle, tester->config.channel, value[i]); + if (ret != HDF_SUCCESS || value[i] >= (1U << tester->config.dataWidth)) { + HDF_LOGE("%s: write value invalid:%u, ret:%d", __func__, value[i], ret); + return HDF_ERR_IO; + } + } + + return HDF_SUCCESS; +} + +static int DacTestThreadFunc(void *param) +{ + struct DacTester *tester = NULL; + uint32_t val; + int i; + int32_t ret; + tester = DacTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: get tester failed", __func__); + *((int32_t *)param) = 1; + return HDF_ERR_INVALID_OBJECT; + } + for (i = 0; i < DAC_TEST_WAIT_TIMES; i++) { + val = i; + ret = DacWrite(tester->handle, tester->config.channel, val); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: DacWrite failed, ret:%d", __func__, ret); + return HDF_ERR_IO; + } + } + + *((int32_t *)param) = 1; + return val; +} + +int32_t DacTestMultiThread(void) +{ + int32_t ret; + struct OsalThread thread1, thread2; + struct OsalThreadParam cfg1, cfg2; + int32_t count1, count2; + + count1 = count2 = 0; + ret = OsalThreadCreate(&thread1, (OsalThreadEntry)DacTestThreadFunc, (void *)&count1); + if (ret != HDF_SUCCESS) { + HDF_LOGE("create test thread1 fail:%d", ret); + return HDF_FAILURE; + } + + ret = OsalThreadCreate(&thread2, (OsalThreadEntry)DacTestThreadFunc, (void *)&count2); + if (ret != HDF_SUCCESS) { + HDF_LOGE("create test thread1 fail:%d", ret); + return HDF_FAILURE; + } + + cfg1.name = "DacTestThread-1"; + cfg2.name = "DacTestThread-2"; + cfg1.priority = cfg2.priority = OSAL_THREAD_PRI_DEFAULT; + cfg1.stackSize = cfg2.stackSize = DAC_TEST_STACK_SIZE; + + ret = OsalThreadStart(&thread1, &cfg1); + if (ret != HDF_SUCCESS) { + HDF_LOGE("start test thread1 fail:%d", ret); + return HDF_FAILURE; + } + + ret = OsalThreadStart(&thread2, &cfg2); + if (ret != HDF_SUCCESS) { + HDF_LOGE("start test thread2 fail:%d", ret); + return HDF_FAILURE; + } + + while (count1 == 0 || count2 == 0) { + HDF_LOGE("waitting testing thread finish..."); + OsalMSleep(DAC_TEST_WAIT_TIMES); + } + + (void)OsalThreadDestroy(&thread1); + (void)OsalThreadDestroy(&thread2); + return HDF_SUCCESS; +} + +int32_t DacTestReliability(void) +{ + struct DacTester *tester = NULL; + uint32_t val; + + val = 0; + tester = DacTesterGet(); + if (tester == NULL || tester->handle == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + HDF_LOGD("%s: test dfr for DacRead ...", __func__); + // invalid handle + (void)DacWrite(NULL, tester->config.channel, val); + // invalid channel + (void)DacWrite(tester->handle, tester->config.maxChannel + 1, val); + return HDF_SUCCESS; +} + +struct DacTestEntry { + int cmd; + int32_t (*func)(void); + const char *name; +}; +static struct DacTestEntry g_entry[] = { + { DAC_TEST_CMD_WRITE, DacTestWrite, "DacTestWrite" }, + { DAC_TEST_CMD_MULTI_THREAD, DacTestMultiThread, "DacTestMultiThread" }, + { DAC_TEST_CMD_RELIABILITY, DacTestReliability, "DacTestReliability" }, +}; + +int32_t DacTestExecute(int cmd) +{ + uint32_t i; + int32_t ret = HDF_ERR_NOT_SUPPORT; + + if (cmd > DAC_TEST_CMD_MAX) { + HDF_LOGE("%s: invalid cmd:%d", __func__, cmd); + ret = HDF_ERR_NOT_SUPPORT; + goto __EXIT__; + } + + for (i = 0; i < sizeof(g_entry) / sizeof(g_entry[0]); i++) { + if (g_entry[i].cmd != cmd || g_entry[i].func == NULL) { + continue; + } + ret = g_entry[i].func(); + break; + } + +__EXIT__: + HDF_LOGE("[%s][======cmd:%d====ret:%d======]", __func__, cmd, ret); + return ret; +} diff --git a/test/unittest/platform/common/dac_test.h b/test/unittest/platform/common/dac_test.h new file mode 100644 index 0000000000000000000000000000000000000000..4e25d2f0ce86266a16e865faf617673189e4fe87 --- /dev/null +++ b/test/unittest/platform/common/dac_test.h @@ -0,0 +1,48 @@ +/* + * Copyright (c) 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 DAC_TEST_H +#define DAC_TEST_H + +#include "dac_if.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +struct DacTestConfig { + uint32_t devNum; + uint32_t channel; + uint32_t maxChannel; + uint32_t dataWidth; + uint32_t rate; +}; + +struct DacTester { + struct DacTestConfig config; + DevHandle handle; +}; + +enum DacTestCmd { + DAC_TEST_CMD_WRITE = 0, + DAC_TEST_CMD_MULTI_THREAD, + DAC_TEST_CMD_RELIABILITY, + DAC_TEST_CMD_MAX, +}; + +int32_t DacTestExecute(int cmd); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* DAC_TEST_H */ diff --git a/test/unittest/platform/common/gpio_driver_test.c b/test/unittest/platform/common/gpio_driver_test.c new file mode 100644 index 0000000000000000000000000000000000000000..e8adc017f2592cef189e60b0a47532c5721c7ac0 --- /dev/null +++ b/test/unittest/platform/common/gpio_driver_test.c @@ -0,0 +1,116 @@ +/* + * Copyright (c) 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 "gpio_test.h" +#include "device_resource_if.h" +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "hdf_log.h" + +static struct GpioTestConfig g_config; + +static int32_t GpioTestDispatch(struct HdfDeviceIoClient *client, int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGD("%s: enter!", __func__); + + if (cmd == 0) { + if (reply == NULL) { + HDF_LOGE("%s: reply is null!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (!HdfSbufWriteBuffer(reply, &g_config, sizeof(g_config))) { + HDF_LOGE("%s: write reply failed", __func__); + return HDF_ERR_IO; + } + } else { + return HDF_ERR_NOT_SUPPORT; + } + + return HDF_SUCCESS; +} + +static int32_t GpioTestReadConfig(struct GpioTestConfig *config, const struct DeviceResourceNode *node) +{ + int32_t ret; + uint16_t tmp; + struct DeviceResourceIface *drsOps = NULL; + + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetUint16 == NULL) { + HDF_LOGE("%s: invalid drs ops fail!", __func__); + return HDF_FAILURE; + } + + ret = drsOps->GetUint16(node, "gpio", &tmp, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read gpio fail!", __func__); + return ret; + } + config->gpio = (uint16_t)tmp; + + ret = drsOps->GetUint16(node, "gpioIrq", &tmp, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read gpioIrq fail!", __func__); + return ret; + } + config->gpioIrq = (uint16_t)tmp; + + ret = drsOps->GetUint16(node, "testUserApi", &tmp, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGW("%s: read gpioIrq fail, using 0 as default", __func__); + config->testUserApi = 0; + } + config->testUserApi = (uint16_t)tmp; + + return HDF_SUCCESS; +} + +static int32_t GpioTestBind(struct HdfDeviceObject *device) +{ + int32_t ret; + static struct IDeviceIoService service; + + if (device == NULL || device->property == NULL) { + HDF_LOGE("%s: device or config is null!", __func__); + return HDF_ERR_IO; + } + + ret = GpioTestReadConfig(&g_config, device->property); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read config failed", __func__); + return ret; + } + + service.Dispatch = GpioTestDispatch; + device->service = &service; + + return HDF_SUCCESS; +} + +static int32_t GpioTestInit(struct HdfDeviceObject *device) +{ + (void)device; + return HDF_SUCCESS; +} + +static void GpioTestRelease(struct HdfDeviceObject *device) +{ + if (device != NULL) { + device->service = NULL; + } + return; +} + +struct HdfDriverEntry g_gpioTestEntry = { + .moduleVersion = 1, + .Bind = GpioTestBind, + .Init = GpioTestInit, + .Release = GpioTestRelease, + .moduleName = "PLATFORM_GPIO_TEST", +}; +HDF_INIT(g_gpioTestEntry); diff --git a/test/unittest/platform/common/gpio_test.c b/test/unittest/platform/common/gpio_test.c index 92e5520ce8bcee3d658187bb0dae6c547bc1f1bb..e64507ec78d4fdf7066f561f719a1b3f8ad6034c 100644 --- a/test/unittest/platform/common/gpio_test.c +++ b/test/unittest/platform/common/gpio_test.c @@ -7,31 +7,108 @@ */ #include "gpio_test.h" -#include "device_resource_if.h" #include "gpio_if.h" #include "hdf_base.h" -#include "hdf_device_desc.h" +#include "hdf_io_service_if.h" #include "hdf_log.h" #include "osal_irq.h" #include "osal_time.h" +#include "securec.h" #define HDF_LOG_TAG gpio_test #define GPIO_TEST_IRQ_TIMEOUT 1000 #define GPIO_TEST_IRQ_DELAY 200 -static int32_t GpioTestSetUp(struct GpioTester *tester) +static int32_t GpioTestGetConfig(struct GpioTestConfig *config) { int32_t ret; + struct HdfSBuf *reply = NULL; + struct HdfIoService *service = NULL; + const void *buf = NULL; + uint32_t len; + + HDF_LOGD("%s: enter!", __func__); + service = HdfIoServiceBind("GPIO_TEST"); + if (service == NULL) { + HDF_LOGE("%s: failed to bind gpio test server", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + reply = HdfSBufObtain(sizeof(*config) + sizeof(uint64_t)); + if (reply == NULL) { + HDF_LOGE("%s: failed to obtain reply", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + ret = service->dispatcher->Dispatch(&service->object, 0, NULL, reply); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: remote dispatch fail:%d", __func__, ret); + } + + if (!HdfSbufReadBuffer(reply, &buf, &len)) { + HDF_LOGE("%s: read buf failed", __func__); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + + if (len != sizeof(*config)) { + HDF_LOGE("%s: config size:%u, but read size:%u!", __func__, sizeof(*config), len); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + + if (memcpy_s(config, sizeof(*config), buf, sizeof(*config)) != EOK) { + HDF_LOGE("%s: memcpy buf failed", __func__); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + + HdfSBufRecycle(reply); + HDF_LOGD("%s: exit", __func__); + HdfIoServiceRecycle(service); + return HDF_SUCCESS; +} + +static struct GpioTester *GpioTesterGet(void) +{ + int32_t ret; + static struct GpioTester tester; + static struct GpioTester *pTester = NULL; + + if (pTester != NULL) { + return pTester; + } + + ret = GpioTestGetConfig(&tester.cfg); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: get config failed:%d", __func__, ret); + return NULL; + } + HDF_LOGI("%s: test cfg: gpio=%u, gpioIrq=%u, testUserApi=%u", __func__, + tester.cfg.gpio, tester.cfg.gpioIrq, tester.cfg.testUserApi); + + pTester = &tester; + return pTester; +} + +static int32_t GpioTestSetUp(void) +{ + int32_t ret; + struct GpioTester *tester = NULL; + + tester = GpioTesterGet(); if (tester == NULL) { + HDF_LOGE("%s: get tester failed", __func__); return HDF_ERR_INVALID_OBJECT; } - ret = GpioGetDir(tester->gpio, &tester->oldDir); + + ret = GpioGetDir(tester->cfg.gpio, &tester->oldDir); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: get old dir fail! ret:%d", __func__, ret); return ret; } - ret = GpioRead(tester->gpio, &tester->oldVal); + ret = GpioRead(tester->cfg.gpio, &tester->oldVal); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: read old val fail! ret:%d", __func__, ret); return ret; @@ -43,13 +120,18 @@ static int32_t GpioTestSetUp(struct GpioTester *tester) return HDF_SUCCESS; } -static int32_t GpioTestTearDown(struct GpioTester *tester) +static int32_t GpioTestTearDown(void) { int ret; + struct GpioTester *tester = NULL; + + tester = GpioTesterGet(); if (tester == NULL) { + HDF_LOGE("%s: get tester failed", __func__); return HDF_ERR_INVALID_OBJECT; } - ret = GpioSetDir(tester->gpio, tester->oldDir); + + ret = GpioSetDir(tester->cfg.gpio, tester->oldDir); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: set old dir fail! ret:%d", __func__, ret); return ret; @@ -57,7 +139,7 @@ static int32_t GpioTestTearDown(struct GpioTester *tester) if (tester->oldDir == GPIO_DIR_IN) { return HDF_SUCCESS; } - ret = GpioWrite(tester->gpio, tester->oldVal); + ret = GpioWrite(tester->cfg.gpio, tester->oldVal); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: write old val fail! ret:%d", __func__, ret); return ret; @@ -66,22 +148,29 @@ static int32_t GpioTestTearDown(struct GpioTester *tester) return HDF_SUCCESS; } -static int32_t TestCaseGpioSetGetDir(struct GpioTester *tester) +static int32_t GpioTestSetGetDir(void) { int32_t ret; uint16_t dirSet; uint16_t dirGet; + struct GpioTester *tester = NULL; + + tester = GpioTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: get tester failed", __func__); + return HDF_ERR_INVALID_OBJECT; + } dirSet = GPIO_DIR_OUT; dirGet = GPIO_DIR_IN; SET_GET_DIR: - ret = GpioSetDir(tester->gpio, dirSet); + ret = GpioSetDir(tester->cfg.gpio, dirSet); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: set dir fail! ret:%d", __func__, ret); return ret; } - ret = GpioGetDir(tester->gpio, &dirGet); + ret = GpioGetDir(tester->cfg.gpio, &dirGet); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: get dir fail! ret:%d", __func__, ret); return ret; @@ -99,13 +188,20 @@ SET_GET_DIR: return HDF_SUCCESS; } -static int32_t TestCaseGpioWriteRead(struct GpioTester *tester) +static int32_t GpioTestWriteRead(void) { int32_t ret; uint16_t valWrite; uint16_t valRead; + struct GpioTester *tester = NULL; - ret = GpioSetDir(tester->gpio, GPIO_DIR_OUT); + tester = GpioTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: get tester failed", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + ret = GpioSetDir(tester->cfg.gpio, GPIO_DIR_OUT); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: set dir fail! ret:%d", __func__, ret); return ret; @@ -114,12 +210,12 @@ static int32_t TestCaseGpioWriteRead(struct GpioTester *tester) valRead = GPIO_VAL_HIGH; WRITE_READ_VAL: - ret = GpioWrite(tester->gpio, valWrite); + ret = GpioWrite(tester->cfg.gpio, valWrite); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: write val:%u fail! ret:%d", __func__, valWrite, ret); return ret; } - ret = GpioRead(tester->gpio, &valRead); + ret = GpioRead(tester->cfg.gpio, &valRead); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: read fail! ret:%d", __func__, ret); return ret; @@ -137,7 +233,7 @@ WRITE_READ_VAL: return HDF_SUCCESS; } -static int32_t TestCaseGpioIrqHandler(uint16_t gpio, void *data) +static int32_t GpioTestIrqHandler(uint16_t gpio, void *data) { struct GpioTester *tester = (struct GpioTester *)data; @@ -149,7 +245,7 @@ static int32_t TestCaseGpioIrqHandler(uint16_t gpio, void *data) return HDF_FAILURE; } -static inline void TestHelperGpioInverse(uint16_t gpio, uint16_t mode) +static inline void GpioTestHelperInversePin(uint16_t gpio, uint16_t mode) { uint16_t dir = 0; uint16_t valRead = 0; @@ -161,20 +257,20 @@ static inline void TestHelperGpioInverse(uint16_t gpio, uint16_t mode) HDF_LOGD("%s, gpio:%u, val:%u, dir:%u, mode:%x", __func__, gpio, valRead, dir, mode); } -static int32_t TestCaseGpioIrq(struct GpioTester *tester, uint16_t mode, bool inverse) +static int32_t GpioTestIrqSharedFunc(struct GpioTester *tester, uint16_t mode, bool inverse) { int32_t ret; uint32_t timeout; - ret = GpioSetIrq(tester->gpioIrq, mode, TestCaseGpioIrqHandler, (void *)tester); + ret = GpioSetIrq(tester->cfg.gpioIrq, mode, GpioTestIrqHandler, (void *)tester); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: set irq fail! ret:%d", __func__, ret); return ret; } - ret = GpioEnableIrq(tester->gpioIrq); + ret = GpioEnableIrq(tester->cfg.gpioIrq); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: enable irq fail! ret:%d", __func__, ret); - (void)GpioUnSetIrq(tester->gpioIrq); + (void)GpioUnSetIrq(tester->cfg.gpioIrq); return ret; } @@ -182,11 +278,11 @@ static int32_t TestCaseGpioIrq(struct GpioTester *tester, uint16_t mode, bool in timeout += GPIO_TEST_IRQ_DELAY) { if (inverse) { // maybe can make a inverse ... - TestHelperGpioInverse(tester->gpioIrq, mode); + GpioTestHelperInversePin(tester->cfg.gpioIrq, mode); } OsalMSleep(GPIO_TEST_IRQ_DELAY); } - (void)GpioUnSetIrq(tester->gpioIrq); + (void)GpioUnSetIrq(tester->cfg.gpioIrq); #if defined(_LINUX_USER_) || defined(__KERNEL__) if (inverse) { @@ -195,69 +291,99 @@ static int32_t TestCaseGpioIrq(struct GpioTester *tester, uint16_t mode, bool in } #endif if (tester->irqCnt <= 0) { - HDF_LOGE("%s: set mode:%x on %u failed", __func__, mode, tester->gpioIrq); + HDF_LOGE("%s: set mode:%x on %u failed", __func__, mode, tester->cfg.gpioIrq); return HDF_FAILURE; } return HDF_SUCCESS; } -static int32_t TestCaseGpioIrqLevel(struct GpioTester *tester) +static int32_t GpioTestIrqLevel(void) { - (void)tester; return HDF_SUCCESS; } -static int32_t TestCaseGpioIrqEdge(struct GpioTester *tester) +static int32_t GpioTestIrqEdge(void) { +#if defined(_LINUX_USER_) || defined(__USER__) + (void)GpioTestIrqSharedFunc; + return HDF_SUCCESS; +#else uint16_t mode; + struct GpioTester *tester = NULL; + + tester = GpioTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: get tester failed", __func__); + return HDF_ERR_INVALID_OBJECT; + } /* set dir to out for self trigger on liteos */ #if defined(_LINUX_USER_) || defined(__KERNEL__) - (void)GpioSetDir(tester->gpioIrq, GPIO_DIR_IN); + (void)GpioSetDir(tester->cfg.gpioIrq, GPIO_DIR_IN); #else - (void)GpioSetDir(tester->gpioIrq, GPIO_DIR_OUT); + (void)GpioSetDir(tester->cfg.gpioIrq, GPIO_DIR_OUT); #endif mode = GPIO_IRQ_TRIGGER_FALLING | GPIO_IRQ_TRIGGER_RISING; - return TestCaseGpioIrq(tester, mode, true); + return GpioTestIrqSharedFunc(tester, mode, true); +#endif } -int32_t TestCaseGpioIrqThread(struct GpioTester *tester) +int32_t GpioTestIrqThread(void) { +#if defined(_LINUX_USER_) || defined(__USER__) + return HDF_SUCCESS; +#else uint16_t mode; + struct GpioTester *tester = NULL; + + tester = GpioTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: get tester failed", __func__); + return HDF_ERR_INVALID_OBJECT; + } + /* set dir to out for self trigger on liteos */ #if defined(_LINUX_USER_) || defined(__KERNEL__) - (void)GpioSetDir(tester->gpioIrq, GPIO_DIR_IN); + (void)GpioSetDir(tester->cfg.gpioIrq, GPIO_DIR_IN); #else - (void)GpioSetDir(tester->gpioIrq, GPIO_DIR_OUT); + (void)GpioSetDir(tester->cfg.gpioIrq, GPIO_DIR_OUT); #endif mode = GPIO_IRQ_TRIGGER_FALLING | GPIO_IRQ_TRIGGER_RISING | GPIO_IRQ_USING_THREAD; - return TestCaseGpioIrq(tester, mode, true); + return GpioTestIrqSharedFunc(tester, mode, true); +#endif } -static int32_t TestCaseGpioReliability(struct GpioTester *tester) +static int32_t GpioTestReliability(void) { uint16_t val = 0; + struct GpioTester *tester = NULL; + + tester = GpioTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: get tester failed", __func__); + return HDF_ERR_INVALID_OBJECT; + } (void)GpioWrite(-1, val); /* invalid gpio number */ - (void)GpioWrite(tester->gpio, -1); /* invalid gpio value */ + (void)GpioWrite(tester->cfg.gpio, -1); /* invalid gpio value */ (void)GpioRead(-1, &val); /* invalid gpio number */ - (void)GpioRead(tester->gpio, NULL); /* invalid pointer */ + (void)GpioRead(tester->cfg.gpio, NULL); /* invalid pointer */ (void)GpioSetDir(-1, val); /* invalid gpio number */ - (void)GpioSetDir(tester->gpio, -1); /* invalid value */ + (void)GpioSetDir(tester->cfg.gpio, -1); /* invalid value */ (void)GpioGetDir(-1, &val); /* invalid gpio number */ - (void)GpioGetDir(tester->gpio, NULL); /* invalid pointer */ + (void)GpioGetDir(tester->cfg.gpio, NULL); /* invalid pointer */ /* invalid gpio number */ - (void)GpioSetIrq(-1, OSAL_IRQF_TRIGGER_RISING, TestCaseGpioIrqHandler, (void *)tester); + (void)GpioSetIrq(-1, OSAL_IRQF_TRIGGER_RISING, GpioTestIrqHandler, (void *)tester); /* invalid irq mode */ - (void)GpioSetIrq(tester->gpioIrq, -1, TestCaseGpioIrqHandler, (void *)tester); + (void)GpioSetIrq(tester->cfg.gpioIrq, -1, GpioTestIrqHandler, (void *)tester); /* invalid irq handler */ - (void)GpioSetIrq(tester->gpioIrq, OSAL_IRQF_TRIGGER_RISING, NULL, (void *)tester); + (void)GpioSetIrq(tester->cfg.gpioIrq, OSAL_IRQF_TRIGGER_RISING, NULL, (void *)tester); /* invalid irq data */ - (void)GpioSetIrq(tester->gpioIrq, OSAL_IRQF_TRIGGER_RISING, TestCaseGpioIrqHandler, NULL); + (void)GpioSetIrq(tester->cfg.gpioIrq, OSAL_IRQF_TRIGGER_RISING, GpioTestIrqHandler, NULL); (void)GpioUnSetIrq(-1); /* invalid gpio number */ @@ -268,129 +394,73 @@ static int32_t TestCaseGpioReliability(struct GpioTester *tester) return HDF_SUCCESS; } -static int32_t GpioTestByCmd(struct GpioTester *tester, int32_t cmd) -{ - int32_t i; - - if (cmd == GPIO_TEST_SET_GET_DIR) { - return TestCaseGpioSetGetDir(tester); - } else if (cmd == GPIO_TEST_WRITE_READ) { - return TestCaseGpioWriteRead(tester); - } else if (cmd == GPIO_TEST_IRQ_LEVEL) { - return TestCaseGpioIrqLevel(tester); - } else if (cmd == GPIO_TEST_IRQ_EDGE) { - return TestCaseGpioIrqEdge(tester); - } else if (cmd == GPIO_TEST_IRQ_THREAD) { - return TestCaseGpioIrqThread(tester); - } else if (cmd == GPIO_TEST_RELIABILITY) { - return TestCaseGpioReliability(tester); - } +struct GpioTestEntry { + int cmd; + int32_t (*func)(void); + const char *name; +}; - for (i = 0; i < GPIO_TEST_MAX; i++) { - if (GpioTestByCmd(tester, i) != HDF_SUCCESS) { - tester->fails++; - } - } - HDF_LOGE("%s: **********PASS:%u FAIL:%u**************\n\n", - __func__, tester->total - tester->fails, tester->fails); - return (tester->fails > 0) ? HDF_FAILURE : HDF_SUCCESS; -} +static struct GpioTestEntry g_entry[] = { + { GPIO_TEST_SET_GET_DIR, GpioTestSetGetDir, "GpioTestSetGetDir" }, + { GPIO_TEST_WRITE_READ, GpioTestWriteRead, "GpioTestWriteRead" }, + { GPIO_TEST_IRQ_LEVEL, GpioTestIrqLevel, "GpioTestIrqLevel" }, + { GPIO_TEST_IRQ_EDGE, GpioTestIrqEdge, "GpioTestIrqEdge" }, + { GPIO_TEST_IRQ_THREAD, GpioTestIrqThread, "GpioTestIrqThread" }, + { GPIO_TEST_RELIABILITY, GpioTestReliability, "GpioTestReliability" }, +}; -static int32_t GpioTestDoTest(struct GpioTester *tester, int32_t cmd) +int32_t GpioTestExecute(int cmd) { - int32_t ret; + uint32_t i; + int32_t ret = HDF_ERR_NOT_SUPPORT; +#if defined(_LINUX_USER_) || defined(__USER__) + struct GpioTester *tester = GpioTesterGet(); if (tester == NULL) { - return HDF_ERR_INVALID_OBJECT; + HDF_LOGI("%s: tester is null", __func__); + return HDF_SUCCESS; } - - ret = GpioTestSetUp(tester); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: setup fail!", __func__); - return ret; + if (tester->cfg.testUserApi == 0) { + HDF_LOGI("%s: do not test user api", __func__); + return HDF_SUCCESS; } +#endif - ret = GpioTestByCmd(tester, cmd); - - (void)GpioTestTearDown(tester); - return ret; -} - -static int32_t GpioTestReadConfig(struct GpioTester *tester, const struct DeviceResourceNode *node) -{ - int32_t ret; - uint32_t tmp; - struct DeviceResourceIface *drsOps = NULL; + for (i = 0; i < sizeof(g_entry) / sizeof(g_entry[0]); i++) { + if (g_entry[i].cmd != cmd || g_entry[i].func == NULL) { + continue; + } + ret = GpioTestSetUp(); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: setup failed", __func__); + return ret; + } - drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); - if (drsOps == NULL || drsOps->GetUint32 == NULL) { - HDF_LOGE("%s: invalid drs ops fail!", __func__); - return HDF_FAILURE; - } + ret = g_entry[i].func(); - ret = drsOps->GetUint32(node, "gpio", &tmp, 0); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: read gpio fail!", __func__); - return ret; + (void)GpioTestTearDown(); + break; } - tester->gpio = (uint16_t)tmp; - ret = drsOps->GetUint32(node, "gpioIrq", &tmp, 0); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: read gpioIrq fail!", __func__); - return ret; + if (ret == HDF_ERR_NOT_SUPPORT) { + HDF_LOGE("%s: cmd:%d not supportted", __func__, cmd); } - tester->gpioIrq = (uint16_t)tmp; - tester->doTest = GpioTestDoTest; - return HDF_SUCCESS; + HDF_LOGI("[%s][======cmd:%d====ret:%d======]", __func__, cmd, ret); + return ret; } -static int32_t GpioTestBind(struct HdfDeviceObject *device) +void GpioTestExecuteAll(void) { + int32_t i; int32_t ret; - static struct GpioTester tester; + int32_t fails = 0; - if (device == NULL || device->property == NULL) { - HDF_LOGE("%s: device or property is null!", __func__); - return HDF_ERR_INVALID_OBJECT; - } - - ret = GpioTestReadConfig(&tester, device->property); - if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: read config fail!", __func__); - return ret; + for (i = 0; i < GPIO_TEST_MAX; i++) { + ret = GpioTestExecute(i); + fails += (ret != HDF_SUCCESS) ? 1 : 0; } - tester.total = GPIO_TEST_MAX; - device->service = &tester.service; - -#ifdef GPIO_TEST_ON_INIT - HDF_LOGE("%s: test on init!", __func__); - tester.doTest(&tester, -1); -#endif - return HDF_SUCCESS; -} - -static int32_t GpioTestInit(struct HdfDeviceObject *device) -{ - (void)device; - return HDF_SUCCESS; -} - -static void GpioTestRelease(struct HdfDeviceObject *device) -{ - if (device != NULL) { - device->service = NULL; - } - return; + HDF_LOGE("%s: **********PASS:%d FAIL:%d************\n\n", + __func__, GPIO_TEST_MAX - fails, fails); } - -struct HdfDriverEntry g_gpioTestEntry = { - .moduleVersion = 1, - .Bind = GpioTestBind, - .Init = GpioTestInit, - .Release = GpioTestRelease, - .moduleName = "PLATFORM_GPIO_TEST", -}; -HDF_INIT(g_gpioTestEntry); diff --git a/test/unittest/platform/common/gpio_test.h b/test/unittest/platform/common/gpio_test.h index 6d8b1940639739479568c9e01b42423e064a8ee5..f31f766c643b4e5b9e921d65af1acd3a8a06f713 100644 --- a/test/unittest/platform/common/gpio_test.h +++ b/test/unittest/platform/common/gpio_test.h @@ -9,7 +9,13 @@ #ifndef GPIO_TEST_H #define GPIO_TEST_H -#include "hdf_device_desc.h" +#include "hdf_base.h" + +#ifdef __cplusplus +extern "C" { +#endif + +int32_t GpioTestExecute(int cmd); enum GpioTestCmd { GPIO_TEST_SET_GET_DIR = 0, @@ -21,12 +27,14 @@ enum GpioTestCmd { GPIO_TEST_MAX = 6, }; -struct GpioTester { - struct IDeviceIoService service; - struct HdfDeviceObject *device; - int32_t (*doTest)(struct GpioTester *tester, int32_t cmd); +struct GpioTestConfig { uint16_t gpio; uint16_t gpioIrq; + uint16_t testUserApi; +}; + +struct GpioTester { + struct GpioTestConfig cfg; uint16_t oldDir; uint16_t oldVal; uint16_t irqCnt; @@ -35,9 +43,8 @@ struct GpioTester { uint32_t irqTimeout; }; -static inline struct GpioTester *GpioTesterGet(void) -{ - return (struct GpioTester *)DevSvcManagerClntGetService("GPIO_TEST"); +#ifdef __cplusplus } +#endif #endif /* GPIO_TEST_H */ diff --git a/test/unittest/platform/common/hdmi_test.c b/test/unittest/platform/common/hdmi_test.c new file mode 100644 index 0000000000000000000000000000000000000000..540a52715315e49dba969a3f40473799f4f3ac16 --- /dev/null +++ b/test/unittest/platform/common/hdmi_test.c @@ -0,0 +1,303 @@ +/* + * Copyright (c) 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 "hdmi_test.h" +#include "device_resource_if.h" +#include "hdf_base.h" +#include "hdf_log.h" +#include "hdmi_if.h" +#include "osal_time.h" + +#define HDF_LOG_TAG hdmi_test_c + +struct HdmiTestFunc { + enum HdmiTestCmd type; + int32_t (*Func)(struct HdmiTester *tester); +}; + +static DevHandle HdmiTestGetHandle(struct HdmiTester *tester) +{ + if (tester == NULL) { + HDF_LOGE("%s: tester is null", __func__); + return NULL; + } + return HdmiOpen(tester->busNum); +} + +static void HdmiTestReleaseHandle(DevHandle handle) +{ + if (handle == NULL) { + HDF_LOGE("%s: sdio handle is null", __func__); + return; + } + HdmiClose(handle); +} + +static int32_t TestHdmiStartAndStop(struct HdmiTester *tester) +{ + int32_t ret; + + ret = HdmiStart(tester->handle); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: HdmiStart failed ret = %d.", __func__, ret); + return ret; + } + ret = HdmiStop(tester->handle); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: HdmiStop failed ret = %d.", __func__, ret); + } + return ret; +} + +static int32_t TestHdmiSetAudioAttr(struct HdmiTester *tester) +{ + int32_t ret; + struct HdmiAudioAttr attr = {0}; + + attr.codingType = HDMI_AUDIO_CODING_TYPE_STREAM; + attr.ifType = HDMI_AUDIO_IF_TYPE_I2S; + attr.bitDepth = HDMI_ADIO_BIT_DEPTH_20; + attr.sampleRate = HDMI_SAMPLE_RATE_12K; + attr.channels = HDMI_AUDIO_FORMAT_CHANNEL_5; + ret = HdmiSetAudioAttribute(tester->handle, &attr); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: HdmiSetAudioAttribute failed ret = %d.", __func__, ret); + } + return ret; +} + +static int32_t TestHdmiSetVideoAttr(struct HdmiTester *tester) +{ + int32_t ret; + struct HdmiVideoAttr attr = {0}; + + attr.xvycc = true; + attr.nups = HDMI_NUPS_HORIZONTAL; + attr.colorSpace = HDMI_COLOR_SPACE_YCBCR420; + attr.colorimetry = HDMI_COLORIMETRY_ITU709; + attr.quantization = HDMI_QUANTIZATION_RANGE_FULL; + ret = HdmiSetVideoAttribute(tester->handle, &attr); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: HdmiSetAudioAttribute failed ret = %d.", __func__, ret); + } + return ret; +} + +static int32_t TestHdmiSetHdrAttr(struct HdmiTester *tester) +{ + int32_t ret; + struct HdmiHdrAttr attr = {0}; + + attr.mode = HDMI_HDR_MODE_DOLBY_NORMAL; + attr.userMode = HDMI_HDR_USERMODE_DOLBY; + attr.eotfType = HDMI_EOTF_HLG; + attr.colorimetry = HDMI_HDR_EXTENDED_COLORIMETRY_S_YCC_601; + attr.metadataType = HDMI_DRM_STATIC_METADATA_TYPE_1; + ret = HdmiSetHdrAttribute(tester->handle, &attr); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: HdmiSetHdrAttribute failed ret=%d.", __func__, ret); + } + return ret; +} + +static int32_t TestHdmiSetAvmute(struct HdmiTester *tester) +{ + int32_t ret; + + ret = HdmiAvmuteSet(tester->handle, true); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: HdmiAvmuteSet failed ret = %d.", __func__, ret); + return ret; + } + + ret = HdmiAvmuteSet(tester->handle, false); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: HdmiAvmuteSet failed ret = %d.", __func__, ret); + } + return ret; +} + +static int32_t TestHdmiEdidRawDataGet(struct HdmiTester *tester) +{ + int32_t len; + uint8_t edid[HDMI_EDID_MAX_LEN] = {0}; + + len = HdmiReadSinkEdid(tester->handle, edid, HDMI_EDID_MAX_LEN); + if (len < 0) { + HDF_LOGE("%s: HdmiReadSinkEdid failed len = %d.", __func__, len); + return HDF_FAILURE; + } + HDF_LOGD("%s: HdmiReadSinkEdid success, len = %d, edid[1] = 0x%x.", __func__, len, edid[1]); + return HDF_SUCCESS; +} + +static int32_t TestHdmiDeepColorSetAndGet(struct HdmiTester *tester) +{ + int32_t ret; + enum HdmiDeepColor color = HDMI_DEEP_COLOR_BUTT; + + ret = HdmiDeepColorSet(tester->handle, HDMI_DEEP_COLOR_48BITS); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: HdmiDeepColorSet failed ret = %d.", __func__, ret); + } + ret = HdmiDeepColorGet(tester->handle, &color); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: HdmiDeepColorGet failed ret = %d.", __func__, ret); + } else { + HDF_LOGE("%s: HdmiDeepColorGet success, color = %d.", __func__, color); + } + return ret; +} + +static void TestHdmiHdpHandle(void *data, bool hdp) +{ + if (data == NULL) { + printf("data is null"); + } + + if (hdp == true) { + HDF_LOGE("TestHdmiHdpHandle: hdp."); + } else { + HDF_LOGE("TestHdmiHdpHandle: unhdp."); + } +} + +static int32_t TestHdmiHpdRegisterAndUnregister(struct HdmiTester *tester) +{ + int32_t ret; + struct HdmiHpdCallbackInfo info; + + info.data = NULL; + info.callbackFunc = TestHdmiHdpHandle; + ret = HdmiRegisterHpdCallbackFunc(tester->handle, &info); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: TestHdmiHpdRegisterAndUnregister failed ret = %d.", __func__, ret); + } + ret = HdmiUnregisterHpdCallbackFunc(tester->handle); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: HdmiUnregisterHpdCallbackFunc failed ret = %d.", __func__, ret); + } + return ret; +} + +struct HdmiTestFunc g_hdmiTestFunc[] = { + { HDMI_START_AND_STOP_01, TestHdmiStartAndStop }, + { HDMI_SET_AUDIO_ATTR_01, TestHdmiSetAudioAttr }, + { HDMI_SET_VIDEO_ATTR_01, TestHdmiSetVideoAttr }, + { HDMI_SET_HDR_ATTR_01, TestHdmiSetHdrAttr }, + { HDMI_SET_AVMUTE_01, TestHdmiSetAvmute }, + { HDMI_EDID_RAW_DATA_GET_01, TestHdmiEdidRawDataGet }, + { HDMI_DEEP_COLOR_SET_AND_GET_01, TestHdmiDeepColorSetAndGet }, + { HDMI_HPD_REGISTER_AND_UNREGISTER_01, TestHdmiHpdRegisterAndUnregister }, +}; + +static int32_t HdmiTestEntry(struct HdmiTester *tester, int32_t cmd) +{ + int32_t i; + int32_t ret = HDF_SUCCESS; + bool isFind = false; + + if (tester == NULL) { + HDF_LOGE("%s: tester is NULL", __func__); + return HDF_ERR_INVALID_OBJECT; + } + tester->handle = HdmiTestGetHandle(tester); + if (tester->handle == NULL) { + HDF_LOGE("%s: hdmi test get handle failed", __func__); + return HDF_FAILURE; + } + for (i = 0; i < sizeof(g_hdmiTestFunc) / sizeof(g_hdmiTestFunc[0]); i++) { + if (cmd == g_hdmiTestFunc[i].type && g_hdmiTestFunc[i].Func != NULL) { + ret = g_hdmiTestFunc[i].Func(tester); + isFind = true; + break; + } + } + if (!isFind) { + ret = HDF_ERR_NOT_SUPPORT; + HDF_LOGE("%s: cmd %d not supported", __func__, cmd); + } + HdmiTestReleaseHandle(tester->handle); + return ret; +} + +static int32_t HdmiTestFillConfig(struct HdmiTester *tester, const struct DeviceResourceNode *node) +{ + int32_t ret; + struct DeviceResourceIface *drsOps = NULL; + + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetUint32 == NULL) { + HDF_LOGE("%s: invalid drs ops", __func__); + return HDF_FAILURE; + } + + ret = drsOps->GetUint32(node, "busNum", &(tester->busNum), 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: fill bus num failed", __func__); + return ret; + } + + HDF_LOGE("%s: busNum:%d.", __func__, tester->busNum); + return HDF_SUCCESS; +} + +static int32_t HdmiTestBind(struct HdfDeviceObject *device) +{ + static struct HdmiTester tester; + + if (device == NULL) { + HDF_LOGE("%s: device or config is null!", __func__); + return HDF_ERR_IO; + } + + device->service = &tester.service; + HDF_LOGE("%s: HDMI_TEST service init success!", __func__); + return HDF_SUCCESS; +} + +static int32_t HdmiTestInit(struct HdfDeviceObject *device) +{ + struct HdmiTester *tester = NULL; + int32_t ret; + + if (device == NULL || device->service == NULL || device->property == NULL) { + HDF_LOGE("%s: invalid parameter", __func__); + return HDF_ERR_INVALID_PARAM; + } + + tester = (struct HdmiTester *)device->service; + if (tester == NULL) { + HDF_LOGE("%s: tester is NULL", __func__); + return HDF_ERR_INVALID_PARAM; + } + ret = HdmiTestFillConfig(tester, device->property); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read config failed", __func__); + return ret; + } + tester->TestEntry = HdmiTestEntry; + HDF_LOGE("%s: success", __func__); + return HDF_SUCCESS; +} + +static void HdmiTestRelease(struct HdfDeviceObject *device) +{ + if (device != NULL) { + device->service = NULL; + } +} + +struct HdfDriverEntry g_hdmiTestEntry = { + .moduleVersion = 1, + .Bind = HdmiTestBind, + .Init = HdmiTestInit, + .Release = HdmiTestRelease, + .moduleName = "PLATFORM_HDMI_TEST", +}; +HDF_INIT(g_hdmiTestEntry); diff --git a/test/unittest/platform/common/hdmi_test.h b/test/unittest/platform/common/hdmi_test.h new file mode 100644 index 0000000000000000000000000000000000000000..109138e4f2ec0edcec555f9418379e5088e9056a --- /dev/null +++ b/test/unittest/platform/common/hdmi_test.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 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 HDMI_TEST_H +#define HDMI_TEST_H + +#include "hdf_device_desc.h" +#include "hdf_platform.h" + +enum HdmiTestCmd { + HDMI_START_AND_STOP_01 = 0, + HDMI_SET_AUDIO_ATTR_01 = 1, + HDMI_SET_VIDEO_ATTR_01 = 2, + HDMI_SET_HDR_ATTR_01 = 3, + HDMI_SET_AVMUTE_01 = 4, + HDMI_EDID_RAW_DATA_GET_01 = 5, + HDMI_DEEP_COLOR_SET_AND_GET_01 = 6, + HDMI_HPD_REGISTER_AND_UNREGISTER_01 = 7, +}; + +struct HdmiTester { + struct IDeviceIoService service; + struct HdfDeviceObject *device; + int32_t (*TestEntry)(struct HdmiTester *tester, int32_t cmd); + uint32_t busNum; + DevHandle handle; +}; + +static inline struct HdmiTester *GetHdmiTester(void) +{ + return (struct HdmiTester *)DevSvcManagerClntGetService("HDMI_TEST"); +} + +#endif /* HDMI_TEST_H */ diff --git a/test/unittest/platform/common/i2s_test.c b/test/unittest/platform/common/i2s_test.c index 241417cace166e904e8a63fd9a515ce50e7d8771..9415b9b52daf5df366c768d2b7e4991f68e0b260 100644 --- a/test/unittest/platform/common/i2s_test.c +++ b/test/unittest/platform/common/i2s_test.c @@ -209,7 +209,12 @@ static int32_t I2sReadTest(struct I2sTest *test) return HDF_FAILURE; } - if (memcpy_s(test->wbuf, test->len, test->rbuf, test->len) != EOK) { + if (test->len > I2S_DATA_BUF_SIZE) { + HDF_LOGE("%s:I2sRead read data too large \n", __func__); + return HDF_FAILURE; + } + + if (memcpy_s(test->wbuf, I2S_DATA_BUF_SIZE, test->rbuf, test->len) != EOK) { HDF_LOGE("%s: memcpy buf failed", __func__); return HDF_ERR_IO; } diff --git a/test/unittest/platform/common/i3c_driver_test.c b/test/unittest/platform/common/i3c_driver_test.c new file mode 100644 index 0000000000000000000000000000000000000000..b648f961ad9805bbf502f4bdb4a2671fdd210481 --- /dev/null +++ b/test/unittest/platform/common/i3c_driver_test.c @@ -0,0 +1,126 @@ +/* + * Copyright (c) 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 "i3c_test.h" +#include "device_resource_if.h" +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "hdf_log.h" + +#define HDF_LOG_TAG i3c_driver_test_c + +static struct I3cTestConfig g_config; + +static int32_t I3cTestDispatch(struct HdfDeviceIoClient *client, int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + HDF_LOGD("%s: enter!", __func__); + + if (cmd == 0) { + if (reply == NULL) { + HDF_LOGE("%s: reply is null!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (!HdfSbufWriteBuffer(reply, &g_config, sizeof(g_config))) { + HDF_LOGE("%s: write reply failed", __func__); + return HDF_ERR_IO; + } + } else { + return HDF_ERR_NOT_SUPPORT; + } + + return HDF_SUCCESS; +} + +static int32_t I3cTestReadConfig(struct I3cTestConfig *config, const struct DeviceResourceNode *node) +{ + int32_t ret; + struct DeviceResourceIface *drsOps = NULL; + + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetUint16 == NULL) { + HDF_LOGE("%s: invalid drs ops", __func__); + return HDF_FAILURE; + } + + ret = drsOps->GetUint16(node, "busId", &config->busId, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read busId failed", __func__); + return ret; + } + + ret = drsOps->GetUint16(node, "devAddr", &config->devAddr, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read dev addr failed", __func__); + return ret; + } + + ret = drsOps->GetUint16(node, "regLen", &config->regLen, 1); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read reg len failed", __func__); + return ret; + } + + ret = drsOps->GetUint16(node, "regAddr", &config->regAddr, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read reg addr failed", __func__); + return ret; + } + + ret = drsOps->GetUint16(node, "bufSize", &config->bufSize, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read buf size failed", __func__); + return ret; + } + return HDF_SUCCESS; +} + +static int32_t I3cTestBind(struct HdfDeviceObject *device) +{ + int32_t ret; + static struct IDeviceIoService service; + + if (device == NULL || device->property == NULL) { + HDF_LOGE("%s: device or config is null!", __func__); + return HDF_ERR_IO; + } + + ret = I3cTestReadConfig(&g_config, device->property); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read config failed", __func__); + return ret; + } + service.Dispatch = I3cTestDispatch; + device->service = &service; + HDF_LOGI("%s: Done!", __func__); + return HDF_SUCCESS; +} + +static int32_t I3cTestInit(struct HdfDeviceObject *device) +{ + (void)device; + HDF_LOGI("%s: Done!", __func__); + return HDF_SUCCESS; +} + +static void I3cTestRelease(struct HdfDeviceObject *device) +{ + if (device != NULL) { + device->service = NULL; + } + HDF_LOGI("%s: Done!", __func__); + return; +} + +struct HdfDriverEntry g_i3cTestEntry = { + .moduleVersion = 1, + .Bind = I3cTestBind, + .Init = I3cTestInit, + .Release = I3cTestRelease, + .moduleName = "PLATFORM_I3C_TEST", +}; +HDF_INIT(g_i3cTestEntry); diff --git a/test/unittest/platform/common/i3c_test.c b/test/unittest/platform/common/i3c_test.c new file mode 100644 index 0000000000000000000000000000000000000000..a84b884151b2f11f21d53ce2827631eb60d0f2bb --- /dev/null +++ b/test/unittest/platform/common/i3c_test.c @@ -0,0 +1,517 @@ +/* + * Copyright (c) 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 "i3c_test.h" +#include "hdf_base.h" +#include "hdf_io_service_if.h" +#include "hdf_log.h" +#include "i3c_ccc.h" +#include "i3c_if.h" +#include "osal_mem.h" +#include "osal_thread.h" +#include "osal_time.h" +#include "securec.h" + +#define HDF_LOG_TAG i3c_test_c + +#define I3C_TEST_MSG_NUM 2 +#define I3C_TEST_8BIT 8 +#define I3C_TEST_WAIT_TIMES 100 +#define I3C_TEST_WAIT_TIMEOUT 20 +#define I3C_TEST_STACK_SIZE (1024 * 256) +#define I3C_TEST_IBI_PAYLOAD 16 +#define I3C_TEST_REG_LEN 2 + +static struct I3cMsg g_msgs[I3C_TEST_MSG_NUM]; +static uint8_t *g_buf; +static uint8_t g_regs[I3C_TEST_REG_LEN]; + +struct I3cTestEntry { + int cmd; + int32_t (*func)(void *param); + const char *name; +}; + +static int32_t I3cTestGetTestConfig(struct I3cTestConfig *config) +{ + int32_t ret; + struct HdfSBuf *reply = NULL; + struct HdfIoService *service = NULL; + const void *buf = NULL; + uint32_t len; + + service = HdfIoServiceBind("I3C_TEST"); + if (service == NULL) { + return HDF_ERR_NOT_SUPPORT; + } + + reply = HdfSBufObtain(sizeof(*config) + sizeof(uint64_t)); + if (reply == NULL) { + HDF_LOGE("%s: Failed to obtain reply", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + ret = service->dispatcher->Dispatch(&service->object, 0, NULL, reply); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Remote dispatch failed", __func__); + return ret; + } + + if (!HdfSbufReadBuffer(reply, &buf, &len)) { + HDF_LOGE("%s: Read buf failed", __func__); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + + if (len != sizeof(*config)) { + HDF_LOGE("%s: Config size:%zu, read size:%u", __func__, sizeof(*config), len); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + + if (memcpy_s(config, sizeof(*config), buf, sizeof(*config)) != EOK) { + HDF_LOGE("%s: Memcpy buf failed", __func__); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + HdfSBufRecycle(reply); + HDF_LOGD("%s: Done", __func__); + return HDF_SUCCESS; +} + +struct I3cTester *I3cTesterGet(void) +{ + int32_t ret; + static struct I3cTester tester; + static bool hasInit = false; + + if (hasInit) { + return &tester; + } + ret = I3cTestGetTestConfig(&tester.config); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read config failed, ret = %d", __func__, ret); + return NULL; + } + tester.handle = I3cOpen(tester.config.busId); + if (tester.handle == NULL) { + HDF_LOGE("%s: Open I3C controller: %u failed!", __func__, tester.config.busId); + return NULL; + } + hasInit = true; + HDF_LOGD("%s: Done", __func__); + return &tester; +} + +static int32_t I3cTestMallocBuf(struct I3cTester *tester) +{ + struct I3cTestConfig *config = &tester->config; + + if (g_buf == NULL) { + g_buf = OsalMemCalloc(config->bufSize); + if (g_buf == NULL) { + HDF_LOGE("I3cTestMallocBuf: malloc buf fail!"); + return HDF_ERR_MALLOC_FAIL; + } + } + + g_regs[0] = (uint8_t)config->regAddr; + if (config->regLen > 1) { + g_regs[1] = g_regs[0]; + g_regs[0] = (uint8_t)(config->regAddr >> I3C_TEST_8BIT); + } + + g_msgs[0].addr = config->devAddr; + g_msgs[0].flags = 0; + g_msgs[0].len = config->regLen; + g_msgs[0].buf = g_regs; + + g_msgs[1].addr = config->devAddr; + g_msgs[1].flags = I3C_FLAG_READ; + g_msgs[1].len = config->bufSize; + g_msgs[1].buf = g_buf; + + return HDF_SUCCESS; +} + +int32_t I3cTestSetUpAll(void *param) +{ + struct I3cTester *tester = NULL; + struct I3cTestConfig *cfg = NULL; + + (void) param; + HDF_LOGD("I3cTestSetUpAll: enter!"); + tester = I3cTesterGet(); + if (tester == NULL) { + HDF_LOGE("I3cTestSetUpAll: get tester fail!"); + return HDF_ERR_INVALID_OBJECT; + } + tester->total = I3C_TEST_CMD_MAX; + tester->fails = 0; + + cfg = &tester->config; + HDF_LOGD("I3cTestSetUpAll: test on bus:0x%x, addr:0x%x, reg:0x%x, reglen:0x%x, size:0x%x", + cfg->busId, cfg->devAddr, cfg->regAddr, cfg->regLen, cfg->bufSize); + if (I3cTestMallocBuf(tester) != HDF_SUCCESS) { + HDF_LOGE("I3cTestSetUpAll: set up test case fail!"); + } + HDF_LOGD("I3cTestSetUpAll: exit!"); + *((int32_t *)param) = 1; + + return HDF_SUCCESS; +} + +int32_t I3cTestTearDownAll(void *param) +{ + if (g_buf != NULL) { + OsalMemFree(g_buf); + g_buf = NULL; + } + *((int32_t *)param) = 1; + + return HDF_SUCCESS; +} + +int32_t I3cTestSetUpSingle(void) +{ + return HDF_SUCCESS; +} + +int32_t I3cTestTearDownSingle(void) +{ + return HDF_SUCCESS; +} + +int32_t I3cTestTransfer(void *param) +{ + struct I3cTester *tester = NULL; + int32_t ret; + + tester = I3cTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: Get tester failed!", __func__); + *((int32_t *)param) = 1; + return HDF_ERR_INVALID_OBJECT; + } + /* transfer one write msg */ + ret = I3cTransfer(tester->handle, g_msgs, 1, I3C_MODE); + if (ret != 1) { + HDF_LOGE("%s: I3cTransfer(write) err: %d", __func__, ret); + *((int32_t *)param) = 1; + return HDF_FAILURE; + } + + /* transfer one read msg */ + ret = I3cTransfer(tester->handle, g_msgs + 1, 1, I3C_MODE); + if (ret != 1) { + HDF_LOGE("%s: I3cTransfer(read) err: %d", __func__, ret); + *((int32_t *)param) = 1; + return HDF_FAILURE; + } + + /* transfer two msgs including a read msg and a write msg */ + ret = I3cTransfer(tester->handle, g_msgs, I3C_TEST_MSG_NUM, I3C_MODE); + if (ret != I3C_TEST_MSG_NUM) { + HDF_LOGE("%s: I3cTransfer(mix) err: %d", __func__, ret); + *((int32_t *)param) = 1; + return HDF_FAILURE; + } + *((int32_t *)param) = 1; + HDF_LOGD("%s: Done", __func__); + return HDF_SUCCESS; +} + +int32_t I3cTestSetConfig(void *param) +{ + struct I3cTester *tester = NULL; + struct I3cConfig *config = NULL; + int32_t ret; + + tester = I3cTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: Get tester failed!", __func__); + *((int32_t *)param) = 1; + return HDF_ERR_INVALID_OBJECT; + } + + config = (struct I3cConfig*)OsalMemCalloc(sizeof(*config)); + if (config == NULL) { + HDF_LOGE("%s: MemCalloc failed!", __func__); + *((int32_t *)param) = 1; + return HDF_ERR_MALLOC_FAIL; + } + + config->busMode = I3C_BUS_HDR_MODE; + config->curMaster = NULL; + ret = I3cSetConfig(tester->handle, config); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Set config failed!, busId = %d", __func__, tester->config.busId); + OsalMemFree(config); + *((int32_t *)param) = 1; + return HDF_FAILURE; + } + OsalMemFree(config); + config = NULL; + HDF_LOGD("%s: Done", __func__); + *((int32_t *)param) = 1; + + return HDF_SUCCESS; +} + +int32_t I3cTestGetConfig(void *param) +{ + struct I3cTester *tester = NULL; + struct I3cConfig *config = NULL; + int32_t ret; + + tester = I3cTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: Get tester failed!", __func__); + *((int32_t *)param) = 1; + return HDF_ERR_INVALID_OBJECT; + } + + config = (struct I3cConfig*)OsalMemCalloc(sizeof(*config)); + if (config == NULL) { + HDF_LOGE("%s: MemCalloc failed!", __func__); + *((int32_t *)param) = 1; + return HDF_ERR_MALLOC_FAIL; + } + + ret = I3cGetConfig(tester->handle, config); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Get config failed!, busId = %d", __func__, tester->config.busId); + OsalMemFree(config); + *((int32_t *)param) = 1; + return HDF_FAILURE; + } + + OsalMemFree(config); + config = NULL; + *((int32_t *)param) = 1; + HDF_LOGD("%s: Done", __func__); + + return HDF_SUCCESS; +} + +static int32_t TestI3cIbiFunc(DevHandle handle, uint16_t addr, struct I3cIbiData data) +{ + (void)handle; + (void)addr; + HDF_LOGD("%s: %.16s", __func__, (char *)data.buf); + + return HDF_SUCCESS; +} + +int32_t I3cTestRequestIbi(void *param) +{ + struct I3cTester *tester = NULL; + int32_t ret; + + tester = I3cTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: Get tester failed!", __func__); + *((int32_t *)param) = 1; + return HDF_ERR_INVALID_OBJECT; + } + + ret = I3cRequestIbi(tester->handle, tester->config.devAddr, TestI3cIbiFunc, I3C_TEST_IBI_PAYLOAD); + if (ret != HDF_SUCCESS) { + *((int32_t *)param) = 1; + HDF_LOGE("%s: Requset IBI failed!, busId = %d", __func__, tester->config.busId); + return HDF_FAILURE; + } + *((int32_t *)param) = 1; + HDF_LOGD("%s: Done", __func__); + + return HDF_SUCCESS; +} + +int32_t I3cTestFreeIbi(void *param) +{ + struct I3cTester *tester = NULL; + int32_t ret; + + tester = I3cTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: Get tester failed!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + ret = I3cFreeIbi(tester->handle, tester->config.devAddr); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Free IBI failed!, busId = %d", __func__, tester->config.busId); + *((int32_t *)param) = 1; + return HDF_FAILURE; + } + *((int32_t *)param) = 1; + HDF_LOGD("%s: done", __func__); + + return HDF_SUCCESS; +} + +int32_t I3cTestThreadFunc(OsalThreadEntry func) +{ + int32_t ret; + uint32_t time; + struct OsalThread thread1, thread2; + struct OsalThreadParam cfg1, cfg2; + int32_t count1, count2; + + count1 = count2 = 0; + time = 0; + ret = OsalThreadCreate(&thread1, func, (void *)&count1); + if (ret != HDF_SUCCESS) { + HDF_LOGE("create test thread1 fail:%d", ret); + return HDF_FAILURE; + } + + ret = OsalThreadCreate(&thread2, func, (void *)&count2); + if (ret != HDF_SUCCESS) { + HDF_LOGE("create test thread1 fail:%d", ret); + return HDF_FAILURE; + } + + cfg1.name = "I3cTestThread-1"; + cfg2.name = "I3cTestThread-2"; + cfg1.priority = cfg2.priority = OSAL_THREAD_PRI_DEFAULT; + cfg1.stackSize = cfg2.stackSize = I3C_TEST_STACK_SIZE; + + ret = OsalThreadStart(&thread1, &cfg1); + if (ret != HDF_SUCCESS) { + HDF_LOGE("start test thread1 fail:%d", ret); + return HDF_FAILURE; + } + + ret = OsalThreadStart(&thread2, &cfg2); + if (ret != HDF_SUCCESS) { + HDF_LOGE("start test thread2 fail:%d", ret); + return HDF_FAILURE; + } + + while (count1 == 0 || count2 == 0) { + HDF_LOGE("waitting testing thread finish..."); + OsalMSleep(I3C_TEST_WAIT_TIMES); + time++; + if (time > I3C_TEST_WAIT_TIMEOUT) { + break; + } + } + + (void)OsalThreadDestroy(&thread1); + (void)OsalThreadDestroy(&thread2); + HDF_LOGD("%s: done", __func__); + + return HDF_SUCCESS; +} + +static struct I3cTestEntry g_multiThreadEntry[] = { + { I3C_TEST_CMD_TRANSFER, I3cTestTransfer, "I3cTestTransfer" }, + { I3C_TEST_CMD_SET_CONFIG, I3cTestSetConfig, "I3cTestSetConfig" }, + { I3C_TEST_CMD_GET_CONFIG, I3cTestGetConfig, "I3cTestGetConfig" }, + { I3C_TEST_CMD_REQUEST_IBI, I3cTestRequestIbi, "I3cTestRequestIbi" }, + { I3C_TEST_CMD_FREE_IBI, I3cTestFreeIbi, "I3cTestFreeIbi" }, +}; + +int32_t I3cTestMultiThread(void *param) +{ + uint32_t i; + int32_t ret; + + for (i = 0; i < sizeof(g_multiThreadEntry) / sizeof(g_multiThreadEntry[0]); i++) { + if (g_multiThreadEntry[i].func == NULL) { + HDF_LOGE("%s: func is NULL", __func__); + return HDF_FAILURE; + } + HDF_LOGI("%s: =================calling func %d =========================", __func__, i); + ret = I3cTestThreadFunc((OsalThreadEntry)g_multiThreadEntry[i].func); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Multithreading test failed: %u", __func__, i); + return ret; + } + } + *((int32_t *)param) = 1; + + return HDF_SUCCESS; +} + +int32_t I3cTestReliability(void *param) +{ + struct I3cTester *tester = NULL; + struct I3cConfig *config = NULL; + + tester = I3cTesterGet(); + if (tester == NULL || tester->handle == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + config = (struct I3cConfig *)OsalMemCalloc(sizeof(*config)); + if (config == NULL) { + HDF_LOGE("func:%s config is NULL!", __func__); + return HDF_ERR_MALLOC_FAIL; + } + config->busMode = I3C_BUS_HDR_MODE; + config->curMaster = NULL; + // invalid handle + (void)I3cTransfer(NULL, g_msgs, 1, I3C_MODE); + (void)I3cSetConfig(NULL, config); + (void)I3cGetConfig(NULL, config); + (void)I3cRequestIbi(NULL, tester->config.devAddr, TestI3cIbiFunc, I3C_TEST_IBI_PAYLOAD); + (void)I3cFreeIbi(NULL, tester->config.devAddr); + // Invalid msg + (void)I3cTransfer(tester->handle, NULL, 1, I3C_MODE); + // Invalid config + (void)I3cSetConfig(tester->handle, NULL); + (void)I3cGetConfig(tester->handle, NULL); + // Invalid function + (void)I3cRequestIbi(tester->handle, tester->config.devAddr, NULL, I3C_TEST_IBI_PAYLOAD); + // Invalid number + (void)I3cTransfer(tester->handle, g_msgs, -1, I3C_MODE); + (void)I3cRequestIbi(tester->handle, tester->config.devAddr, TestI3cIbiFunc, -1); + *((int32_t *)param) = 1; + HDF_LOGD("%s: Done", __func__); + + return HDF_SUCCESS; +} + +static struct I3cTestEntry g_entry[] = { + { I3C_TEST_CMD_TRANSFER, I3cTestTransfer, "I3cTestTransfer" }, + { I3C_TEST_CMD_SET_CONFIG, I3cTestSetConfig, "I3cTestSetConfig" }, + { I3C_TEST_CMD_GET_CONFIG, I3cTestGetConfig, "I3cTestGetConfig" }, + { I3C_TEST_CMD_REQUEST_IBI, I3cTestRequestIbi, "I3cTestRequestIbi" }, + { I3C_TEST_CMD_FREE_IBI, I3cTestFreeIbi, "I3cTestFreeIbi" }, + { I3C_TEST_CMD_MULTI_THREAD, I3cTestMultiThread, "I3cTestMultiThread" }, + { I3C_TEST_CMD_RELIABILITY, I3cTestReliability, "I3cTestReliability" }, + { I3C_TEST_CMD_SETUP_ALL, I3cTestSetUpAll, "I3cTestSetUpAll" }, + { I3C_TEST_CMD_TEARDOWN_ALL, I3cTestTearDownAll, "I3cTestTearDownAll" }, +}; + +int32_t I3cTestExecute(int cmd) +{ + uint32_t i; + int32_t count; + int32_t ret = HDF_ERR_NOT_SUPPORT; + + if (cmd > I3C_TEST_CMD_MAX) { + HDF_LOGE("%s: invalid cmd:%d", __func__, cmd); + ret = HDF_ERR_NOT_SUPPORT; + goto __EXIT__; + } + + for (i = 0; i < sizeof(g_entry) / sizeof(g_entry[0]); i++) { + if (g_entry[i].cmd != cmd || g_entry[i].func == NULL) { + continue; + } + count = 0; + ret = g_entry[i].func((void *)&count); + break; + } + +__EXIT__: + HDF_LOGI("[%s][======cmd:%d====ret:%d======]", __func__, cmd, ret); + return ret; +} \ No newline at end of file diff --git a/test/unittest/platform/common/i3c_test.h b/test/unittest/platform/common/i3c_test.h new file mode 100644 index 0000000000000000000000000000000000000000..7ef6c9e618489039b357e4c66fb27e5a81c3fc7d --- /dev/null +++ b/test/unittest/platform/common/i3c_test.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 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 I3C_TEST_H +#define I3C_TEST_H + +#include "i3c_if.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +struct I3cTestConfig { + uint16_t busId; + uint16_t devAddr; + uint16_t regAddr; + uint16_t regLen; + uint16_t bufSize; +}; + +struct I3cTester { + struct I3cTestConfig config; + DevHandle handle; + uint16_t total; + uint16_t fails; +}; + +enum I3cTestCmd { + I3C_TEST_CMD_TRANSFER = 0, + I3C_TEST_CMD_SET_CONFIG, + I3C_TEST_CMD_GET_CONFIG, + I3C_TEST_CMD_REQUEST_IBI, + I3C_TEST_CMD_FREE_IBI, + I3C_TEST_CMD_MULTI_THREAD, + I3C_TEST_CMD_RELIABILITY, + I3C_TEST_CMD_SETUP_ALL, + I3C_TEST_CMD_TEARDOWN_ALL, + I3C_TEST_CMD_SETUP_SINGLE, + I3C_TEST_CMD_TEARDOWN_SINGLE, + I3C_TEST_CMD_MAX, +}; + +int32_t I3cTestExecute(int cmd); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* I3C_TEST_H */ diff --git a/test/unittest/platform/common/mipi_csi_test.c b/test/unittest/platform/common/mipi_csi_test.c new file mode 100755 index 0000000000000000000000000000000000000000..cb028a06df99dd7aa0d8734803728adbf109388c --- /dev/null +++ b/test/unittest/platform/common/mipi_csi_test.c @@ -0,0 +1,547 @@ +/* + * Copyright (c) 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 "mipi_csi_test.h" +#include "hdf_log.h" +#include "osal_time.h" +#include "securec.h" + +#define HDF_LOG_TAG mipi_csi_test +#define SEQ_OUTPUT_DELAY 100 /* Delay time of sequential output, unit: ms */ + +// Input interface type of RX. +enum InterfaceType { + INTERFACE_MIPI = 0, + INTERFACE_LVDS, + INTERFACE_CMOS, + INTERFACE_BUTT +}; + +static int32_t MipiCsiTestSetUp(struct MipiCsiTest *test) +{ + HDF_LOGI("%s: enter!", __func__); + + if (test == NULL) { + HDF_LOGE("%s: test is NULL.", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (test->handle == NULL) { + HDF_LOGE("%s: enter! cntlrId:0x%x", __func__, test->cntlrId); + test->cntlrId = 0; + test->handle = MipiCsiOpen(test->cntlrId); + if (test->handle == NULL) { + HDF_LOGE("%s: failed.", __func__); + return HDF_FAILURE; + } + } + + test->fails = 0; + HDF_LOGD("%s: cntlrId:0x%x", __func__, test->cntlrId); + return HDF_SUCCESS; +} + +static void MipiCsiTestTearDown(struct MipiCsiTest *test) +{ + if (test == NULL) { + return; + } + if (test->handle != NULL) { + MipiCsiClose(test->handle); + test->handle = NULL; + } +} + +/** + * @brief Initialize the device parameters applying LVDS protocol. + * + * This is not fully tested! + * + * @since 1.0 + */ +static void InitLvdsDevAttr(LvdsDevAttr *lvdsAttr) +{ + int i; + int j; + int k; + LvdsDevAttr attr; + + if (lvdsAttr == NULL) { + return; + } + + (void)memset_s(&attr, sizeof(LvdsDevAttr), 0, sizeof(LvdsDevAttr)); + // Hi3516CV500 (DATA_TYPE_RAW_12BIT), Hi3516EV200 (DATA_TYPE_RAW_12BIT) + attr.inputDataType = DATA_TYPE_RAW_12BIT; + attr.wdrMode = HI_WDR_MODE_NONE; + // LVDS synchronization mode. LVDS_SYNC_MODE_SOF, LVDS_SYNC_MODE_SAV + attr.syncMode = LVDS_SYNC_MODE_SOF; + // LVDS Vsync type. LVDS_VSYNC_NORMAL, LVDS_VSYNC_SHARE, LVDS_VSYNC_HCONNECT + attr.vsyncAttr.syncType = LVDS_VSYNC_NORMAL; + // hconnect vsync blanking len, valid when the syncType is LVDS_VSYNC_HCONNECT + // This is not fully tested! + if (attr.vsyncAttr.syncType == LVDS_VSYNC_HCONNECT) { + attr.vsyncAttr.hblank1 = 0; + attr.vsyncAttr.hblank2 = 0; + } + // frame identification code: LVDS_FID_NONE, LVDS_FID_IN_SAV, LVDS_FID_IN_DATA + attr.fidAttr.fidType = LVDS_FID_NONE; + // Sony DOL has the Frame Information Line, in DOL H-Connection mode, should + // configure this flag as false to disable output the Frame Information Line. + // This is not fully tested! + attr.fidAttr.outputFil = 'm'; + // LVDS bit size end mode: LVDS_ENDIAN_LITTLE, LVDS_ENDIAN_BIG + attr.dataEndian = LVDS_ENDIAN_LITTLE; + // sync code endian: little/big, LVDS_ENDIAN_LITTLE, LVDS_ENDIAN_BIG + attr.syncCodeEndian = LVDS_ENDIAN_LITTLE; + // laneId: -1 - disable + attr.laneId[0] = 0; /* 0 -- laneId 0 */ + attr.laneId[1] = 1; /* 1 -- laneId 1 */ + attr.laneId[2] = 2; /* 2 -- laneId 2 */ + attr.laneId[3] = 3; /* 3 -- laneId 3 */ + + /** each vc has 4 params, syncCode[i]: + syncMode is SYNC_MODE_SOF: SOF, EOF, SOL, EOL + syncMode is SYNC_MODE_SAV: invalid sav, invalid eav, valid sav, valid eav */ + // This is not fully tested! + for (i = 0; i < LVDS_LANE_NUM; i++) { + for (j = 0; j < WDR_VC_NUM; j++) { + for (k = 0; k < SYNC_CODE_NUM; k++) { + attr.syncCode[i][j][k] = 0; /* 0 -- frame0 sof */ + } + } + } + + *lvdsAttr = attr; +} + +/** + * @brief Initialize MIPI device attributes. + * + * Data type (DT: data type) + * The data type describes the format and content of load data. Up to 64 data types are supported. + * There are only two data types for short packets, and the others belong to long packets. + * + * @Data type describe + * 0x00 – 0x07 Synchronous short packet data type + * 0x08 – 0x0F General short packet data type + * 0x10 – 0x17 General long packet data type + * 0x18 – 0x1F YUV data + * 0x20 – 0x27 RGB data + * 0x28 – 0x2F Raw data + * 0x30 – 0x37 User defined byte based data type + * 0x38 – 0x3F Reserved + * + * @since 1.0 + */ +static void InitMipiDevAttr(MipiDevAttr *mipiAttr) +{ + MipiDevAttr attr; + if (mipiAttr == NULL) { + return; + } + + HDF_LOGI("%s: enter.", __func__); + (void)memset_s(&attr, sizeof(MipiDevAttr), 0, sizeof(MipiDevAttr)); + // Hi3516CV500 (DATA_TYPE_RAW_12BIT), Hi3516EV200 (DATA_TYPE_RAW_12BIT) + attr.inputDataType = DATA_TYPE_RAW_12BIT; + // Hi3516CV500 (HI_MIPI_WDR_MODE_NONE), Hi3516EV200 (HI_MIPI_WDR_MODE_NONE) + attr.wdrMode = HI_MIPI_WDR_MODE_NONE; + // laneId: -1 - disable + // Hi3516CV500 (0, 1, 2, 3), Hi3516EV200 (0, 1, -1, -1) + attr.laneId[0] = 0; /* 0 -- laneId 0 */ + attr.laneId[1] = 1; /* 1 -- laneId 1 */ + attr.laneId[2] = 2; /* 2 -- laneId 2 */ + attr.laneId[3] = 3; /* 3 -- laneId 3 */ + + // Used by the HI_MIPI_WDR_MODE_DT, This is not fully tested! + if (attr.wdrMode == HI_MIPI_WDR_MODE_DT) { + attr.dataType[0] = 0x39; /* 0x39 -- data type reserved */ + attr.dataType[1] = 0x39; /* 0x39 -- data type reserved */ + attr.dataType[2] = 0x39; /* 0x39 -- data type reserved */ + attr.dataType[3] = 0x39; /* 0x39 -- data type reserved */ + } + + *mipiAttr = attr; +} + +static int MipiGetIntputModeType(InputMode inputMode) +{ + switch (inputMode) { + case INPUT_MODE_SUBLVDS: + case INPUT_MODE_LVDS: + case INPUT_MODE_HISPI: + return INTERFACE_LVDS; + case INPUT_MODE_MIPI: + return INTERFACE_MIPI; + case INPUT_MODE_CMOS: + case INPUT_MODE_BT1120: + case INPUT_MODE_BT656: + case INPUT_MODE_BYPASS: + return INTERFACE_CMOS; + default: + break; + } + + return INTERFACE_BUTT; +} + +static void InitComboDevAttr(struct MipiCsiTest *test) +{ + enum InterfaceType interType; + ComboDevAttr attr; + + (void)memset_s(&attr, sizeof(ComboDevAttr), 0, sizeof(ComboDevAttr)); + // Hi3516CV500(0), Hi3516EV200(0) + attr.devno = 0; + // Hi3516CV500(INPUT_MODE_MIPI), Hi3516EV200(INPUT_MODE_MIPI) + attr.inputMode = INPUT_MODE_MIPI; + // Hi3516CV500(MIPI_DATA_RATE_X1), Hi3516EV200(MIPI_DATA_RATE_X1) + attr.dataRate = MIPI_DATA_RATE_X1; + // Hi3516CV500 (0, 204, 2592, 1944), Hi3516EV200 (0, 204, 2304, 1296), Hi3516DV300-imx335 (0, 0, 2592, 1944) + attr.imgRect.x = 0; /* 0: image sensor left-top positon */ + attr.imgRect.y = 0; /* 0: image sensor right-top position */ + attr.imgRect.width = 2592; /* 2592: image sensor width size */ + attr.imgRect.height = 1944; /* 1944: image sensor height size */ + + interType = MipiGetIntputModeType(attr.inputMode); + if (interType == INTERFACE_MIPI) { + HDF_LOGI("%s: call[InitMipiDevAttr].", __func__); + InitMipiDevAttr(&attr.mipiAttr); + } else if (interType == INTERFACE_LVDS) { + HDF_LOGI("%s: call[InitLvdsDevAttr].", __func__); + InitLvdsDevAttr(&attr.lvdsAttr); + } else { + HDF_LOGE("%s: interType = %d is error!", __func__, attr.inputMode); + } + + test->attr = attr; +} + +static int32_t MipiCsiSetComboDevAttrTest(struct MipiCsiTest *test) +{ + int32_t ret; + + InitComboDevAttr(test); + ret = MipiCsiSetComboDevAttr(test->handle, &(test->attr)); + if ((ret == HDF_SUCCESS) || (ret == HDF_ERR_NOT_SUPPORT)) { + return HDF_SUCCESS; + } + + HDF_LOGE("%s: failed.", __func__); + return ret; +} + +static int32_t MipiCsiSetPhyCmvmodeTest(struct MipiCsiTest *test) +{ + int32_t ret; + + test->devno = 0; + // PHY_CMV_GE1200MV or PHY_CMV_LT1200MV + test->cmvMode = PHY_CMV_GE1200MV; + ret = MipiCsiSetPhyCmvmode(test->handle, test->devno, test->cmvMode); + if ((ret == HDF_SUCCESS) || (ret == HDF_ERR_NOT_SUPPORT)) { + return HDF_SUCCESS; + } + HDF_LOGE("%s: failed.", __func__); + + return ret; +} + +static int32_t MipiCsiResetSensorTest(struct MipiCsiTest *test) +{ + int32_t ret; + + // snsResetSource select 0 or 1, and must be less than SNS_MAX_RST_SOURCE_NUM + test->snsResetSource = 0; + ret = MipiCsiResetSensor(test->handle, test->snsResetSource); + if ((ret == HDF_SUCCESS) || (ret == HDF_ERR_NOT_SUPPORT)) { + return HDF_SUCCESS; + } + HDF_LOGE("%s: failed.", __func__); + + return ret; +} + +static int32_t MipiCsiUnresetSensorTest(struct MipiCsiTest *test) +{ + int32_t ret; + + // snsResetSource select 0 or 1, and must be less than SNS_MAX_RST_SOURCE_NUM + test->snsResetSource = 0; + ret = MipiCsiUnresetSensor(test->handle, test->snsResetSource); + if ((ret == HDF_SUCCESS) || (ret == HDF_ERR_NOT_SUPPORT)) { + return HDF_SUCCESS; + } + HDF_LOGE("%s: failed.", __func__); + + return ret; +} + +static int32_t MipiCsiResetRxTest(struct MipiCsiTest *test) +{ + int32_t ret; + + // comboDev select 0 or 1, and must be less than MIPI_RX_MAX_DEV_NUM + test->comboDev = 0; + ret = MipiCsiResetRx(test->handle, test->comboDev); + if ((ret == HDF_SUCCESS) || (ret == HDF_ERR_NOT_SUPPORT)) { + return HDF_SUCCESS; + } + HDF_LOGE("%s: failed.", __func__); + + return ret; +} + +static int32_t MipiCsiUnresetRxTest(struct MipiCsiTest *test) +{ + int32_t ret; + + // comboDev select 0 or 1, and must be less than MIPI_RX_MAX_DEV_NUM + test->comboDev = 0; + ret = MipiCsiUnresetRx(test->handle, test->comboDev); + if ((ret == HDF_SUCCESS) || (ret == HDF_ERR_NOT_SUPPORT)) { + return HDF_SUCCESS; + } + HDF_LOGE("%s: failed.", __func__); + + return ret; +} + +static int32_t MipiCsiSetHsModeTest(struct MipiCsiTest *test) +{ + int32_t ret; + + // laneDivideMode: Hi3516CV500(LANE_DIVIDE_MODE_0), Hi3516EV200(LANE_DIVIDE_MODE_0) + test->laneDivideMode = LANE_DIVIDE_MODE_0; + ret = MipiCsiSetHsMode(test->handle, test->laneDivideMode); + if ((ret == HDF_SUCCESS) || (ret == HDF_ERR_NOT_SUPPORT)) { + return HDF_SUCCESS; + } + HDF_LOGE("%s: failed.", __func__); + + return ret; +} + +static int32_t MipiCsiEnableMipiClockTest(struct MipiCsiTest *test) +{ + int32_t ret; + + // comboDev select 0 or 1, and must be less than MIPI_RX_MAX_DEV_NUM + test->comboDev = 0; + ret = MipiCsiEnableClock(test->handle, test->comboDev); + if ((ret == HDF_SUCCESS) || (ret == HDF_ERR_NOT_SUPPORT)) { + return HDF_SUCCESS; + } + HDF_LOGE("%s: failed.", __func__); + + return ret; +} + +static int32_t MipiCsiDisableMipiClockTest(struct MipiCsiTest *test) +{ + int32_t ret; + + // comboDev select 0 or 1, and must be less than MIPI_RX_MAX_DEV_NUM + test->comboDev = 0; + ret = MipiCsiDisableClock(test->handle, test->comboDev); + if ((ret == HDF_SUCCESS) || (ret == HDF_ERR_NOT_SUPPORT)) { + return HDF_SUCCESS; + } + HDF_LOGE("%s: failed.", __func__); + + return ret; +} + +static int32_t MipiCsiEnableSensorClockTest(struct MipiCsiTest *test) +{ + int32_t ret; + + // snsClkSource select 0 or 1, and must be less than SNS_MAX_CLK_SOURCE_NUM + test->snsClkSource = 0; + ret = MipiCsiEnableSensorClock(test->handle, test->snsClkSource); + if ((ret == HDF_SUCCESS) || (ret == HDF_ERR_NOT_SUPPORT)) { + return HDF_SUCCESS; + } + HDF_LOGE("%s: failed.", __func__); + + return ret; +} + +static int32_t MipiCsiDisableSensorClockTest(struct MipiCsiTest *test) +{ + int32_t ret; + + // snsClkSource select 0 or 1, and must be less than SNS_MAX_CLK_SOURCE_NUM + test->snsClkSource = 0; + ret = MipiCsiDisableSensorClock(test->handle, test->snsClkSource); + if ((ret == HDF_SUCCESS) || (ret == HDF_ERR_NOT_SUPPORT)) { + return HDF_SUCCESS; + } + HDF_LOGE("%s: failed.", __func__); + + return ret; +} + +static int32_t MipiCsiSetExtDataTypeTest(struct MipiCsiTest *test) +{ + int32_t ret; + ExtDataType dataType; + dataType.devno = 0; + dataType.num = 0; + + // extDataBitWidth set 8, 10, 12, 14 or 16. + dataType.extDataBitWidth[0] = 12; /* 12:magic bit width */ + dataType.extDataBitWidth[1] = 12; /* 12:magic bit width */ + dataType.extDataBitWidth[2] = 12; /* 12:magic bit width */ + + dataType.extDataType[0] = 0x39; /* 0x39 -- data type reserved */ + dataType.extDataType[1] = 0x39; /* 0x39 -- data type reserved */ + dataType.extDataType[2] = 0x39; /* 0x39 -- data type reserved */ + test->dataType = dataType; + + ret = MipiCsiSetExtDataType(test->handle, &test->dataType); + if ((ret == HDF_SUCCESS) || (ret == HDF_ERR_NOT_SUPPORT)) { + return HDF_SUCCESS; + } + HDF_LOGE("%s: failed.", __func__); + + return ret; +} + +static int32_t MipiCsiTestByCmd(struct MipiCsiTest *test, uint8_t cmd) +{ + int32_t ret = HDF_FAILURE; + + if (test == NULL) { + HDF_LOGE("%s: test is NULL", __func__); + return ret; + } + + HDF_LOGI("%s: test cmd %u, enter.", __func__, cmd); + switch (cmd) { + case MIPI_CSI_TEST_SET_HS_MODE: + ret = MipiCsiSetHsModeTest(test); + break; + case MIPI_CSI_TEST_DISABLE_MIPI_CLOCK: + ret = MipiCsiDisableMipiClockTest(test); + break; + case MIPI_CSI_TEST_ENABLE_MIPI_CLOCK: + ret = MipiCsiEnableMipiClockTest(test); + break; + case MIPI_CSI_TEST_RESET_RX: + ret = MipiCsiResetRxTest(test); + break; + case MIPI_CSI_TEST_DISABLE_SENSOR_CLOCK: + ret = MipiCsiDisableSensorClockTest(test); + break; + case MIPI_CSI_TEST_ENABLE_SENSOR_CLOCK: + ret = MipiCsiEnableSensorClockTest(test); + break; + case MIPI_CSI_TEST_RESET_SENSOR: + ret = MipiCsiResetSensorTest(test); + break; + case MIPI_CSI_TEST_SET_DEV_ATTR: + ret = MipiCsiSetComboDevAttrTest(test); + break; + case MIPI_CSI_TEST_SET_PHY_CMVMODE: + ret = MipiCsiSetPhyCmvmodeTest(test); + break; + case MIPI_CSI_TEST_SET_EXT_DATA_TYPE: + ret = MipiCsiSetExtDataTypeTest(test); + break; + case MIPI_CSI_TEST_UNRESET_RX: + ret = MipiCsiUnresetRxTest(test); + break; + case MIPI_CSI_TEST_UNRESET_SENSOR: + ret = MipiCsiUnresetSensorTest(test); + break; + default: + HDF_LOGE("%s: not support", __func__); + break; + } + HDF_LOGI("%s: test cmd %u, ret %d done.", __func__, cmd, ret); + + return ret; +} + +static int32_t MipiCsiTestDoTest(struct MipiCsiTest *test, uint8_t cmd) +{ + int32_t ret; + OsalMSleep(SEQ_OUTPUT_DELAY); + + if (test == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + +#ifdef MIPI_CSI_TEST_SELF + int32_t i; + if (cmd != 0) { + return HDF_SUCCESS; + } + ret = MipiCsiTestSetUp(test); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: setup fail!", __func__); + return ret; + } + + for (i = 0; i < test->total; i++) { + if (MipiCsiTestByCmd(test, i) != HDF_SUCCESS) { + test->fails++; + } + } + HDF_LOGI("\n\n%s: **********PASS:%u FAIL:%u**************\n\n", + __func__, test->total - test->fails, test->fails); + ret = (test->fails > 0) ? HDF_FAILURE : HDF_SUCCESS; + MipiCsiTestTearDown(test); +#else + if (cmd == 0) { + ret = MipiCsiTestSetUp(test); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: [MipiCsiTestSetUp] failed!", __func__); + return ret; + } + } + ret = MipiCsiTestByCmd(test, cmd); + if (cmd == (test->total - 1)) { + MipiCsiTestTearDown(test); + } +#endif + OsalMSleep(SEQ_OUTPUT_DELAY); + + return ret; +} + +static int32_t MipiCsiTestBind(struct HdfDeviceObject *device) +{ + static struct MipiCsiTest test; + + test.cntlrId = 0; + test.total = MIPI_CSI_TEST_MAX; + test.doTest = MipiCsiTestDoTest; + device->service = &test.service; +#ifdef MIPI_CSI_TEST_SELF + HDF_LOGI("%s: test on init!", __func__); + test.doTest(&test, -1); +#endif + return HDF_SUCCESS; +} + +static int32_t MipiCsiTestInit(struct HdfDeviceObject *device) +{ + (void)device; + return HDF_SUCCESS; +} + +struct HdfDriverEntry g_mipiCsiTestEntry = { + .moduleVersion = 1, + .Bind = MipiCsiTestBind, + .Init = MipiCsiTestInit, + .moduleName = "PLATFORM_MIPI_CSI_TEST", +}; +HDF_INIT(g_mipiCsiTestEntry); diff --git a/test/unittest/platform/common/mipi_csi_test.h b/test/unittest/platform/common/mipi_csi_test.h new file mode 100755 index 0000000000000000000000000000000000000000..81324f2c4b287e31dcb6d14a3d238429a1cd8649 --- /dev/null +++ b/test/unittest/platform/common/mipi_csi_test.h @@ -0,0 +1,62 @@ +/* + * Copyright (c) 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 MIPI_CSI_TEST_H +#define MIPI_CSI_TEST_H + +#include "hdf_device_desc.h" +#include "mipi_csi_if.h" + +/** + * @brief Pal mipi csi test case number. + * + * The sequence number is related to the test logic, which is different from the actual call. + * 1, 4, 8 and 9 need to be called according to the actual situation. + * + * @since 1.0 + */ +enum MipiCsiTestCmd { + MIPI_CSI_TEST_SET_HS_MODE = 0, + MIPI_CSI_TEST_DISABLE_MIPI_CLOCK = 1, /* for test */ + MIPI_CSI_TEST_ENABLE_MIPI_CLOCK = 2, + MIPI_CSI_TEST_RESET_RX = 3, + MIPI_CSI_TEST_DISABLE_SENSOR_CLOCK = 4, /* for test */ + MIPI_CSI_TEST_ENABLE_SENSOR_CLOCK = 5, + MIPI_CSI_TEST_RESET_SENSOR = 6, + MIPI_CSI_TEST_SET_DEV_ATTR = 7, + MIPI_CSI_TEST_SET_PHY_CMVMODE = 8, /* for test */ + MIPI_CSI_TEST_SET_EXT_DATA_TYPE = 9, /* for test */ + MIPI_CSI_TEST_UNRESET_RX = 10, + MIPI_CSI_TEST_UNRESET_SENSOR = 11, + MIPI_CSI_TEST_MAX = 12, +}; + +struct MipiCsiTest { + struct IDeviceIoService service; + struct HdfDeviceObject *device; + int32_t (*doTest)(struct MipiCsiTest *test, uint8_t cmd); + DevHandle handle; + uint32_t total; + uint32_t fails; + + uint8_t cntlrId; + ComboDevAttr attr; + uint8_t devno; + PhyCmvMode cmvMode; + ExtDataType dataType; + LaneDivideMode laneDivideMode; + uint8_t comboDev; + uint8_t snsClkSource; + uint8_t snsResetSource; +}; + +static inline struct MipiCsiTest *MipiCsiTestServiceGet(void) +{ + return (struct MipiCsiTest *)DevSvcManagerClntGetService("PLATFORM_MIPI_CSI_TEST"); +} +#endif /* MIPI_CSI_TEST_H */ diff --git a/test/unittest/platform/common/mipi_dsi_test.c b/test/unittest/platform/common/mipi_dsi_test.c index b991e1e415c21deae9a1cdafd182881a871e8ad9..21319289dee9dd34988f0f6addbc33e760225ba6 100644 --- a/test/unittest/platform/common/mipi_dsi_test.c +++ b/test/unittest/platform/common/mipi_dsi_test.c @@ -6,12 +6,8 @@ * See the LICENSE file in the root of this repository for complete details. */ -#include "osal_mem.h" -#include "device_resource_if.h" -#include "hdf_base.h" -#include "hdf_device_desc.h" -#include "hdf_log.h" #include "mipi_dsi_test.h" +#include "hdf_log.h" #define HDF_LOG_TAG mipi_dsi_test diff --git a/test/unittest/platform/common/pin_driver_test.c b/test/unittest/platform/common/pin_driver_test.c new file mode 100644 index 0000000000000000000000000000000000000000..9f99572ef65cc30c84f3c10f5ab0a52de2e83d02 --- /dev/null +++ b/test/unittest/platform/common/pin_driver_test.c @@ -0,0 +1,116 @@ +/* + * Copyright (c) 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 "pin_test.h" +#include "device_resource_if.h" +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "hdf_log.h" +#include "string.h" + +#define HDF_LOG_TAG pin_driver_test_c + +static struct PinTestConfig g_config; + +static int32_t PinTestDispatch(struct HdfDeviceIoClient *client, int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + if (cmd == 0) { + if (reply == NULL) { + HDF_LOGE("%s: reply is null!", __func__); + return HDF_ERR_INVALID_PARAM; + } + if (!HdfSbufWriteBuffer(reply, &g_config, sizeof(g_config))) { + HDF_LOGE("%s: write reply failed", __func__); + return HDF_ERR_IO; + } + } else { + return HDF_ERR_NOT_SUPPORT; + } + + return HDF_SUCCESS; +} +static int32_t PinTestReadConfig(struct PinTestConfig *config, const struct DeviceResourceNode *node) +{ + int32_t ret; + const char *funcName = NULL; + struct DeviceResourceIface *drsOps = NULL; + + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetUint32 == NULL || drsOps->GetString == NULL) { + HDF_LOGE("%s: invalid drs ops", __func__); + return HDF_FAILURE; + } + ret = drsOps->GetString(node, "pinName", &config->pinName, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read pinName failed", __func__); + return ret; + } + + ret = drsOps->GetUint32(node, "strengthNum", &config->strengthNum, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read StrengthNum failed", __func__); + return ret; + } + + ret = drsOps->GetUint32(node, "PullTypeNum", &config->PullTypeNum, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read PullTypeNum failed", __func__); + return ret; + } + + ret = drsOps->GetString(node, "funcName", &funcName, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read funcName failed", __func__); + return ret; + } + stpcpy(config->funcNameBuf, funcName); + return HDF_SUCCESS; +} + +static int32_t PinTestBind(struct HdfDeviceObject *device) +{ + int32_t ret; + static struct IDeviceIoService service; + + if (device == NULL || device->property == NULL) { + HDF_LOGE("%s: device or config is null!", __func__); + return HDF_ERR_IO; + } + ret = PinTestReadConfig(&g_config, device->property); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read config failed", __func__); + return ret; + } + service.Dispatch = PinTestDispatch; + device->service = &service; + return HDF_SUCCESS; +} + +static int32_t PinTestInit(struct HdfDeviceObject *device) +{ + (void)device; + return HDF_SUCCESS; +} + +static void PinTestRelease(struct HdfDeviceObject *device) +{ + if (device != NULL) { + device->service = NULL; + } + HDF_LOGI("%s: Done!", __func__); + return; +} + +struct HdfDriverEntry g_pinTestEntry = { + .moduleVersion = 1, + .Bind = PinTestBind, + .Init = PinTestInit, + .Release = PinTestRelease, + .moduleName = "PLATFORM_PIN_TEST", +}; +HDF_INIT(g_pinTestEntry); \ No newline at end of file diff --git a/test/unittest/platform/common/pin_test.c b/test/unittest/platform/common/pin_test.c new file mode 100644 index 0000000000000000000000000000000000000000..2d3a6b30548b7938b6448d629957397d638bad1e --- /dev/null +++ b/test/unittest/platform/common/pin_test.c @@ -0,0 +1,380 @@ +/* + * Copyright (c) 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 "pin_test.h" +#include "hdf_base.h" +#include "hdf_io_service_if.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "osal_time.h" +#include "pin_if.h" +#include "securec.h" + +#define HDF_LOG_TAG pin_test_c + +#define PIN_FUNC_NAME_LENGTH 30 + +struct PinCfgs { + enum PinPullType pullTypeNum; + uint32_t strengthNum; + const char *funcName; +} g_oldPinCfg; + +struct PinTestEntry { + int cmd; + int32_t (*func)(void); + const char *name; +}; + +static int32_t PinTestGetTestConfig(struct PinTestConfig *config) +{ + int32_t ret; + struct HdfSBuf *reply = NULL; + struct HdfIoService *service = NULL; + const void *buf = NULL; + uint32_t len; + + HDF_LOGD("%s: enter", __func__); + service = HdfIoServiceBind("PIN_TEST"); + if (service == NULL) { + return HDF_ERR_NOT_SUPPORT; + } + + reply = HdfSBufObtain(sizeof(*config) + sizeof(uint64_t)); + if (reply == NULL) { + HDF_LOGE("%s: Failed to obtain reply", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + ret = service->dispatcher->Dispatch(&service->object, 0, NULL, reply); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Remote dispatch failed", __func__); + return ret; + } + + if (!HdfSbufReadBuffer(reply, &buf, &len)) { + HDF_LOGE("%s: Read buf failed", __func__); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + + if (len != sizeof(*config)) { + HDF_LOGE("%s: Config size:%zu, read size:%u", __func__, sizeof(*config), len); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + + if (memcpy_s(config, sizeof(*config), buf, sizeof(*config)) != EOK) { + HDF_LOGE("%s: Memcpy buf failed", __func__); + HdfSBufRecycle(reply); + return HDF_ERR_IO; + } + HdfSBufRecycle(reply); + HDF_LOGD("%s: Done", __func__); + return HDF_SUCCESS; +} + +struct PinTester *PinTesterGet(void) +{ + int32_t ret; + static struct PinTester tester; + static bool hasInit = false; + + if (hasInit) { + return &tester; + } + HDF_LOGI("%s: enter", __func__); + if (hasInit) { + return &tester; + } + ret = PinTestGetTestConfig(&tester.config); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read config failed:%d", __func__, ret); + return NULL; + } + tester.handle = PinGet(tester.config.pinName); + if (tester.handle == NULL) { + HDF_LOGE("%s: open pin:%s failed", __func__, tester.config.pinName); + return NULL; + } + hasInit = true; + HDF_LOGD("%s: Done", __func__); + return &tester; +} + +static int32_t PinSetGetPullTest(void) +{ + struct PinTester *tester = NULL; + int32_t ret; + enum PinPullType getPullTypeNum; + + getPullTypeNum = 0; + tester = PinTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: Get tester failed!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + ret = PinSetPull(tester->handle, tester->config.PullTypeNum); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Pin set pull failed!, pinName:%s", __func__, tester->config.pinName); + return HDF_FAILURE; + } + HDF_LOGI("%s: Pin set pull success!, PullTypeNum:%d", __func__, tester->config.PullTypeNum); + ret = PinGetPull(tester->handle, &getPullTypeNum); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Pin get pull failed!, pinName:%s", __func__, tester->config.pinName); + return HDF_FAILURE; + } + if (tester->config.PullTypeNum != getPullTypeNum) { + HDF_LOGE("%s: Pin set pull:%d, but Pin get pull:%u", __func__, tester->config.PullTypeNum, getPullTypeNum); + } + HDF_LOGD("%s: done", __func__); + return HDF_SUCCESS; +} + +static int32_t PinSetGetStrengthTest(void) +{ + struct PinTester *tester = NULL; + int32_t ret; + uint32_t getStrengthNum; + + getStrengthNum = 0; + tester = PinTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: Get tester failed!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + ret = PinSetStrength(tester->handle, tester->config.strengthNum); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Pin set strength failed!, pinName:%s", __func__, tester->config.pinName); + return HDF_FAILURE; + } + HDF_LOGI("%s: Pin set strength success!,strengthNum:%d", __func__, tester->config.strengthNum); + ret = PinGetStrength(tester->handle, &getStrengthNum); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Pin get pull failed!, pinName:%s", __func__, tester->config.pinName); + return HDF_FAILURE; + } + if (tester->config.strengthNum != getStrengthNum) { + HDF_LOGE("%s: Pin set strength:%d, but Pin get strength:%d", __func__, + tester->config.strengthNum, getStrengthNum); + } + HDF_LOGD("%s: done", __func__); + return HDF_SUCCESS; +} + +static int32_t PinSetGetFuncTest(void) +{ + struct PinTester *tester = NULL; + int32_t ret; + + tester = PinTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: Get tester failed!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + ret = PinSetFunc(tester->handle, (const char *)tester->config.funcNameBuf); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Pin set function failed!, pinName:%s, functionName:%s", __func__, + tester->config.pinName, tester->config.funcNameBuf); + return HDF_FAILURE; + } + HDF_LOGI("%s: Pin set function success!, pinName:%s, functionName:%s", __func__, + tester->config.pinName, tester->config.funcNameBuf); + ret = PinGetFunc(tester->handle, &tester->config.funcName); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Pin get function failed!, pinName:%s, functionName:%s", __func__, + tester->config.pinName, tester->config.funcName); + return HDF_FAILURE; + } + HDF_LOGI("%s: Pin get function success!, pinName:%s, functionName:%s", __func__, + tester->config.pinName, tester->config.funcName); + if (strcmp((const char *)tester->config.funcNameBuf, tester->config.funcName) != 0) { + HDF_LOGE("%s: Pin set function:%s, but Pin get function:%s", __func__, + tester->config.funcNameBuf, tester->config.funcName); + } + HDF_LOGD("%s: done", __func__); + return HDF_SUCCESS; +} + +int32_t PinTestSetUpAll(void) +{ + int32_t ret; + struct PinTester *tester = NULL; + struct PinTestConfig *cfg = NULL; + + HDF_LOGD("%s: enter!", __func__); + tester = PinTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: get tester fail!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + tester->total = PIN_TEST_CMD_MAX; + tester->fails = 0; + + cfg = &tester->config; + HDF_LOGD("%s: test on pinName:%s, PullTypeNum:%d, strengthNum:%d", __func__, + cfg->pinName, cfg->PullTypeNum, cfg->strengthNum); + ret = PinGetPull(tester->handle, &g_oldPinCfg.pullTypeNum); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: get pullTypeNum failed!", __func__); + return ret; + } + ret = PinGetStrength(tester->handle, &g_oldPinCfg.strengthNum); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: get strengthNum failed!", __func__); + return ret; + } + g_oldPinCfg.funcName = (char *)OsalMemCalloc(PIN_FUNC_NAME_LENGTH * sizeof(char)); + if (g_oldPinCfg.funcName == NULL) { + HDF_LOGE("%s: alloc g_oldPinCfg.funcName failed", __func__); + return HDF_ERR_MALLOC_FAIL; + } + tester->config.funcName = (char *)OsalMemCalloc(PIN_FUNC_NAME_LENGTH * sizeof(char)); + if (tester->config.funcName == NULL) { + HDF_LOGE("%s: alloc tester->config.funcName failed", __func__); + return HDF_ERR_MALLOC_FAIL; + } + ret = PinGetFunc(tester->handle, &g_oldPinCfg.funcName); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: get funcName failed!", __func__); + return ret; + } + HDF_LOGI(":%s old funcName:%s", __func__, g_oldPinCfg.funcName); + HDF_LOGD("%s: exit!", __func__); + + return HDF_SUCCESS; +} + +int32_t PinTestTearDownAll(void) +{ + int32_t ret; + struct PinTester *tester = NULL; + + HDF_LOGD("%s: enter!", __func__); + tester = PinTesterGet(); + if (tester == NULL) { + HDF_LOGE("%s: get tester fail!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + ret = PinSetPull(tester->handle, g_oldPinCfg.pullTypeNum); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: set pullTypeNum failed!", __func__); + return ret; + } + ret = PinSetStrength(tester->handle, g_oldPinCfg.strengthNum); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: set strengthNum failed!", __func__); + return ret; + } + ret = PinSetFunc(tester->handle, g_oldPinCfg.funcName); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: set funcName failed!", __func__); + return ret; + } + HDF_LOGD("%s: exit!", __func__); + + return HDF_SUCCESS; +} + +int32_t PinTestSetUpSingle(void) +{ + return HDF_SUCCESS; +} + +int32_t PinTestTearDownSingle(void) +{ + return HDF_SUCCESS; +} + +int32_t PinTestReliability(void) +{ + struct PinTester *tester = NULL; + + HDF_LOGI("%s: enter", __func__); + tester = PinTesterGet(); + if (tester == NULL || tester->handle == NULL) { + return HDF_ERR_INVALID_OBJECT; + } + HDF_LOGD("%s: test dfr for PinSetPull ...", __func__); + // invalid handle + (void)PinSetPull(NULL, tester->config.PullTypeNum); + (void)PinGetPull(NULL, &tester->config.PullTypeNum); + (void)PinSetStrength(NULL, tester->config.strengthNum); + (void)PinGetStrength(NULL, &tester->config.strengthNum); + (void)PinSetFunc(NULL, (const char *)tester->config.funcNameBuf); + (void)PinGetFunc(NULL, &tester->config.funcName); + // invalid strengthNum + (void)PinSetStrength(tester->handle, -1); + (void)PinGetStrength(tester->handle, NULL); + // invalid FuncName + (void)PinSetFunc(tester->handle, NULL); + HDF_LOGD("%s:test done.All completed!", __func__); + + return HDF_SUCCESS; +} + +static struct PinTestEntry g_entry[] = { + { PIN_TEST_CMD_SETGETPULL, PinSetGetPullTest, "PinSetGetPullTest" }, + { PIN_TEST_CMD_SETGETSTRENGTH, PinSetGetStrengthTest, "PinSetGetStrengthTest" }, + { PIN_TEST_CMD_SETGETFUNC, PinSetGetFuncTest, "PinSetGetFuncTest" }, + { PIN_TEST_CMD_RELIABILITY, PinTestReliability, "PinTestReliability" }, + { PIN_TEST_CMD_SETUP_ALL, PinTestSetUpAll, "PinTestSetUpAll" }, + { PIN_TEST_CMD_TEARDOWN_ALL, PinTestTearDownAll, "PinTestTearDownAll" }, +}; + +int32_t PinTestExecute(int cmd) +{ + uint32_t i; + int32_t ret = HDF_ERR_NOT_SUPPORT; + + if (cmd > PIN_TEST_CMD_MAX) { + HDF_LOGE("%s: invalid cmd:%d", __func__, cmd); + ret = HDF_ERR_NOT_SUPPORT; + goto __EXIT__; + } + + for (i = 0; i < sizeof(g_entry) / sizeof(g_entry[0]); i++) { + if (g_entry[i].cmd != cmd || g_entry[i].func == NULL) { + continue; + } + ret = g_entry[i].func(); + break; + } + +__EXIT__: + HDF_LOGE("[%s][======cmd:%d====ret:%d======]", __func__, cmd, ret); + return ret; +} + +void PinTestExecuteAll(void) +{ + int32_t i; + int32_t ret; + int32_t fails = 0; + + /* setup env for all test cases */ + ret = PinTestExecute(PIN_TEST_CMD_SETUP_ALL); + if (ret != HDF_SUCCESS) { + HDF_LOGE("func:%s PinTestExecute SETUP failed", __func__); + } + + for (i = 0; i < PIN_TEST_CMD_SETUP_ALL; i++) { + ret = PinTestExecute(i); + fails += (ret != HDF_SUCCESS) ? 1 : 0; + } + + /* teardown env for all test cases */ + ret = PinTestExecute(PIN_TEST_CMD_TEARDOWN_ALL); + if (ret != HDF_SUCCESS) { + HDF_LOGE("func:%s PinTestExecute TEARDOWN failed", __func__); + } + + HDF_LOGI("%s: **********PASS:%d FAIL:%d************\n\n", + __func__, PIN_TEST_CMD_RELIABILITY + 1 - fails, fails); +} \ No newline at end of file diff --git a/test/unittest/platform/common/pin_test.h b/test/unittest/platform/common/pin_test.h new file mode 100644 index 0000000000000000000000000000000000000000..6dddb9abef6839fb0d343396a77d2798e07f68ba --- /dev/null +++ b/test/unittest/platform/common/pin_test.h @@ -0,0 +1,55 @@ +/* + * Copyright (c) 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 PIN_TEST_H +#define PIN_TEST_H + +#include "pin_if.h" + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +struct PinTestConfig { + const char *pinName; + char funcNameBuf[30]; + const char *funcName; + enum PinPullType PullTypeNum; + uint32_t strengthNum; +}; + +struct PinTester { + struct PinTestConfig config; + DevHandle handle; + uint16_t total; + uint16_t fails; +}; + +enum PinTestCmd { + PIN_TEST_CMD_SETGETPULL = 0, + PIN_TEST_CMD_SETGETSTRENGTH = 1, + PIN_TEST_CMD_SETGETFUNC = 2, + PIN_TEST_CMD_RELIABILITY = 3, + PIN_TEST_CMD_SETUP_ALL = 4, + PIN_TEST_CMD_TEARDOWN_ALL = 5, + PIN_TEST_CMD_SETUP_SINGLE = 6, + PIN_TEST_CMD_TEARDOWN_SINGLE = 7, + PIN_TEST_CMD_MAX = 8, +}; + +int32_t PinTestExecute(int cmd); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* PIN_TEST_H */ diff --git a/test/unittest/platform/common/pwm_test.c b/test/unittest/platform/common/pwm_test.c index 6c291326a82c374e21d7a1f70fe32f6e418d8b20..d0340de49bd849547602da26cb338fda9dcb668f 100644 --- a/test/unittest/platform/common/pwm_test.c +++ b/test/unittest/platform/common/pwm_test.c @@ -6,14 +6,17 @@ * See the LICENSE file in the root of this repository for complete details. */ +#include "pwm_test.h" #include "device_resource_if.h" #include "hdf_base.h" #include "hdf_log.h" -#include "osal_mem.h" #include "osal_time.h" -#include "pwm_test.h" -#define HDF_LOG_TAG pwm_test_c +#define HDF_LOG_TAG pwm_test +#define SEQ_OUTPUT_DELAY 100 /* Delay time of sequential output, unit: ms */ +#define OUTPUT_WAVES_DELAY 1 /* Delay time of waves output, unit: second */ +#define TEST_WAVES_NUMBER 10 /* The number of waves for test. */ + struct PwmTestFunc { enum PwmTestCmd type; int32_t (*Func)(struct PwmTest *test); @@ -27,7 +30,7 @@ static DevHandle PwmTestGetHandle(struct PwmTest *test) static void PwmTestReleaseHandle(DevHandle handle) { if (handle == NULL) { - HDF_LOGE("%s: pwm handle is null", __func__); + HDF_LOGE("%s: pwm handle is null.", __func__); return; } PwmClose(handle); @@ -37,23 +40,36 @@ static int32_t PwmSetConfigTest(struct PwmTest *test) { int32_t ret; struct PwmConfig cfg = {0}; + uint32_t number; + HDF_LOGI("%s: enter. Test [PwmSetConfig].", __func__); + number = test->cfg.number; + test->cfg.number = ((number > 0) ? 0 : TEST_WAVES_NUMBER); + HDF_LOGI("%s: Set number %u.", __func__, test->cfg.number); + ret = PwmSetConfig(test->handle, &(test->cfg)); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: [PwmSetConfig] failed, ret %d.", __func__, ret); + return HDF_FAILURE; + } + OsalSleep(OUTPUT_WAVES_DELAY); + test->cfg.number = number; + HDF_LOGI("%s: Set number %u.", __func__, test->cfg.number); ret = PwmSetConfig(test->handle, &(test->cfg)); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: error, ret %d", __func__, ret); + HDF_LOGE("%s: [PwmSetConfig] failed, ret %d.", __func__, ret); return HDF_FAILURE; } ret = PwmGetConfig(test->handle, &cfg); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: error, ret %d", __func__, ret); + HDF_LOGE("%s: [PwmGetConfig] failed, ret %d.", __func__, ret); return HDF_FAILURE; } if (memcmp(&cfg, &(test->cfg), sizeof(cfg)) != 0) { - HDF_LOGE("%s: failed", __func__); + HDF_LOGE("%s: [memcmp] failed.", __func__); return HDF_FAILURE; } - HDF_LOGE("============= %s: success =============", __func__); + HDF_LOGI("%s: success.", __func__); return ret; } @@ -62,12 +78,13 @@ static int32_t PwmGetConfigTest(struct PwmTest *test) int32_t ret; struct PwmConfig cfg = {0}; + HDF_LOGI("%s: enter. Test [PwmGetConfig].", __func__); ret = PwmGetConfig(test->handle, &cfg); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: error, ret %d", __func__, ret); + HDF_LOGE("%s: [PwmGetConfig] failed, ret %d.", __func__, ret); return HDF_FAILURE; } - HDF_LOGE("============= %s: success =============", __func__); + HDF_LOGI("%s: success.", __func__); return ret; } @@ -75,22 +92,25 @@ static int32_t PwmSetPeriodTest(struct PwmTest *test) { int32_t ret; struct PwmConfig cfg = {0}; + uint32_t period; - ret = PwmSetPeriod(test->handle, test->cfg.period); + period = test->cfg.period + test->originCfg.period; + HDF_LOGI("%s: enter. Test [PwmSetPeriod] period %u.", __func__, period); + ret = PwmSetPeriod(test->handle, period); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: error, ret %d", __func__, ret); + HDF_LOGE("%s: [PwmSetPeriod] failed, ret %d.", __func__, ret); return HDF_FAILURE; } ret = PwmGetConfig(test->handle, &cfg); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: error, ret %d", __func__, ret); + HDF_LOGE("%s: [PwmGetConfig] failed, ret %d.", __func__, ret); return HDF_FAILURE; } - if (cfg.period != test->cfg.period) { - HDF_LOGE("%s: failed", __func__); + if (cfg.period != period) { + HDF_LOGE("%s: failed.", __func__); return HDF_FAILURE; } - HDF_LOGE("============= %s: success =============", __func__); + HDF_LOGI("%s: success.", __func__); return ret; } @@ -98,22 +118,25 @@ static int32_t PwmSetDutyTest(struct PwmTest *test) { int32_t ret; struct PwmConfig cfg = {0}; + uint32_t duty; - ret = PwmSetDuty(test->handle, test->cfg.duty); + duty = test->cfg.duty + test->originCfg.duty; + HDF_LOGI("%s: enter. Test [PwmSetDuty] duty %u.", __func__, duty); + ret = PwmSetDuty(test->handle, duty); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: error, ret %d", __func__, ret); + HDF_LOGE("%s: [PwmSetDuty] failed, ret %d.", __func__, ret); return HDF_FAILURE; } ret = PwmGetConfig(test->handle, &cfg); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: error, ret %d", __func__, ret); + HDF_LOGE("%s: [PwmGetConfig] failed, ret %d.", __func__, ret); return HDF_FAILURE; } - if (cfg.duty != test->cfg.duty) { - HDF_LOGE("%s: failed", __func__); + if (cfg.duty != duty) { + HDF_LOGE("%s: failed.", __func__); return HDF_FAILURE; } - HDF_LOGE("============= %s: success =============", __func__); + HDF_LOGI("%s: success.", __func__); return ret; } @@ -122,21 +145,31 @@ static int32_t PwmSetPolarityTest(struct PwmTest *test) int32_t ret; struct PwmConfig cfg = {0}; + HDF_LOGI("%s: enter.", __func__); + test->cfg.polarity = PWM_NORMAL_POLARITY; + HDF_LOGI("%s: Test [PwmSetPolarity] polarity %u.", __func__, test->cfg.polarity); ret = PwmSetPolarity(test->handle, test->cfg.polarity); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: error, ret %d", __func__, ret); + HDF_LOGE("%s: [PwmSetPolarity] failed, ret %d.", __func__, ret); + return HDF_FAILURE; + } + test->cfg.polarity = PWM_INVERTED_POLARITY; + HDF_LOGI("%s: Test [PwmSetPolarity] polarity %u.", __func__, test->cfg.polarity); + ret = PwmSetPolarity(test->handle, test->cfg.polarity); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: [PwmSetPolarity] failed, ret %d.", __func__, ret); return HDF_FAILURE; } ret = PwmGetConfig(test->handle, &cfg); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: error, ret %d", __func__, ret); + HDF_LOGE("%s: [PwmGetConfig] failed, ret %d.", __func__, ret); return HDF_FAILURE; } if (cfg.polarity != test->cfg.polarity) { - HDF_LOGE("%s: failed", __func__); + HDF_LOGE("%s: failed.", __func__); return HDF_FAILURE; } - HDF_LOGE("============= %s: success =============", __func__); + HDF_LOGI("%s: success.", __func__); return ret; } @@ -145,21 +178,28 @@ static int32_t PwmEnableTest(struct PwmTest *test) int32_t ret; struct PwmConfig cfg = {0}; + HDF_LOGI("%s: enter.", __func__); + ret = PwmDisable(test->handle); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: [PwmDisable] failed, ret %d.", __func__, ret); + return HDF_FAILURE; + } + HDF_LOGI("%s: Test [PwmEnable] enable.", __func__); ret = PwmEnable(test->handle); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: error, ret %d", __func__, ret); + HDF_LOGE("%s: [PwmEnable] failed, ret %d.", __func__, ret); return HDF_FAILURE; } ret = PwmGetConfig(test->handle, &cfg); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: error, ret %d", __func__, ret); + HDF_LOGE("%s: [PwmGetConfig] failed, ret %d.", __func__, ret); return HDF_FAILURE; } - if (cfg.status == 0) { + if (cfg.status == PWM_DISABLE_STATUS) { HDF_LOGE("%s: failed", __func__); return HDF_FAILURE; } - HDF_LOGE("============= %s: success =============", __func__); + HDF_LOGI("%s: success.", __func__); return ret; } @@ -168,21 +208,28 @@ static int32_t PwmDisableTest(struct PwmTest *test) int32_t ret; struct PwmConfig cfg = {0}; + HDF_LOGI("%s: enter.", __func__); + ret = PwmEnable(test->handle); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: [PwmEnable] failed, ret %d.", __func__, ret); + return HDF_FAILURE; + } + HDF_LOGI("%s: Test [PwmDisable] disable.", __func__); ret = PwmDisable(test->handle); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: error, ret %d", __func__, ret); + HDF_LOGE("%s: [PwmDisable] failed, ret %d.", __func__, ret); return HDF_FAILURE; } ret = PwmGetConfig(test->handle, &cfg); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: error, ret %d", __func__, ret); + HDF_LOGE("%s: [PwmGetConfig] failed, ret %d.", __func__, ret); return HDF_FAILURE; } - if (cfg.status == 1) { - HDF_LOGE("%s: failed", __func__); + if (cfg.status == PWM_ENABLE_STATUS) { + HDF_LOGE("%s: failed.", __func__); return HDF_FAILURE; } - HDF_LOGE("============= %s: success =============", __func__); + HDF_LOGI("%s: success.", __func__); return ret; } @@ -212,7 +259,7 @@ static int32_t PwmReliabilityTest(struct PwmTest *test) (void)PwmDisable(test->handle); (void)PwmDisable(test->handle); - HDF_LOGE("============= %s: success =============", __func__); + HDF_LOGI("%s: success.", __func__); return HDF_SUCCESS; } @@ -254,7 +301,7 @@ static int32_t PwmTestAll(struct PwmTest *test) } total++; - HDF_LOGE("============= %s: Pwm Test Total %d Error %d =============", __func__, total, error); + HDF_LOGI("%s: Pwm Test Total %d Error %d.", __func__, total, error); return HDF_SUCCESS; } @@ -278,20 +325,34 @@ static int32_t PwmTestEntry(struct PwmTest *test, int32_t cmd) if (test == NULL) { return HDF_ERR_INVALID_OBJECT; } + OsalMSleep(SEQ_OUTPUT_DELAY); test->handle = PwmTestGetHandle(test); if (test->handle == NULL) { - HDF_LOGE("%s: spi test get handle fail", __func__); + HDF_LOGE("%s: pwm test get handle fail.", __func__); return HDF_FAILURE; } + // At first test case. + if (cmd == PWM_SET_PERIOD_TEST) { + ret = PwmGetConfig(test->handle, &(test->originCfg)); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: [PwmGetConfig] failed, ret %d.", __func__, ret); + return HDF_FAILURE; + } + } for (i = 0; i < sizeof(g_pwmTestFunc) / sizeof(g_pwmTestFunc[0]); i++) { if (cmd == g_pwmTestFunc[i].type && g_pwmTestFunc[i].Func != NULL) { ret = g_pwmTestFunc[i].Func(test); - HDF_LOGE("%s: cmd %d ret %d", __func__, cmd, ret); + HDF_LOGI("%s: cmd %d ret %d.", __func__, cmd, ret); break; } } - + // At last test case. + if (cmd == PWM_DISABLE_TEST) { + PwmSetConfig(test->handle, &(test->originCfg)); + } PwmTestReleaseHandle(test->handle); + OsalMSleep(SEQ_OUTPUT_DELAY); + return ret; } @@ -302,9 +363,9 @@ static int32_t PwmTestBind(struct HdfDeviceObject *device) if (device != NULL) { device->service = &test.service; } else { - HDF_LOGE("%s: device is NULL", __func__); + HDF_LOGE("%s: device is NULL.", __func__); } - HDF_LOGE("%s: success", __func__); + HDF_LOGE("%s: success.", __func__); return HDF_SUCCESS; } @@ -317,31 +378,31 @@ static int32_t PwmTestInitFromHcs(struct PwmTest *test, const struct DeviceResou face = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); if (face == NULL) { - HDF_LOGE("%s: face is null", __func__); + HDF_LOGE("%s: face is null.", __func__); return HDF_FAILURE; } if (face->GetUint32 == NULL) { - HDF_LOGE("%s: GetUint32 not support", __func__); + HDF_LOGE("%s: GetUint32 not support.", __func__); return HDF_ERR_NOT_SUPPORT; } ret = face->GetUint32(node, "num", &(test->num), 0); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: read num fail", __func__); + HDF_LOGE("%s: read num fail.", __func__); return HDF_FAILURE; } ret = face->GetUint32(node, "period", &(test->cfg.period), 0); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: read period fail", __func__); + HDF_LOGE("%s: read period fail.", __func__); return HDF_FAILURE; } ret = face->GetUint32(node, "duty", &(test->cfg.duty), 0); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: read duty fail", __func__); + HDF_LOGE("%s: read duty fail.", __func__); return HDF_FAILURE; } ret = face->GetUint32(node, "polarity", &tmp, 0); if (ret != HDF_SUCCESS) { - HDF_LOGE("%s: read polarity fail", __func__); + HDF_LOGE("%s: read polarity fail.", __func__); return HDF_FAILURE; } test->cfg.polarity = tmp; @@ -359,14 +420,14 @@ static int32_t PwmTestInit(struct HdfDeviceObject *device) struct PwmTest *test = NULL; if (device == NULL || device->service == NULL || device->property == NULL) { - HDF_LOGE("%s: invalid parameter", __func__); + HDF_LOGE("%s: invalid parameter.", __func__); return HDF_ERR_INVALID_PARAM; } test = (struct PwmTest *)device->service; if (PwmTestInitFromHcs(test, device->property) != HDF_SUCCESS) { return HDF_FAILURE; } - HDF_LOGE("%s: success", __func__); + HDF_LOGE("%s: success.", __func__); test->TestEntry = PwmTestEntry; return HDF_SUCCESS; } @@ -374,7 +435,7 @@ static int32_t PwmTestInit(struct HdfDeviceObject *device) static void PwmTestRelease(struct HdfDeviceObject *device) { (void)device; - HDF_LOGE("%s: success", __func__); + HDF_LOGE("%s: success.", __func__); } struct HdfDriverEntry g_pwmTestEntry = { @@ -385,4 +446,3 @@ struct HdfDriverEntry g_pwmTestEntry = { .moduleName = "PLATFORM_PWM_TEST", }; HDF_INIT(g_pwmTestEntry); - diff --git a/test/unittest/platform/common/pwm_test.h b/test/unittest/platform/common/pwm_test.h index b82a8b3ed7c9e0d40d5e1b4eee9297b23cfb7c33..35cfddddd714d4051d79ec801e221c8b30c7fd53 100644 --- a/test/unittest/platform/common/pwm_test.h +++ b/test/unittest/platform/common/pwm_test.h @@ -10,7 +10,6 @@ #define PWM_TEST_H #include "hdf_device_desc.h" -#include "hdf_platform.h" #include "pwm_if.h" enum PwmTestCmd { @@ -31,6 +30,7 @@ struct PwmTest { int32_t (*TestEntry)(struct PwmTest *test, int32_t cmd); uint32_t num; struct PwmConfig cfg; + struct PwmConfig originCfg; DevHandle handle; }; diff --git a/test/unittest/platform/common/regulator_test.c b/test/unittest/platform/common/regulator_test.c new file mode 100755 index 0000000000000000000000000000000000000000..3bbebe10a7475084ad2ef1a273479ba36b504399 --- /dev/null +++ b/test/unittest/platform/common/regulator_test.c @@ -0,0 +1,409 @@ +/* + * Copyright (c) 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 "regulator_test.h" +#include "device_resource_if.h" +#include "hdf_log.h" +#include "osal_thread.h" +#include "osal_time.h" +#include "regulator_if.h" +#if defined(CONFIG_DRIVERS_HDF_PLATFORM_REGULATOR) +#include "virtual/regulator_linux_voltage_virtual_driver.h" +#include "virtual/regulator_linux_current_virtual_driver.h" +#endif + +#define HDF_LOG_TAG regulator_test_c + +struct RegulatorTestFunc { + enum RegulatorTestCmd type; + int32_t (*Func)(struct RegulatorTest *test); +}; + +enum RegulatorVoltage { + VOLTAGE_50_UV = 50, + VOLTAGE_250_UV = 250, + VOLTAGE_2500_UV = 2500, +}; + +enum RegulatorCurrent { + CURRENT_50_UA = 50, + CURRENT_250_UA = 250, +}; + +static int32_t RegulatorEnableTest(struct RegulatorTest *test) +{ + if (test == NULL || test->handle == NULL) { + HDF_LOGE("%s: test null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + RegulatorEnable(test->handle); + return HDF_SUCCESS; +} + +static int32_t RegulatorDisableTest(struct RegulatorTest *test) +{ + if (test == NULL || test->handle == NULL) { + HDF_LOGE("%s: test null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + RegulatorDisable(test->handle); + return HDF_SUCCESS; +} +static int32_t RegulatorForceDisableTest(struct RegulatorTest *test) +{ + if (test == NULL || test->handle == NULL) { + HDF_LOGE("%s: test null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + RegulatorForceDisable(test->handle); + return HDF_SUCCESS; +} +static int32_t RegulatorSetVoltageTest(struct RegulatorTest *test) +{ + if (test == NULL || test->handle == NULL) { + HDF_LOGE("%s: test null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (test->mode != REGULATOR_CHANGE_VOLTAGE) { + return HDF_SUCCESS; + } + + if (RegulatorSetVoltage(test->handle, test->minUv, test->maxUv) != HDF_SUCCESS) { + HDF_LOGE("%s:[%d, %d] test fail", __func__, test->maxUv, test->minUv); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} +static int32_t RegulatorGetVoltageTest(struct RegulatorTest *test) +{ + if (test == NULL || test->handle == NULL) { + HDF_LOGE("%s: test null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (test->mode != REGULATOR_CHANGE_VOLTAGE) { + return HDF_SUCCESS; + } + + if (RegulatorGetVoltage(test->handle, &test->uv) != HDF_SUCCESS) { + HDF_LOGE("%s: test fail", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} +static int32_t RegulatorSetCurrentTest(struct RegulatorTest *test) +{ + if (test == NULL || test->handle == NULL) { + HDF_LOGE("%s: test null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (test->mode != REGULATOR_CHANGE_CURRENT) { + return HDF_SUCCESS; + } + + if (RegulatorSetCurrent(test->handle, test->minUa, test->maxUa) != HDF_SUCCESS) { + HDF_LOGE("%s:[%d, %d] test fail", __func__, test->minUa, test->maxUa); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} +static int32_t RegulatorGetCurrentTest(struct RegulatorTest *test) +{ + if (test == NULL || test->handle == NULL) { + HDF_LOGE("%s: test null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (test->mode != REGULATOR_CHANGE_CURRENT) { + return HDF_SUCCESS; + } + + if (RegulatorGetCurrent(test->handle, &test->ua) != HDF_SUCCESS) { + HDF_LOGE("%s: test fail", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} +static int32_t RegulatorGetStatusTest(struct RegulatorTest *test) +{ + if (test == NULL || test->handle == NULL) { + HDF_LOGE("%s: test null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + if (RegulatorGetStatus(test->handle, &test->status) != HDF_SUCCESS) { + HDF_LOGE("%s: test fail", __func__); + return HDF_FAILURE; + } + + if ((test->status != REGULATOR_STATUS_ON) && (test->status != REGULATOR_STATUS_OFF)) { + HDF_LOGE("%s: regulator status invalid %d", __func__, test->status); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} +static int RegulatorTestThreadFunc(void *param) +{ + DevHandle handle = RegulatorOpen("regulator_virtual_1"); + if (handle == NULL) { + HDF_LOGE("%s: regulator test get handle fail", __func__); + *((int32_t *)param) = 1; + return HDF_FAILURE; + } + + if (RegulatorSetVoltage(handle, VOLTAGE_250_UV, VOLTAGE_2500_UV) != HDF_SUCCESS) { + HDF_LOGE("%s:test fail", __func__); + RegulatorClose(handle); + *((int32_t *)param) = 1; + return HDF_FAILURE; + } + + RegulatorClose(handle); + *((int32_t *)param) = 1; + return HDF_SUCCESS; +} + +int32_t RegulatorTestMultiThread(struct RegulatorTest *test) +{ + int32_t ret; + uint32_t time; + struct OsalThread thread1, thread2; + struct OsalThreadParam cfg1, cfg2; + int32_t count1, count2; + + count1 = count2 = 0; + time = 0; + ret = OsalThreadCreate(&thread1, (OsalThreadEntry)RegulatorTestThreadFunc, (void *)&count1); + if (ret != HDF_SUCCESS) { + HDF_LOGE("create test thread1 fail:%d", ret); + return HDF_FAILURE; + } + + ret = OsalThreadCreate(&thread2, (OsalThreadEntry)RegulatorTestThreadFunc, (void *)&count2); + if (ret != HDF_SUCCESS) { + (void)OsalThreadDestroy(&thread1); + HDF_LOGE("create test thread1 fail:%d", ret); + return HDF_FAILURE; + } + + cfg1.name = "RegulatorTestThread-1"; + cfg2.name = "RegulatorTestThread-2"; + cfg1.priority = cfg2.priority = OSAL_THREAD_PRI_DEFAULT; + cfg1.stackSize = cfg2.stackSize = REGULATOR_TEST_STACK_SIZE; + + ret = OsalThreadStart(&thread1, &cfg1); + if (ret != HDF_SUCCESS) { + (void)OsalThreadDestroy(&thread1); + (void)OsalThreadDestroy(&thread2); + HDF_LOGE("start test thread1 fail:%d", ret); + return HDF_FAILURE; + } + + ret = OsalThreadStart(&thread2, &cfg2); + if (ret != HDF_SUCCESS) { + (void)OsalThreadDestroy(&thread1); + (void)OsalThreadDestroy(&thread2); + HDF_LOGE("start test thread2 fail:%d", ret); + return HDF_FAILURE; + } + + while (count1 == 0 || count2 == 0) { + HDF_LOGE("waitting testing Regulator thread finish..."); + OsalMSleep(REGULATOR_TEST_WAIT_TIMES); + time++; + if (time > REGULATOR_TEST_WAIT_TIMEOUT) { + break; + } + } + + (void)OsalThreadDestroy(&thread1); + (void)OsalThreadDestroy(&thread2); + return HDF_SUCCESS; +} + +int32_t RegulatorTestReliability(struct RegulatorTest *test) +{ + HDF_LOGD("RegulatorTestReliability: test for Regulator ..."); + if (test == NULL || test->handle == NULL) { + HDF_LOGE("%s: test null", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + RegulatorSetVoltage(test->handle, VOLTAGE_250_UV, VOLTAGE_50_UV); + RegulatorSetCurrent(test->handle, CURRENT_250_UA, CURRENT_50_UA); + RegulatorGetCurrent(test->handle, NULL); + return HDF_SUCCESS; +} + +static struct RegulatorTestFunc g_regulatorTestFunc[] = { + {REGULATOR_ENABLE_TEST, RegulatorEnableTest}, + {REGULATOR_DISABLE_TEST, RegulatorDisableTest}, + {REGULATOR_FORCE_DISABLE_TEST, RegulatorForceDisableTest}, + {REGULATOR_SET_VOLTAGE_TEST, RegulatorSetVoltageTest}, + {REGULATOR_GET_VOLTAGE_TEST, RegulatorGetVoltageTest}, + {REGULATOR_SET_CURRENT_TEST, RegulatorSetCurrentTest}, + {REGULATOR_GET_CURRENT_TEST, RegulatorGetCurrentTest}, + {REGULATOR_GET_STATUS_TEST, RegulatorGetStatusTest}, + {REGULATOR_MULTI_THREAD_TEST, RegulatorTestMultiThread}, + {REGULATOR_RELIABILITY_TEST, RegulatorTestReliability}, +}; + +static int32_t RegulatorTestEntry(struct RegulatorTest *test, int32_t cmd) +{ + int32_t i; + int32_t ret = HDF_ERR_NOT_SUPPORT; + + if (test == NULL || test->name == NULL) { + HDF_LOGE("%s: test null cmd %d", __func__, cmd); + return HDF_ERR_INVALID_OBJECT; + } + + if (cmd != REGULATOR_MULTI_THREAD_TEST) { + test->handle = RegulatorOpen(test->name); + if (test->handle == NULL) { + HDF_LOGE("%s: regulator test get handle fail", __func__); + return HDF_FAILURE; + } + } + + for (i = 0; i < sizeof(g_regulatorTestFunc) / sizeof(g_regulatorTestFunc[0]); i++) { + if (cmd == g_regulatorTestFunc[i].type && g_regulatorTestFunc[i].Func != NULL) { + ret = g_regulatorTestFunc[i].Func(test); + HDF_LOGD("%s: cmd %d ret %d", __func__, cmd, ret); + break; + } + } + + if (cmd != REGULATOR_MULTI_THREAD_TEST) { + RegulatorClose(test->handle); + } + return ret; +} + +static int32_t RegulatorTestBind(struct HdfDeviceObject *device) +{ + static struct RegulatorTest test; + + if (device != NULL) { + device->service = &test.service; + } else { + HDF_LOGE("%s: device is NULL", __func__); + } + + HDF_LOGI("RegulatorTestBind success\r\n"); + return HDF_SUCCESS; +} + +static int32_t RegulatorTestInitFromHcs(struct RegulatorTest *test, const struct DeviceResourceNode *node) +{ + int32_t ret; + struct DeviceResourceIface *face = NULL; + + face = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (face == NULL) { + HDF_LOGE("%s: face is null", __func__); + return HDF_FAILURE; + } + if (face->GetUint32 == NULL || face->GetUint32Array == NULL) { + HDF_LOGE("%s: GetUint32 or GetUint32Array not support", __func__); + return HDF_ERR_NOT_SUPPORT; + } + + ret = face->GetString(node, "name", &(test->name), "ERROR"); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read name fail!", __func__); + return HDF_FAILURE; + } + + ret = face->GetUint8(node, "mode", &test->mode, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read mode fail!", __func__); + return HDF_FAILURE; + } + + ret = face->GetUint32(node, "minUv", &test->minUv, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read minUv fail!", __func__); + return HDF_FAILURE; + } + + ret = face->GetUint32(node, "maxUv", &test->maxUv, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read maxUv fail!", __func__); + return HDF_FAILURE; + } + + ret = face->GetUint32(node, "minUa", &test->minUa, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read minUa fail!", __func__); + return HDF_FAILURE; + } + + ret = face->GetUint32(node, "maxUa", &test->maxUa, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read maxUa fail!", __func__); + return HDF_FAILURE; + } + + HDF_LOGI("regulator test init:[%s][%d]--[%d][%d]--[%d][%d]!", + test->name, test->mode, test->minUv, test->maxUv, test->minUa, test->maxUa); + + return HDF_SUCCESS; +} + +static int32_t RegulatorTestInit(struct HdfDeviceObject *device) +{ + struct RegulatorTest *test = NULL; + + HDF_LOGI("RegulatorTestInit in\r\n"); + +#if defined(CONFIG_DRIVERS_HDF_PLATFORM_REGULATOR) + VirtualVoltageRegulatorAdapterInit(); + VirtualCurrentRegulatorAdapterInit(); +#endif + + if (device == NULL || device->service == NULL || device->property == NULL) { + HDF_LOGE("%s: invalid parameter", __func__); + return HDF_ERR_INVALID_PARAM; + } + test = (struct RegulatorTest *)device->service; + + if (RegulatorTestInitFromHcs(test, device->property) != HDF_SUCCESS) { + HDF_LOGE("%s: RegulatorTestInitFromHcs failed", __func__); + return HDF_FAILURE; + } + + test->TestEntry = RegulatorTestEntry; + HDF_LOGI("%s: success", __func__); + + return HDF_SUCCESS; +} + +static void RegulatorTestRelease(struct HdfDeviceObject *device) +{ + (void)device; +} + +struct HdfDriverEntry g_regulatorTestEntry = { + .moduleVersion = 1, + .Bind = RegulatorTestBind, + .Init = RegulatorTestInit, + .Release = RegulatorTestRelease, + .moduleName = "PLATFORM_REGULATOR_TEST", +}; +HDF_INIT(g_regulatorTestEntry); diff --git a/test/unittest/platform/common/regulator_test.h b/test/unittest/platform/common/regulator_test.h new file mode 100755 index 0000000000000000000000000000000000000000..99a52ff7b853a98500f77d6f19bd3d6baa5c88f1 --- /dev/null +++ b/test/unittest/platform/common/regulator_test.h @@ -0,0 +1,66 @@ +/* + * Copyright (c) 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 REGULATOR_TEST_H +#define REGULATOR_TEST_H + +#include "hdf_device_desc.h" +#include "hdf_platform.h" + +#ifdef REGULATOR_TEST_PRINTK_OPEN +#define REGULATOR_TEST_PRINT_LOG_DBG(fmt, arg...) \ +dprintf("[HDF]-[REGULATOR]:[%s][%d]---" fmt "\r\n", __func__, __LINE__, ##arg) +#define REGULATOR_TEST_PRINT_LOG_INF(fmt, arg...) \ +dprintf("[HDF]-[REGULATOR]:[%s][%d]---" fmt "\r\n", __func__, __LINE__, ##arg) +#define REGULATOR_TEST_PRINT_LOG_ERR(fmt, arg...) \ +dprintf("[HDF]-[REGULATOR]:[%s][%d]---" fmt "\r\n", __func__, __LINE__, ##arg) +#else +#define REGULATOR_TEST_PRINT_LOG_DBG(fmt, arg...) HDF_LOGD_WRAPPER("[HDF]-[REGULATOR]:" fmt "\r\n", ##arg) +#define REGULATOR_TEST_PRINT_LOG_INF(fmt, arg...) HDF_LOGI_WRAPPER("[HDF]-[REGULATOR]:" fmt "\r\n", ##arg) +#define REGULATOR_TEST_PRINT_LOG_ERR(fmt, arg...) HDF_LOGE_WRAPPER("[HDF]-[REGULATOR]:" fmt "\r\n", ##arg) +#endif + +enum RegulatorTestCmd { + REGULATOR_ENABLE_TEST, + REGULATOR_DISABLE_TEST, + REGULATOR_FORCE_DISABLE_TEST, + REGULATOR_SET_VOLTAGE_TEST, + REGULATOR_GET_VOLTAGE_TEST, + REGULATOR_SET_CURRENT_TEST, + REGULATOR_GET_CURRENT_TEST, + REGULATOR_GET_STATUS_TEST, + REGULATOR_MULTI_THREAD_TEST, + REGULATOR_RELIABILITY_TEST, +}; + +#define REGULATOR_TEST_STACK_SIZE (1024 * 100) +#define REGULATOR_TEST_WAIT_TIMES 200 +#define REGULATOR_TEST_WAIT_TIMEOUT 20 + +struct RegulatorTest { + struct IDeviceIoService service; + struct HdfDeviceObject *device; + int32_t (*TestEntry)(struct RegulatorTest *test, int32_t cmd); + DevHandle handle; + const char *name; + uint32_t maxUv; + uint32_t minUv; + uint32_t maxUa; + uint32_t minUa; + uint32_t uv; + uint32_t ua; + uint32_t status; + uint8_t mode; +}; + +static inline struct RegulatorTest *GetRegulatorTest(void) +{ + return (struct RegulatorTest *)DevSvcManagerClntGetService("REGULATOR_TEST"); +} + +#endif /* REGULATOR_TEST_H */ diff --git a/test/unittest/platform/common/spi_test.c b/test/unittest/platform/common/spi_test.c index d1603ac0808e72c139cd1e47b87399be0d794bd1..0fce13ea3baf7397cf1af3267ea8a91e155e4431 100644 --- a/test/unittest/platform/common/spi_test.c +++ b/test/unittest/platform/common/spi_test.c @@ -237,6 +237,7 @@ static int32_t SpiDmaTransferTest(struct SpiTest *test) return ret; } + SpiUnsetDmaIntMsg(&msg); return HDF_SUCCESS; } @@ -268,6 +269,7 @@ static int32_t SpiIntTransferTest(struct SpiTest *test) return ret; } + SpiUnsetDmaIntMsg(&msg); return HDF_SUCCESS; } diff --git a/test/unittest/platform/common/uart_test.c b/test/unittest/platform/common/uart_test.c index 7700323b391a536313c3f2905474b41f38d65e3e..d926be92d5f2563d8089e9f184cccf1176d99fa8 100644 --- a/test/unittest/platform/common/uart_test.c +++ b/test/unittest/platform/common/uart_test.c @@ -35,10 +35,12 @@ static int32_t UartWriteTest(struct UartTest *test) static int32_t UartReadTest(struct UartTest *test) { +#ifdef __LITEOS__ if (UartSetTransMode(test->handle, UART_MODE_RD_NONBLOCK) != HDF_SUCCESS) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; - } + } +#endif if (UartRead(test->handle, test->rbuf, test->len) != 0) { HDF_LOGE("%s: error", __func__); return HDF_FAILURE; diff --git a/test/unittest/platform/common/watchdog_test.c b/test/unittest/platform/common/watchdog_test.c index ee2d923602d9e91c64ef5ff9859fc6b10b29aa30..9a4ad18b01e9dbb9cdd54f158fd75385ee57d589 100644 --- a/test/unittest/platform/common/watchdog_test.c +++ b/test/unittest/platform/common/watchdog_test.c @@ -19,13 +19,21 @@ #define WATCHDOG_TEST_TIMEOUT 2 #define WATCHDOG_TEST_FEED_TIME 6 +static int32_t g_wdtState = 0; + static int32_t WatchdogTestSetUp(struct WatchdogTester *tester) { + int32_t ret; + if (tester == NULL) { return HDF_ERR_INVALID_OBJECT; } if (tester->handle == NULL) { - tester->handle = WatchdogOpen(0); + ret = WatchdogOpen(0, &tester->handle); + if (ret == HDF_ERR_DEVICE_BUSY) { + g_wdtState = ret; + return HDF_SUCCESS; + } } if (tester->handle == NULL) { return HDF_ERR_DEVICE_BUSY; @@ -38,6 +46,11 @@ static int32_t WatchdogTestSetUp(struct WatchdogTester *tester) static void WatchdogTestTearDown(struct WatchdogTester *tester) { + if (g_wdtState == HDF_ERR_DEVICE_BUSY) { + HDF_LOGE("%s: DEVICE IS BUSY", __func__); + return; + } + int ret; if (tester == NULL || tester->handle == NULL) { @@ -56,6 +69,11 @@ static void WatchdogTestTearDown(struct WatchdogTester *tester) static int32_t TestCaseWatchdogSetGetTimeout(struct WatchdogTester *tester) { + if (g_wdtState == HDF_ERR_DEVICE_BUSY) { + HDF_LOGE("%s: DEVICE IS BUSY", __func__); + return HDF_SUCCESS; + } + int32_t ret; uint32_t timeoutGet = 0; const uint32_t timeoutSet = WATCHDOG_TEST_TIMEOUT; @@ -80,6 +98,11 @@ static int32_t TestCaseWatchdogSetGetTimeout(struct WatchdogTester *tester) static int32_t TestCaseWatchdogStartStop(struct WatchdogTester *tester) { + if (g_wdtState == HDF_ERR_DEVICE_BUSY) { + HDF_LOGE("%s: DEVICE IS BUSY", __func__); + return HDF_SUCCESS; + } + int32_t ret; int32_t status; @@ -116,6 +139,11 @@ static int32_t TestCaseWatchdogStartStop(struct WatchdogTester *tester) static int32_t TestCaseWatchdogFeed(struct WatchdogTester *tester) { + if (g_wdtState == HDF_ERR_DEVICE_BUSY) { + HDF_LOGE("%s: DEVICE IS BUSY", __func__); + return HDF_SUCCESS; + } + int32_t ret; int32_t i; @@ -141,6 +169,11 @@ static int32_t TestCaseWatchdogFeed(struct WatchdogTester *tester) static int32_t TestCaseWatchdogBark(struct WatchdogTester *tester) { + if (g_wdtState == HDF_ERR_DEVICE_BUSY) { + HDF_LOGE("%s: DEVICE IS BUSY", __func__); + return HDF_SUCCESS; + } + #ifdef WATCHDOG_TEST_BARK_RESET int32_t ret; int32_t i; @@ -166,6 +199,11 @@ static int32_t TestCaseWatchdogBark(struct WatchdogTester *tester) static int32_t TestCaseWatchdogReliability(struct WatchdogTester *tester) { + if (g_wdtState == HDF_ERR_DEVICE_BUSY) { + HDF_LOGE("%s: DEVICE IS BUSY", __func__); + return HDF_SUCCESS; + } + int32_t status; uint32_t timeout; @@ -198,6 +236,11 @@ static int32_t TestCaseWatchdogReliability(struct WatchdogTester *tester) static int32_t WatchdogTestByCmd(struct WatchdogTester *tester, int32_t cmd) { + if (g_wdtState == HDF_ERR_DEVICE_BUSY) { + HDF_LOGE("%s: DEVICE IS BUSY", __func__); + return HDF_SUCCESS; + } + int32_t i; if (cmd == WATCHDOG_TEST_SET_GET_TIMEOUT) { diff --git a/test/unittest/platform/hdf_adc_entry_test.c b/test/unittest/platform/entry/hdf_adc_entry_test.c similarity index 100% rename from test/unittest/platform/hdf_adc_entry_test.c rename to test/unittest/platform/entry/hdf_adc_entry_test.c diff --git a/test/unittest/platform/hdf_adc_entry_test.h b/test/unittest/platform/entry/hdf_adc_entry_test.h similarity index 100% rename from test/unittest/platform/hdf_adc_entry_test.h rename to test/unittest/platform/entry/hdf_adc_entry_test.h diff --git a/test/unittest/platform/entry/hdf_dac_entry_test.c b/test/unittest/platform/entry/hdf_dac_entry_test.c new file mode 100644 index 0000000000000000000000000000000000000000..afcf67744c1dbf632a94ed3077a3ce547b542c90 --- /dev/null +++ b/test/unittest/platform/entry/hdf_dac_entry_test.c @@ -0,0 +1,26 @@ +/* + * Copyright (c) 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_dac_entry_test.h" +#include "hdf_log.h" +#include "dac_test.h" +#include "hdf_log.h" + +#define HDF_LOG_TAG hdf_dac_entry_test + +int32_t HdfDacTestEntry(HdfTestMsg *msg) +{ + HDF_LOGE("%s: enter", __func__); + if (msg == NULL) { + return HDF_FAILURE; + } + + msg->result = DacTestExecute(msg->subCmd); + + return HDF_SUCCESS; +} diff --git a/test/unittest/platform/entry/hdf_dac_entry_test.h b/test/unittest/platform/entry/hdf_dac_entry_test.h new file mode 100644 index 0000000000000000000000000000000000000000..b693b6b0e3c40d4cbbf6bf398e82b6bb70669e8f --- /dev/null +++ b/test/unittest/platform/entry/hdf_dac_entry_test.h @@ -0,0 +1,16 @@ +/* + * Copyright (c) 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_DAC_ENTRY_TEST_H +#define HDF_DAC_ENTRY_TEST_H + +#include "hdf_main_test.h" + +int32_t HdfDacTestEntry(HdfTestMsg *msg); + +#endif /* HDF_DAC_ENTRY_TEST_H */ \ No newline at end of file diff --git a/test/unittest/platform/hdf_emmc_entry_test.c b/test/unittest/platform/entry/hdf_emmc_entry_test.c similarity index 100% rename from test/unittest/platform/hdf_emmc_entry_test.c rename to test/unittest/platform/entry/hdf_emmc_entry_test.c diff --git a/test/unittest/platform/hdf_emmc_entry_test.h b/test/unittest/platform/entry/hdf_emmc_entry_test.h similarity index 100% rename from test/unittest/platform/hdf_emmc_entry_test.h rename to test/unittest/platform/entry/hdf_emmc_entry_test.h diff --git a/test/unittest/platform/hdf_gpio_entry_test.c b/test/unittest/platform/entry/hdf_gpio_entry_test.c similarity index 63% rename from test/unittest/platform/hdf_gpio_entry_test.c rename to test/unittest/platform/entry/hdf_gpio_entry_test.c index 9cd7adbbb28e32425a203b55abc92b7ba570db01..ebda1edb7cb35ca7c011d6bd0f95694bc3f0cf37 100644 --- a/test/unittest/platform/hdf_gpio_entry_test.c +++ b/test/unittest/platform/entry/hdf_gpio_entry_test.c @@ -7,27 +7,16 @@ */ #include "hdf_gpio_entry_test.h" -#include "gpio_if.h" #include "gpio_test.h" -#include "hdf_log.h" #define HDF_LOG_TAG hdf_gpio_entry_test int32_t HdfGpioTestEntry(HdfTestMsg *msg) { - struct GpioTester *tester = NULL; - if (msg == NULL) { return HDF_FAILURE; } - tester = GpioTesterGet(); - if (tester == NULL) { - HDF_LOGE("%s: tester is NULL!\n", __func__); - return HDF_FAILURE; - } - - msg->result = tester->doTest(tester, msg->subCmd); - + msg->result = GpioTestExecute(msg->subCmd); return HDF_SUCCESS; } diff --git a/test/unittest/platform/hdf_gpio_entry_test.h b/test/unittest/platform/entry/hdf_gpio_entry_test.h similarity index 100% rename from test/unittest/platform/hdf_gpio_entry_test.h rename to test/unittest/platform/entry/hdf_gpio_entry_test.h diff --git a/test/unittest/platform/entry/hdf_hdmi_entry_test.c b/test/unittest/platform/entry/hdf_hdmi_entry_test.c new file mode 100644 index 0000000000000000000000000000000000000000..17435b662abcef45108060df20c36499e2338a99 --- /dev/null +++ b/test/unittest/platform/entry/hdf_hdmi_entry_test.c @@ -0,0 +1,32 @@ +/* + * Copyright (c) 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_hdmi_entry_test.h" +#include "hdf_log.h" +#include "hdmi_if.h" +#include "hdmi_test.h" + +#define HDF_LOG_TAG hdf_hdmi_entry_test + +int32_t HdfHdmiUnitTestEntry(HdfTestMsg *msg) +{ + struct HdmiTester *tester = NULL; + + if (msg == NULL) { + HDF_LOGE("HdfHdmiUnitTestEntry: msg is NULL"); + return HDF_FAILURE; + } + tester = GetHdmiTester(); + if (tester == NULL || tester->TestEntry == NULL) { + HDF_LOGE("HdfHdmiUnitTestEntry: tester/TestEntry is NULL"); + msg->result = HDF_FAILURE; + return HDF_FAILURE; + } + msg->result = tester->TestEntry(tester, msg->subCmd); + return msg->result; +} diff --git a/test/unittest/platform/entry/hdf_hdmi_entry_test.h b/test/unittest/platform/entry/hdf_hdmi_entry_test.h new file mode 100644 index 0000000000000000000000000000000000000000..9a446367012aaf9c0b310d4a0404c96d2d2d5b54 --- /dev/null +++ b/test/unittest/platform/entry/hdf_hdmi_entry_test.h @@ -0,0 +1,16 @@ +/* + * Copyright (c) 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_HDMI_ENTRY_TEST_H +#define HDF_HDMI_ENTRY_TEST_H + +#include "hdf_main_test.h" + +int32_t HdfHdmiUnitTestEntry(HdfTestMsg *msg); + +#endif // HDF_HDMI_ENTRY_TEST_H \ No newline at end of file diff --git a/test/unittest/platform/hdf_i2c_entry_test.c b/test/unittest/platform/entry/hdf_i2c_entry_test.c similarity index 100% rename from test/unittest/platform/hdf_i2c_entry_test.c rename to test/unittest/platform/entry/hdf_i2c_entry_test.c diff --git a/test/unittest/platform/hdf_i2c_entry_test.h b/test/unittest/platform/entry/hdf_i2c_entry_test.h similarity index 100% rename from test/unittest/platform/hdf_i2c_entry_test.h rename to test/unittest/platform/entry/hdf_i2c_entry_test.h diff --git a/test/unittest/platform/hdf_i2s_entry_test.c b/test/unittest/platform/entry/hdf_i2s_entry_test.c similarity index 100% rename from test/unittest/platform/hdf_i2s_entry_test.c rename to test/unittest/platform/entry/hdf_i2s_entry_test.c diff --git a/test/unittest/platform/hdf_i2s_entry_test.h b/test/unittest/platform/entry/hdf_i2s_entry_test.h similarity index 100% rename from test/unittest/platform/hdf_i2s_entry_test.h rename to test/unittest/platform/entry/hdf_i2s_entry_test.h diff --git a/test/unittest/platform/entry/hdf_i3c_entry_test.c b/test/unittest/platform/entry/hdf_i3c_entry_test.c new file mode 100644 index 0000000000000000000000000000000000000000..c6219940d350e442ba75f58f7fb823cfc92e16a1 --- /dev/null +++ b/test/unittest/platform/entry/hdf_i3c_entry_test.c @@ -0,0 +1,25 @@ +/* + * Copyright (c) 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_i3c_entry_test.h" +#include "hdf_log.h" +#include "i3c_test.h" + +#define HDF_LOG_TAG hdf_adc_entry_test + +int32_t HdfI3cTestEntry(HdfTestMsg *msg) +{ + HDF_LOGI("%s: enter", __func__); + if (msg == NULL) { + return HDF_FAILURE; + } + + msg->result = I3cTestExecute(msg->subCmd); + + return HDF_SUCCESS; +} \ No newline at end of file diff --git a/test/unittest/platform/entry/hdf_i3c_entry_test.h b/test/unittest/platform/entry/hdf_i3c_entry_test.h new file mode 100644 index 0000000000000000000000000000000000000000..efe663e0ad1cf1501a3f64ed91c95fd1f2b646ee --- /dev/null +++ b/test/unittest/platform/entry/hdf_i3c_entry_test.h @@ -0,0 +1,16 @@ +/* + * Copyright (c) 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_I3C_ENTRY_TEST_H +#define HDF_I3C_ENTRY_TEST_H + +#include "hdf_main_test.h" + +int32_t HdfI3cTestEntry(HdfTestMsg *msg); + +#endif /* HDF_I3C_ENTRY_TEST_H */ diff --git a/test/unittest/platform/entry/hdf_mipi_csi_entry_test.c b/test/unittest/platform/entry/hdf_mipi_csi_entry_test.c new file mode 100755 index 0000000000000000000000000000000000000000..d3b4d0d7187648efe5dccb1ec8d0ec317b113d45 --- /dev/null +++ b/test/unittest/platform/entry/hdf_mipi_csi_entry_test.c @@ -0,0 +1,36 @@ +/* + * Copyright (c) 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_mipi_csi_entry_test.h" +#include "hdf_log.h" +#include "mipi_csi_test.h" + +#define HDF_LOG_TAG hdf_mipi_csi_entry_test + +int32_t HdfMipiCsiEntry(HdfTestMsg *msg) +{ + int32_t ret; + struct MipiCsiTest *test = NULL; + + if (msg == NULL) { + HDF_LOGE("%s: msg is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + test = MipiCsiTestServiceGet(); + if (test == NULL) { + HDF_LOGE("%s: test is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + HDF_LOGI("%s: call [doTest]", __func__); + ret = test->doTest(test, msg->subCmd); + msg->result = (int8_t)ret; + + return ret; +} diff --git a/test/unittest/platform/entry/hdf_mipi_csi_entry_test.h b/test/unittest/platform/entry/hdf_mipi_csi_entry_test.h new file mode 100755 index 0000000000000000000000000000000000000000..c31a73106b8b9e54f88b084ae4b507b760a379fa --- /dev/null +++ b/test/unittest/platform/entry/hdf_mipi_csi_entry_test.h @@ -0,0 +1,15 @@ +/* + * Copyright (c) 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_MIPI_CSI_ENTRY_TEST_H +#define HDF_MIPI_CSI_ENTRY_TEST_H + +#include "hdf_main_test.h" + +int32_t HdfMipiCsiEntry(HdfTestMsg *msg); +#endif // HDF_MIPI_CSI_ENTRY_TEST_H \ No newline at end of file diff --git a/test/unittest/platform/hdf_mipi_dsi_entry_test.c b/test/unittest/platform/entry/hdf_mipi_dsi_entry_test.c similarity index 65% rename from test/unittest/platform/hdf_mipi_dsi_entry_test.c rename to test/unittest/platform/entry/hdf_mipi_dsi_entry_test.c index c4001c21352529fdd2089a2529e36b7368885a7e..ad4a3d6da8d5c691b8aa226c9d49460438c2061d 100644 --- a/test/unittest/platform/hdf_mipi_dsi_entry_test.c +++ b/test/unittest/platform/entry/hdf_mipi_dsi_entry_test.c @@ -8,26 +8,29 @@ #include "hdf_mipi_dsi_entry_test.h" #include "hdf_log.h" -#include "mipi_dsi_if.h" #include "mipi_dsi_test.h" #define HDF_LOG_TAG hdf_mipi_dsi_entry_test int32_t HdfMipiDsiEntry(HdfTestMsg *msg) { + int32_t ret; struct MipiDsiTest *test = NULL; if (msg == NULL) { - return HDF_FAILURE; + HDF_LOGE("%s: msg is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; } test = MipiDsiTestServiceGet(); if (test == NULL) { - HDF_LOGE("%s: get service fail!", __func__); - return HDF_FAILURE; + HDF_LOGE("%s: test is NULL!", __func__); + return HDF_ERR_INVALID_OBJECT; } - msg->result = test->doTest(test, msg->subCmd); + HDF_LOGI("%s: call [doTest]", __func__); + ret = test->doTest(test, msg->subCmd); + msg->result = (int8_t)ret; return HDF_SUCCESS; } diff --git a/test/unittest/platform/hdf_mipi_dsi_entry_test.h b/test/unittest/platform/entry/hdf_mipi_dsi_entry_test.h similarity index 100% rename from test/unittest/platform/hdf_mipi_dsi_entry_test.h rename to test/unittest/platform/entry/hdf_mipi_dsi_entry_test.h diff --git a/test/unittest/platform/entry/hdf_pin_entry_test.c b/test/unittest/platform/entry/hdf_pin_entry_test.c new file mode 100644 index 0000000000000000000000000000000000000000..b159fcd3608bbd0c67ff7b461770b195974d5404 --- /dev/null +++ b/test/unittest/platform/entry/hdf_pin_entry_test.c @@ -0,0 +1,26 @@ +/* + * Copyright (c) 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_pin_entry_test.h" +#include "hdf_log.h" +#include "pin_test.h" + +#define HDF_LOG_TAG hdf_pin_entry_test + +int32_t HdfPinTestEntry(HdfTestMsg *msg) +{ + HDF_LOGD("%s: enter", __func__); + + if (msg == NULL) { + return HDF_FAILURE; + } + + msg->result = PinTestExecute(msg->subCmd); + + return HDF_SUCCESS; +} \ No newline at end of file diff --git a/test/unittest/platform/entry/hdf_pin_entry_test.h b/test/unittest/platform/entry/hdf_pin_entry_test.h new file mode 100644 index 0000000000000000000000000000000000000000..eac3848cd785097ef293cc70d7667762a03fd22f --- /dev/null +++ b/test/unittest/platform/entry/hdf_pin_entry_test.h @@ -0,0 +1,16 @@ +/* + * Copyright (c) 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_PIN_ENTRY_TEST_H +#define HDF_PIN_ENTRY_TEST_H + +#include "hdf_main_test.h" + +int32_t HdfPinTestEntry(HdfTestMsg *msg); + +#endif /* HDF_PIN_ENTRY_TEST_H */ \ No newline at end of file diff --git a/test/unittest/platform/hdf_pwm_entry_test.c b/test/unittest/platform/entry/hdf_pwm_entry_test.c similarity index 82% rename from test/unittest/platform/hdf_pwm_entry_test.c rename to test/unittest/platform/entry/hdf_pwm_entry_test.c index bb274ea2415f24b3e9616df4f1de9d9922423ea5..8bb761a7cdd3d89631728758a1ffdce9f0fbefd6 100644 --- a/test/unittest/platform/hdf_pwm_entry_test.c +++ b/test/unittest/platform/entry/hdf_pwm_entry_test.c @@ -8,7 +8,6 @@ #include "hdf_pwm_entry_test.h" #include "hdf_log.h" -#include "pwm_if.h" #include "pwm_test.h" #define HDF_LOG_TAG hdf_pwm_entry_test @@ -18,13 +17,16 @@ int32_t HdfPwmUnitTestEntry(HdfTestMsg *msg) struct PwmTest *test = NULL; if (msg == NULL) { + HDF_LOGE("%s: msg is NULL!", __func__); return HDF_FAILURE; } test = GetPwmTest(); if (test == NULL || test->TestEntry == NULL) { + HDF_LOGE("%s: test or TestEntry is NULL!", __func__); msg->result = HDF_FAILURE; return HDF_FAILURE; } + HDF_LOGI("%s: call [TestEntry]", __func__); msg->result = test->TestEntry(test, msg->subCmd); return msg->result; } diff --git a/test/unittest/platform/hdf_pwm_entry_test.h b/test/unittest/platform/entry/hdf_pwm_entry_test.h similarity index 100% rename from test/unittest/platform/hdf_pwm_entry_test.h rename to test/unittest/platform/entry/hdf_pwm_entry_test.h diff --git a/test/unittest/platform/entry/hdf_regulator_entry_test.c b/test/unittest/platform/entry/hdf_regulator_entry_test.c new file mode 100755 index 0000000000000000000000000000000000000000..50c01cf27c55c1cecc04a5261659f9b5302bd6de --- /dev/null +++ b/test/unittest/platform/entry/hdf_regulator_entry_test.c @@ -0,0 +1,30 @@ +/* + * Copyright (c) 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_regulator_entry_test.h" +#include "hdf_log.h" +#include "regulator_test.h" + +#define HDF_LOG_TAG hdf_regulator_entry_test + +int32_t HdfRegulatorUnitTestEntry(HdfTestMsg *msg) +{ + struct RegulatorTest *test = NULL; + + if (msg == NULL) { + return HDF_FAILURE; + } + test = GetRegulatorTest(); + if (test == NULL || test->TestEntry == NULL) { + HDF_LOGE("%s: tester is NULL!\n", __func__); + msg->result = HDF_FAILURE; + return HDF_FAILURE; + } + msg->result = test->TestEntry(test, msg->subCmd); + return msg->result; +} diff --git a/test/unittest/platform/entry/hdf_regulator_entry_test.h b/test/unittest/platform/entry/hdf_regulator_entry_test.h new file mode 100755 index 0000000000000000000000000000000000000000..229df545325e8cdbb2d9d77efcab38e43b8bffd3 --- /dev/null +++ b/test/unittest/platform/entry/hdf_regulator_entry_test.h @@ -0,0 +1,16 @@ +/* + * Copyright (c) 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_REGULATOR_ENTRY_TEST_H +#define HDF_REGULATOR_ENTRY_TEST_H + +#include "hdf_main_test.h" + +int32_t HdfRegulatorUnitTestEntry(HdfTestMsg *msg); + +#endif /* HDF_REGULATOR_ENTRY_TEST_H */ diff --git a/test/unittest/platform/hdf_rtc_entry_test.c b/test/unittest/platform/entry/hdf_rtc_entry_test.c similarity index 100% rename from test/unittest/platform/hdf_rtc_entry_test.c rename to test/unittest/platform/entry/hdf_rtc_entry_test.c diff --git a/test/unittest/platform/hdf_rtc_entry_test.h b/test/unittest/platform/entry/hdf_rtc_entry_test.h similarity index 100% rename from test/unittest/platform/hdf_rtc_entry_test.h rename to test/unittest/platform/entry/hdf_rtc_entry_test.h diff --git a/test/unittest/platform/hdf_sdio_entry_test.c b/test/unittest/platform/entry/hdf_sdio_entry_test.c similarity index 100% rename from test/unittest/platform/hdf_sdio_entry_test.c rename to test/unittest/platform/entry/hdf_sdio_entry_test.c diff --git a/test/unittest/platform/hdf_sdio_entry_test.h b/test/unittest/platform/entry/hdf_sdio_entry_test.h similarity index 100% rename from test/unittest/platform/hdf_sdio_entry_test.h rename to test/unittest/platform/entry/hdf_sdio_entry_test.h diff --git a/test/unittest/platform/hdf_spi_entry_test.c b/test/unittest/platform/entry/hdf_spi_entry_test.c similarity index 100% rename from test/unittest/platform/hdf_spi_entry_test.c rename to test/unittest/platform/entry/hdf_spi_entry_test.c diff --git a/test/unittest/platform/hdf_spi_entry_test.h b/test/unittest/platform/entry/hdf_spi_entry_test.h similarity index 100% rename from test/unittest/platform/hdf_spi_entry_test.h rename to test/unittest/platform/entry/hdf_spi_entry_test.h diff --git a/test/unittest/platform/hdf_uart_entry_test.c b/test/unittest/platform/entry/hdf_uart_entry_test.c similarity index 100% rename from test/unittest/platform/hdf_uart_entry_test.c rename to test/unittest/platform/entry/hdf_uart_entry_test.c diff --git a/test/unittest/platform/hdf_uart_entry_test.h b/test/unittest/platform/entry/hdf_uart_entry_test.h similarity index 100% rename from test/unittest/platform/hdf_uart_entry_test.h rename to test/unittest/platform/entry/hdf_uart_entry_test.h diff --git a/test/unittest/platform/hdf_watchdog_entry_test.c b/test/unittest/platform/entry/hdf_watchdog_entry_test.c similarity index 100% rename from test/unittest/platform/hdf_watchdog_entry_test.c rename to test/unittest/platform/entry/hdf_watchdog_entry_test.c diff --git a/test/unittest/platform/hdf_watchdog_entry_test.h b/test/unittest/platform/entry/hdf_watchdog_entry_test.h similarity index 100% rename from test/unittest/platform/hdf_watchdog_entry_test.h rename to test/unittest/platform/entry/hdf_watchdog_entry_test.h diff --git a/test/unittest/platform/virtual/dac_virtual.c b/test/unittest/platform/virtual/dac_virtual.c new file mode 100644 index 0000000000000000000000000000000000000000..b8314ed27d2439f6c3bbea27315a35dd8f380bf1 --- /dev/null +++ b/test/unittest/platform/virtual/dac_virtual.c @@ -0,0 +1,195 @@ +/* + * Copyright (c) 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 "dac/dac_core.h" +#include "asm/platform.h" +#include "device_resource_if.h" +#include "hdf_device_desc.h" +#include "hdf_log.h" +#include "los_hwi.h" +#include "osal_io.h" +#include "osal_mem.h" +#include "osal_time.h" + +#define HDF_LOG_TAG dac_virtual + +struct VirtualDacDevice { + struct DacDevice device; + uint32_t deviceNum; + uint32_t validChannel; + uint32_t rate; +}; + +static int32_t VirtualDacWrite(struct DacDevice *device, uint32_t channel, uint32_t val) +{ + (void)device; + (void)channel; + (void)val; + HDF_LOGI("%s: done!", __func__); + + return HDF_SUCCESS; +} + +static inline int32_t VirtualDacStart(struct DacDevice *device) +{ + (void)device; + HDF_LOGI("%s: done!", __func__); + return HDF_SUCCESS; +} + +static inline int32_t VirtualDacStop(struct DacDevice *device) +{ + (void)device; + HDF_LOGI("%s: done!", __func__); + return HDF_SUCCESS; +} + +static inline void VirtualDacDeviceInit(struct VirtualDacDevice *virtual) +{ + HDF_LOGI("%s: device:%u init done!", __func__, virtual->deviceNum); +} + +static const struct DacMethod g_method = { + .write = VirtualDacWrite, + .stop = VirtualDacStop, + .start = VirtualDacStart, +}; + +static int32_t VirtualDacReadDrs(struct VirtualDacDevice *virtual, const struct DeviceResourceNode *node) +{ + struct DeviceResourceIface *drsOps = NULL; + + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetUint32 == NULL || drsOps->GetUint16 == NULL) { + HDF_LOGE("%s: Invalid drs ops fail!", __func__); + return HDF_FAILURE; + } + if (drsOps->GetUint32(node, "deviceNum", &virtual->deviceNum, 0) != HDF_SUCCESS) { + HDF_LOGE("%s: Read deviceNum fail!", __func__); + return HDF_ERR_IO; + } + if (drsOps->GetUint32(node, "validChannel", &virtual->validChannel, 0) != HDF_SUCCESS) { + HDF_LOGE("%s: Read validChannel fail!", __func__); + return HDF_ERR_IO; + } + if (drsOps->GetUint32(node, "rate", &virtual->rate, 0) != HDF_SUCCESS) { + HDF_LOGE("%s: Read rate fail!", __func__); + return HDF_ERR_IO; + } + return HDF_SUCCESS; +} + +static int32_t VirtualDacParseAndInit(struct HdfDeviceObject *device, const struct DeviceResourceNode *node) +{ + int32_t ret; + struct VirtualDacDevice *virtual = NULL; + (void)device; + + virtual = (struct VirtualDacDevice *)OsalMemCalloc(sizeof(*virtual)); + if (virtual == NULL) { + HDF_LOGE("%s: Malloc virtual fail!", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + ret = VirtualDacReadDrs(virtual, node); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Read drs fail! ret:%d", __func__, ret); + goto __ERR__; + } + + VirtualDacDeviceInit(virtual); + virtual->device.priv = (void *)node; + virtual->device.devNum = virtual->deviceNum; + virtual->device.ops = &g_method; + ret = DacDeviceAdd(&virtual->device); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: add Dac controller failed! ret = %d", __func__, ret); + goto __ERR__; + } + + return HDF_SUCCESS; +__ERR__: + if (virtual != NULL) { + OsalMemFree(virtual); + virtual = NULL; + } + + return ret; +} + +static int32_t VirtualDacInit(struct HdfDeviceObject *device) +{ + int32_t ret; + const struct DeviceResourceNode *childNode = NULL; + + if (device == NULL || device->property == NULL) { + HDF_LOGE("%s: device or property is NULL", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + ret = HDF_SUCCESS; + DEV_RES_NODE_FOR_EACH_CHILD_NODE(device->property, childNode) { + ret = VirtualDacParseAndInit(device, childNode); + if (ret != HDF_SUCCESS) { + break; + } + } + return ret; +} + +static void VirtualDacRemoveByNode(const struct DeviceResourceNode *node) +{ + int32_t ret; + int16_t devNum; + struct DacDevice *device = NULL; + struct VirtualDacDevice *virtual = NULL; + struct DeviceResourceIface *drsOps = NULL; + + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetUint32 == NULL) { + HDF_LOGE("%s: invalid drs ops fail!", __func__); + return; + } + + ret = drsOps->GetUint16(node, "devNum", (uint16_t *)&devNum, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read devNum fail!", __func__); + return; + } + + device = DacDeviceGet(devNum); + if (device != NULL && device->priv == node) { + DacDevicePut(device); + DacDeviceRemove(device); + virtual = (struct VirtualDacDevice *)device; + OsalMemFree(virtual); + } + return; +} + +static void VirtualDacRelease(struct HdfDeviceObject *device) +{ + const struct DeviceResourceNode *childNode = NULL; + + if (device == NULL || device->property == NULL) { + HDF_LOGE("%s: device or property is NULL", __func__); + return; + } + + DEV_RES_NODE_FOR_EACH_CHILD_NODE(device->property, childNode) { + VirtualDacRemoveByNode(childNode); + } +} + +struct HdfDriverEntry g_dacDriverEntry = { + .moduleVersion = 1, + .Init = VirtualDacInit, + .Release = VirtualDacRelease, + .moduleName = "virtual_dac_driver", +}; +HDF_INIT(g_dacDriverEntry); diff --git a/test/unittest/platform/virtual/i3c_virtual.c b/test/unittest/platform/virtual/i3c_virtual.c new file mode 100644 index 0000000000000000000000000000000000000000..28616e419486680b17355971c23a3d31c0f174e2 --- /dev/null +++ b/test/unittest/platform/virtual/i3c_virtual.c @@ -0,0 +1,453 @@ +/* + * Copyright (c) 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 "i3c/i3c_core.h" +#include "device_resource_if.h" +#include "osal_mem.h" +#include "osal_time.h" + +#define HDF_LOG_TAG i3c_virtual + +#define VIRTUAL_I3C_DELAY 50 +#define VIRTUAL_I3C_HOT_JOIN_TEST_ADDR 0x3f + +#define VIRTUAL_I3C_TEST_STR_LEN 11 +#define VIRTUAL_I3C_TEST_STR "Hello I3C!" + +struct VirtualI3cCntlr { + struct I3cCntlr cntlr; + OsalSpinlock spin; + uint16_t busId; + uint16_t busMode; + uint16_t IrqNum; + uint32_t i3cMaxRate; + uint32_t i3cRate; + uint32_t i2cFmRate; + uint32_t i2cFmPlusRate; +}; + +struct VirtualI3cTransferData { + struct I3cMsg *msgs; + int16_t index; + int16_t count; +}; + +struct VirtualI3cIbiSimulator { + uint16_t ibiAddr; + uint16_t deviceAddr; +}; + +static struct VirtualI3cIbiSimulator ibiSimulator; + +static inline void VirtualI3cSetIbiSimulator(uint16_t addr, uint16_t deviceAddr) +{ + ibiSimulator.ibiAddr = addr; + ibiSimulator.deviceAddr = deviceAddr; +} + +static inline uint16_t VirtualI3cGetIbiAddr(void) +{ + return ibiSimulator.ibiAddr; +} + +static inline uint16_t VirtualI3cGetIbiDeviceAddr(void) +{ + return ibiSimulator.deviceAddr; +} + +static int32_t VirtualI3cXferI2cOneMsgPolling(const struct VirtualI3cCntlr *virtual, + const struct VirtualI3cTransferData *td) +{ + struct I3cMsg *msg = &td->msgs[td->index]; + + (void)virtual; + (void)msg; + PLAT_LOGV("%s: msg:%p, addr:%x, flags:0x%x, len=%d", __func__, msg, msg->addr, msg->flags, msg->len); + + return HDF_SUCCESS; +} + +static inline void VirtualI3cCntlrInit(struct VirtualI3cCntlr *virtual) +{ + HDF_LOGI("%s: cntlr:%u init done!", __func__, virtual->busId); +} + +static int32_t VirtualSendCccCmd(struct I3cCntlr *cntlr, struct I3cCccCmd *ccc) +{ + (void)cntlr; + HDF_LOGI("%s: Enter, destination: %x", __func__, ccc->dest); + + return HDF_SUCCESS; +} + +static int32_t VirtualI3cTransfer(struct I3cCntlr *cntlr, struct I3cMsg *msgs, int16_t count) +{ + struct VirtualI3cCntlr *virtual = NULL; + + (void)cntlr; + (void)msgs; + if (cntlr == NULL || cntlr->priv == NULL) { + HDF_LOGE("%s: cntlr or virtual is null!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + virtual = (struct VirtualI3cCntlr *)cntlr; + + if (msgs == NULL || count <= 0) { + HDF_LOGE("%s: err params! count:%d", __func__, count); + return HDF_ERR_INVALID_PARAM; + } + + return count; +} + +static int32_t VirtualI3cCntlrI2cTransfer(struct I3cCntlr *cntlr, struct I3cMsg *msgs, int16_t count) +{ + int32_t ret; + unsigned long irqSave; + struct VirtualI3cCntlr *virtual = NULL; + struct VirtualI3cTransferData td; + + if (cntlr == NULL || cntlr->priv == NULL) { + HDF_LOGE("%s: cntlr or virtual is null!", __func__); + return HDF_ERR_INVALID_OBJECT; + } + virtual = (struct VirtualI3cCntlr *)cntlr; + + if (msgs == NULL || count <= 0) { + HDF_LOGE("%s: err params! count:%d", __func__, count); + return HDF_ERR_INVALID_PARAM; + } + td.msgs = msgs; + td.count = count; + td.index = 0; + + irqSave = LOS_IntLock(); + while (td.index < td.count) { + ret = VirtualI3cXferI2cOneMsgPolling(virtual, &td); + if (ret != 0) { + break; + } + td.index++; + } + LOS_IntRestore(irqSave); + return (td.index > 0) ? td.index : ret; +} + +int32_t VirtualI3cSetConfig(struct I3cCntlr *cntlr, struct I3cConfig *config) +{ + (void)cntlr; + (void)config; + HDF_LOGI("%s: done!", __func__); + return HDF_SUCCESS; +} + +int32_t VirtualI3cGetConfig(struct I3cCntlr *cntlr, struct I3cConfig *config) +{ + (void)cntlr; + (void)config; + HDF_LOGI("%s: done!", __func__); + return HDF_SUCCESS; +} + +int32_t VirtualI3cRequestIbi(struct I3cDevice *dev) +{ + (void)dev; + HDF_LOGI("%s: done!", __func__); + + return HDF_SUCCESS; +} + +static void VirtualI3cFreeIbi(struct I3cDevice *dev) +{ + (void)dev; + HDF_LOGI("%s: done!", __func__); +} + +static const struct I3cMethod g_method = { + .sendCccCmd = VirtualSendCccCmd, + .i2cTransfer = VirtualI3cCntlrI2cTransfer, + .Transfer = VirtualI3cTransfer, + .setConfig = VirtualI3cSetConfig, + .getConfig = VirtualI3cGetConfig, + .requestIbi = VirtualI3cRequestIbi, + .freeIbi = VirtualI3cFreeIbi, +}; + +static void VirtualI3cHotJoin(struct VirtualI3cCntlr *virtual) +{ + uint16_t deviceAddr; + struct I3cDevice *device = NULL; + int32_t ret; + + deviceAddr = VirtualI3cGetIbiDeviceAddr(); + device = (struct I3cDevice *)OsalMemCalloc(sizeof(*device)); + if (device == NULL) { + HDF_LOGE("func:%s device is NULL!", __func__); + return; + } + device->cntlr = &virtual->cntlr; + device->addr = deviceAddr; + device->type = I3C_CNTLR_I3C_DEVICE; + device->supportIbi = I3C_DEVICE_SUPPORT_IBI; + ret = I3cDeviceAdd(device); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Add device failed!", __func__); + return; + } + HDF_LOGI("%s: done!", __func__); +} + +static int32_t VirtualI3cReservedAddrWorker(struct VirtualI3cCntlr *virtual, uint16_t addr) +{ + (void)virtual; + switch (addr) { + case I3C_HOT_JOIN_ADDR: + VirtualI3cHotJoin(virtual); + break; + case I3C_RESERVED_ADDR_7H3E: + case I3C_RESERVED_ADDR_7H5E: + case I3C_RESERVED_ADDR_7H6E: + case I3C_RESERVED_ADDR_7H76: + case I3C_RESERVED_ADDR_7H7A: + case I3C_RESERVED_ADDR_7H7C: + case I3C_RESERVED_ADDR_7H7F: + /* All cases of broadcast address single bit error detect */ + HDF_LOGW("%s: broadcast Address single bit error!", __func__); + break; + default: + HDF_LOGD("%s: Reserved address which is not supported!", __func__); + break; + } + + return HDF_SUCCESS; +} + +static int32_t I3cIbiHandle(uint32_t irq, void *data) +{ + struct VirtualI3cCntlr *virtual = NULL; + struct I3cDevice *device = NULL; + uint16_t ibiAddr; + char *testStr = VIRTUAL_I3C_TEST_STR; + + (void)irq; + if (data == NULL) { + HDF_LOGW("%s: data is NULL!", __func__); + return HDF_ERR_INVALID_PARAM; + } + virtual = (struct VirtualI3cCntlr *)data; + ibiAddr = VirtualI3cGetIbiAddr(); + if (CHECK_RESERVED_ADDR(ibiAddr) == I3C_ADDR_RESERVED) { + HDF_LOGD("%s: Calling VirtualI3cResAddrWorker...", __func__); + return VirtualI3cReservedAddrWorker(virtual, ibiAddr); + } else { + HDF_LOGD("%s: Calling I3cCntlrIbiCallback...", __func__); + device = GetDeviceByAddr(&virtual->cntlr, ibiAddr); + if (device == NULL) { + HDF_LOGE("func:%s device is NULL!", __func__); + return HDF_ERR_MALLOC_FAIL; + } + if (device->ibi->payload > VIRTUAL_I3C_TEST_STR_LEN) { + /* Put the string "Hello I3C!" into IBI buffer */ + *device->ibi->data = *testStr; + } + return I3cCntlrIbiCallback(device); + } + + return HDF_SUCCESS; +} + +/* Soft calling is used here to simulate in-band interrupt */ +static inline void SoftInterruptTrigger(struct VirtualI3cCntlr *virtual, uint16_t ibiDeviceAddr) +{ + VirtualI3cSetIbiSimulator(I3C_HOT_JOIN_ADDR, ibiDeviceAddr); + HDF_LOGE("%s: IrqNum: %d", __func__, virtual->IrqNum); + + /* Simulate soft interrupt through direct call */ + if (I3cIbiHandle(virtual->IrqNum, (void *)virtual) != HDF_SUCCESS) { + HDF_LOGE("%s: Call I3cIbiHandle failed!", __func__); + } +} + +static int32_t VirtualI3cHotJoinSimulator(void) +{ + uint16_t busId; + struct I3cCntlr *cntlr = NULL; + struct VirtualI3cCntlr *virtual = NULL; + + for (busId = 0; busId < I3C_CNTLR_MAX; busId++) { + cntlr = I3cCntlrGet(busId); + if (cntlr == NULL) { + continue; + } + + virtual = (struct VirtualI3cCntlr *)cntlr; + OsalMDelay(VIRTUAL_I3C_DELAY); + SoftInterruptTrigger(virtual, VIRTUAL_I3C_HOT_JOIN_TEST_ADDR); + } + + return HDF_SUCCESS; +} + +static int32_t VirtualI3cReadDrs(struct VirtualI3cCntlr *virtual, const struct DeviceResourceNode *node) +{ + struct DeviceResourceIface *drsOps = NULL; + + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetUint32 == NULL || drsOps->GetUint16 == NULL) { + HDF_LOGE("%s: Invalid drs ops fail!", __func__); + return HDF_FAILURE; + } + if (drsOps->GetUint16(node, "busId", &virtual->busId, 0) != HDF_SUCCESS) { + HDF_LOGE("%s: Read busId fail!", __func__); + return HDF_ERR_IO; + } + if (drsOps->GetUint16(node, "busMode", &virtual->busMode, 0) != HDF_SUCCESS) { + HDF_LOGE("%s: Read busMode fail!", __func__); + return HDF_ERR_IO; + } + if (drsOps->GetUint16(node, "IrqNum", &virtual->IrqNum, 0) != HDF_SUCCESS) { + HDF_LOGE("%s: Read IrqNum fail!", __func__); + return HDF_ERR_IO; + } + if (drsOps->GetUint32(node, "i3cMaxRate", &virtual->i3cMaxRate, 0) != HDF_SUCCESS) { + HDF_LOGE("%s: Read i3cMaxRate fail!", __func__); + return HDF_ERR_IO; + } + if (drsOps->GetUint32(node, "i3cRate", &virtual->i3cRate, 0) != HDF_SUCCESS) { + HDF_LOGE("%s: Read i3cRate fail!", __func__); + return HDF_ERR_IO; + } + if (drsOps->GetUint32(node, "i2cFmRate", &virtual->i2cFmRate, 0) != HDF_SUCCESS) { + HDF_LOGE("%s: Read i2cFmRate fail!", __func__); + return HDF_ERR_IO; + } + if (drsOps->GetUint32(node, "i2cFmPlusRate", &virtual->i2cFmPlusRate, 0) != HDF_SUCCESS) { + HDF_LOGE("%s: Read i2cFmPlusRate fail!", __func__); + return HDF_ERR_IO; + } + + return HDF_SUCCESS; +} + +static int32_t VirtualI3cParseAndInit(struct HdfDeviceObject *device, const struct DeviceResourceNode *node) +{ + int32_t ret; + struct VirtualI3cCntlr *virtual = NULL; + (void)device; + + virtual = (struct VirtualI3cCntlr *)OsalMemCalloc(sizeof(*virtual)); + if (virtual == NULL) { + HDF_LOGE("%s: Malloc virtual fail!", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + ret = VirtualI3cReadDrs(virtual, node); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: Read drs fail! ret:%d", __func__, ret); + goto __ERR__; + } + + VirtualI3cCntlrInit(virtual); + virtual->cntlr.priv = (void *)node; + virtual->cntlr.busId = virtual->busId; + virtual->cntlr.ops = &g_method; + (void)OsalSpinInit(&virtual->spin); + ret = I3cCntlrAdd(&virtual->cntlr); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: add i3c controller failed! ret = %d", __func__, ret); + (void)OsalSpinDestroy(&virtual->spin); + goto __ERR__; + } + + return HDF_SUCCESS; +__ERR__: + if (virtual != NULL) { + OsalMemFree(virtual); + virtual = NULL; + } + + return ret; +} + +static int32_t VirtualI3cInit(struct HdfDeviceObject *device) +{ + int32_t ret; + const struct DeviceResourceNode *childNode = NULL; + + HDF_LOGE("%s: Enter", __func__); + if (device == NULL || device->property == NULL) { + HDF_LOGE("%s: device or property is NULL", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + ret = HDF_SUCCESS; + DEV_RES_NODE_FOR_EACH_CHILD_NODE(device->property, childNode) { + ret = VirtualI3cParseAndInit(device, childNode); + if (ret != HDF_SUCCESS) { + break; + } + } + ret = VirtualI3cHotJoinSimulator(); + + return ret; +} + +static void VirtualI3cRemoveByNode(const struct DeviceResourceNode *node) +{ + int32_t ret; + int16_t busId; + struct I3cCntlr *cntlr = NULL; + struct VirtualI3cCntlr *virtual = NULL; + struct DeviceResourceIface *drsOps = NULL; + + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetUint32 == NULL) { + HDF_LOGE("%s: invalid drs ops fail!", __func__); + return; + } + + ret = drsOps->GetUint16(node, "busId", (uint16_t *)&busId, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read busId fail!", __func__); + return; + } + + cntlr = I3cCntlrGet(busId); + if (cntlr != NULL && cntlr->priv == node) { + I3cCntlrPut(cntlr); + I3cCntlrRemove(cntlr); + virtual = (struct VirtualI3cCntlr *)cntlr; + (void)OsalSpinDestroy(&virtual->spin); + OsalMemFree(virtual); + } + return; +} + +static void VirtualI3cRelease(struct HdfDeviceObject *device) +{ + const struct DeviceResourceNode *childNode = NULL; + + HDF_LOGI("%s: enter", __func__); + + if (device == NULL || device->property == NULL) { + HDF_LOGE("%s: device or property is NULL", __func__); + return; + } + + DEV_RES_NODE_FOR_EACH_CHILD_NODE(device->property, childNode) { + VirtualI3cRemoveByNode(childNode); + } +} + +struct HdfDriverEntry g_i3cDriverEntry = { + .moduleVersion = 1, + .Init = VirtualI3cInit, + .Release = VirtualI3cRelease, + .moduleName = "virtual_i3c_driver", +}; +HDF_INIT(g_i3cDriverEntry); diff --git a/test/unittest/platform/virtual/regulator_linux_current_virtual_driver.c b/test/unittest/platform/virtual/regulator_linux_current_virtual_driver.c new file mode 100755 index 0000000000000000000000000000000000000000..dd669efbeee29380fc6270df12963c29fee97417 --- /dev/null +++ b/test/unittest/platform/virtual/regulator_linux_current_virtual_driver.c @@ -0,0 +1,217 @@ +/* + * Copyright (c) 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include "hdf_log.h" +#include "hdf_base.h" + +#define HDF_LOG_TAG regulator_virtual_current + +struct VirtualCurrentRegulatorDev { + struct regmap *regmap; + struct regulator_dev *dev; +}; + +// note:linux kernel constraints:len(devName) + len(supplyName) < REG_STR_SIZE(64) +static struct regulator_consumer_supply g_virtualCurrentRegulatorSupplies[] = { + REGULATOR_SUPPLY("vir-current-reg-hdf-adp", "regulator_adapter_consumer01"), +}; + +// virtual regulator init info +static struct regulator_init_data g_virtualCurrentRegulatorInitData = { + .constraints = { + .name = "virtual_current_regulator", + .min_uA = 1000, + .max_uA = 50000, + .valid_ops_mask = REGULATOR_CHANGE_CURRENT | + REGULATOR_CHANGE_STATUS, + }, + .num_consumer_supplies = ARRAY_SIZE(g_virtualCurrentRegulatorSupplies), + .consumer_supplies = g_virtualCurrentRegulatorSupplies, +}; + +static void VirtualCurrentRegulatorDevRelease(struct device *dev) +{ +} + +static struct platform_device g_virtualCurrentRegulatorPlatformDevice = { + .name = "virtual_current_regulator_dev", + .id = -1, + .dev = { + .release = VirtualCurrentRegulatorDevRelease, + } +}; + +enum RegulatorStatus { + VIR_REGULATOR_STATUS_OFF, + VIR_REGULATOR_STATUS_ON, +}; + +static int g_virStatus = VIR_REGULATOR_STATUS_OFF; +static int VirtualCurrentRegulatorEnable(struct regulator_dev *rdev) +{ + if (rdev == NULL) { + HDF_LOGE("%s: rdev NULL", __func__); + return HDF_FAILURE; + } + + g_virStatus = VIR_REGULATOR_STATUS_ON; + return HDF_SUCCESS; +} + +static int VirtualCurrentRegulatorDisable(struct regulator_dev *rdev) +{ + if (rdev == NULL) { + HDF_LOGE("%s: rdev NULL", __func__); + return HDF_FAILURE; + } + + g_virStatus = VIR_REGULATOR_STATUS_OFF; + return HDF_SUCCESS; +} + +static int VirtualCurrentRegulatorIsEnabled(struct regulator_dev *rdev) +{ + if (rdev == NULL) { + HDF_LOGE("%s: rdev NULL", __func__); + return HDF_FAILURE; + } + + return g_virStatus; +} + +static int VirtualCurrentRegulatorSetCurrent(struct regulator_dev *rdev, int min_uA, + int max_uA) +{ + if ((rdev == NULL) || (rdev->constraints == NULL)) { + HDF_LOGE("%s: rdev NULL", __func__); + return HDF_FAILURE; + } + + struct regulation_constraints *regu_constraints = rdev->constraints; + if (regu_constraints->min_uA == min_uA && + regu_constraints->max_uA == max_uA) { + return HDF_SUCCESS; + } + + return HDF_SUCCESS; +} + +#define VIRTUAL_CURRENT_VAL_500 500 +static int VirtualCurrentRegulatorGetCurrent(struct regulator_dev *rdev) +{ + if (rdev == NULL) { + HDF_LOGE("%s: rdev NULL", __func__); + return HDF_FAILURE; + } + + return VIRTUAL_CURRENT_VAL_500; +} + +static struct regulator_ops g_virtualCurrentRegulatorOps = { + .enable = VirtualCurrentRegulatorEnable, + .disable = VirtualCurrentRegulatorDisable, + .is_enabled = VirtualCurrentRegulatorIsEnabled, + .set_current_limit = VirtualCurrentRegulatorSetCurrent, + .get_current_limit = VirtualCurrentRegulatorGetCurrent, +}; + +static struct regulator_desc g_virtualCurrentRegulatorDesc = { + .name = "regulator_virtual_current", + .type = REGULATOR_CURRENT, + .ops = &g_virtualCurrentRegulatorOps, + .owner = THIS_MODULE, +}; + +static int VirtualCurrentRegulatorPlatformProbe(struct platform_device *platform_dev) +{ + if (platform_dev == NULL) { + HDF_LOGE("%s: platform_dev null!", __func__); + return HDF_FAILURE; + } + struct VirtualCurrentRegulatorDev *data; + struct regulator_config config; + + memset(&config, 0, sizeof(struct regulator_config)); + + data = devm_kzalloc(&platform_dev->dev, sizeof(*data), GFP_KERNEL); + if (!data) { + HDF_LOGE("%s: devm_kzalloc error!", __func__); + return -ENOMEM; + } + config.dev = &platform_dev->dev; + config.init_data = &g_virtualCurrentRegulatorInitData; + config.driver_data = data; + + data->dev = regulator_register(&g_virtualCurrentRegulatorDesc, &config); + if (IS_ERR(data->dev)) { + HDF_LOGE("%s: failed to register regulator %s\n", __func__, g_virtualCurrentRegulatorDesc.name); + return PTR_ERR(data->dev); + } + + platform_set_drvdata(platform_dev, data); + HDF_LOGI("%s: success", __func__); + return 0; +} + +static int VirtualCurrentRegulatorPlatformRemove(struct platform_device *platform_dev) +{ + struct VirtualCurrentRegulatorDev *rdev = platform_get_drvdata(platform_dev); + + regulator_unregister(rdev->dev); + + platform_set_drvdata(platform_dev, NULL); + HDF_LOGI("%s: success", __func__); + return 0; +} + +static struct platform_driver g_virtualCurrentRegulatorPlatformDriver = { + .driver = { + .name = "virtual_current_regulator_dev", + .owner = THIS_MODULE, + }, + .probe = VirtualCurrentRegulatorPlatformProbe, + .remove = VirtualCurrentRegulatorPlatformRemove, +}; + +int VirtualCurrentRegulatorAdapterInit(void) +{ + int ret = platform_device_register(&g_virtualCurrentRegulatorPlatformDevice); + if(ret == 0) { + ret = platform_driver_register(&g_virtualCurrentRegulatorPlatformDriver); + } else { + HDF_LOGE("%s:device register fail %d", __func__, ret); + } + return ret; +} + +static int __init VirtualCurrentRegulatorInit(void) +{ + int ret = platform_device_register(&g_virtualCurrentRegulatorPlatformDevice); + if(ret == 0) { + ret = platform_driver_register(&g_virtualCurrentRegulatorPlatformDriver); + } + return ret; +} + +static void __exit VirtualCurrentRegulatorExit(void) +{ + platform_device_unregister(&g_virtualCurrentRegulatorPlatformDevice); + platform_driver_unregister(&g_virtualCurrentRegulatorPlatformDriver); +} + +MODULE_DESCRIPTION("Virtual current Regulator Controller Platform Device Drivers"); +MODULE_LICENSE("GPL"); diff --git a/test/unittest/platform/virtual/regulator_linux_current_virtual_driver.h b/test/unittest/platform/virtual/regulator_linux_current_virtual_driver.h new file mode 100755 index 0000000000000000000000000000000000000000..5ee1ef550550bb20b39d98ce85698827e2212167 --- /dev/null +++ b/test/unittest/platform/virtual/regulator_linux_current_virtual_driver.h @@ -0,0 +1,15 @@ +/* + * Copyright (c) 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 REGULATOR_LINUX_CURRENT_VIRTUAL_DRIVER_H +#define REGULATOR_LINUX_CURRENT_VIRTUAL_DRIVER_H +#include "hdf_base.h" + +int VirtualCurrentRegulatorAdapterInit(void); + +#endif /* REGULATOR_LINUX_CURRENT_VIRTUAL_DRIVER_H */ diff --git a/test/unittest/platform/virtual/regulator_linux_voltage_virtual_driver.c b/test/unittest/platform/virtual/regulator_linux_voltage_virtual_driver.c new file mode 100755 index 0000000000000000000000000000000000000000..198942208de5c94043a6efc4bed2af11a3f2e88b --- /dev/null +++ b/test/unittest/platform/virtual/regulator_linux_voltage_virtual_driver.c @@ -0,0 +1,221 @@ +/* + * Copyright (c) 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include "hdf_log.h" +#include "hdf_base.h" + +#define HDF_LOG_TAG regulator_virtual + +struct VirtualVoltageRegulatorDev { + struct regmap *regmap; + struct regulator_dev *dev; +}; + +// note:linux kernel constraints:len(devName) + len(supplyName) < REG_STR_SIZE(64) +static struct regulator_consumer_supply g_virtualVoltageRegulatorVoltSupplies[] = { + REGULATOR_SUPPLY("vir-voltage-reg-hdf-adp", "regulator_adapter_consumer01"), +}; + +// virtual regulator init info +static struct regulator_init_data g_virtualVoltageRegulatorInitData = { + .constraints = { + .name = "virtual_regulator", + .min_uV = 1000, + .max_uV = 50000, + .always_on = 1, + .valid_ops_mask = REGULATOR_CHANGE_VOLTAGE | + REGULATOR_CHANGE_STATUS, + }, + .num_consumer_supplies = ARRAY_SIZE(g_virtualVoltageRegulatorVoltSupplies), + .consumer_supplies = g_virtualVoltageRegulatorVoltSupplies, +}; + +static void VirtualVoltageRegulatorDevRelease(struct device *dev) +{ +} +static struct platform_device g_virtualVoltageRegulatorPlatformDevice = { + .name = "virtual_regulator_dev", + .id = -1, + .dev = { + .release = VirtualVoltageRegulatorDevRelease, + } +}; + +enum RegulatorStatus { + VIR_REGULATOR_STATUS_OFF, + VIR_REGULATOR_STATUS_ON, +}; + +static int g_virStatus = VIR_REGULATOR_STATUS_OFF; +static int VirtualVoltageRegulatorEnable(struct regulator_dev *rdev) +{ + if (rdev == NULL) { + HDF_LOGE("%s: rdev NULL", __func__); + return HDF_FAILURE; + } + + g_virStatus = VIR_REGULATOR_STATUS_ON; + return HDF_SUCCESS; +} + +static int VirtualVoltageRegulatorDisable(struct regulator_dev *rdev) +{ + if (rdev == NULL) { + HDF_LOGE("%s: rdev NULL", __func__); + return HDF_FAILURE; + } + + g_virStatus = VIR_REGULATOR_STATUS_OFF; + return HDF_SUCCESS; +} + +static int VirtualVoltageRegulatorIsEnabled(struct regulator_dev *rdev) +{ + if (rdev == NULL) { + HDF_LOGE("%s: rdev NULL", __func__); + return HDF_FAILURE; + } + + return g_virStatus; +} + +static int VirtualVoltageRegulatorSetVoltage(struct regulator_dev *rdev, int min_uV, + int max_uV, unsigned *selector) +{ + if ((rdev == NULL) || (rdev->constraints == NULL)) { + HDF_LOGE("%s: rdev NULL", __func__); + return HDF_FAILURE; + } + + struct regulation_constraints *regu_constraints = rdev->constraints; + if (regu_constraints->min_uV == min_uV && + regu_constraints->max_uV == max_uV) { + return HDF_SUCCESS; + } + + return HDF_SUCCESS; +} + +#define VIRTUAL_VOLTAGE_VAL_500 500 +static int VirtualVoltageRegulatorGetVoltage(struct regulator_dev *rdev) +{ + if (rdev == NULL) { + HDF_LOGE("%s: rdev NULL", __func__); + return HDF_FAILURE; + } + + return VIRTUAL_VOLTAGE_VAL_500; +} + +static struct regulator_ops g_virtualVoltageRegulatorOps = { + .enable = VirtualVoltageRegulatorEnable, + .disable = VirtualVoltageRegulatorDisable, + .is_enabled = VirtualVoltageRegulatorIsEnabled, + .set_voltage = VirtualVoltageRegulatorSetVoltage, + .get_voltage = VirtualVoltageRegulatorGetVoltage, +}; + +static struct regulator_desc g_virtualVoltageRegulatorDesc = { + .name = "regulator_virtual", + .type = REGULATOR_VOLTAGE, + .ops = &g_virtualVoltageRegulatorOps, + .min_uV = 1000, + .owner = THIS_MODULE, +}; + +static int VirtualVoltageRegulatorPlatformProbe(struct platform_device *platform_dev) +{ + if (platform_dev == NULL) { + HDF_LOGE("%s: platform_dev null!", __func__); + return HDF_FAILURE; + } + struct VirtualVoltageRegulatorDev *data; + struct regulator_config config; + + memset(&config, 0, sizeof(struct regulator_config)); + + data = devm_kzalloc(&platform_dev->dev, sizeof(*data), GFP_KERNEL); + if (!data) { + return -ENOMEM; + } + + config.dev = &platform_dev->dev; + config.init_data = &g_virtualVoltageRegulatorInitData; + config.driver_data = data; + + data->dev = regulator_register(&g_virtualVoltageRegulatorDesc, &config); + if (IS_ERR(data->dev)) { + HDF_LOGE("%s: failed to register regulator %s\n", __func__, g_virtualVoltageRegulatorDesc.name); + return PTR_ERR(data->dev); + } + + platform_set_drvdata(platform_dev, data); + HDF_LOGI("%s: success", __func__); + return 0; +} + +static int VirtualVoltageRegulatorPlatformRemove(struct platform_device *platform_dev) +{ + struct VirtualVoltageRegulatorDev *rdev = platform_get_drvdata(platform_dev); + + regulator_unregister(rdev->dev); + + platform_set_drvdata(platform_dev, NULL); + HDF_LOGI("VirtualVoltageRegulatorPlatformRemove"); + return 0; +} + +static struct platform_driver g_virtualVoltageRegulatorPlatformDriver = { + .driver = { + .name = "virtual_regulator_dev", + .owner = THIS_MODULE, + }, + .probe = VirtualVoltageRegulatorPlatformProbe, + .remove = VirtualVoltageRegulatorPlatformRemove, +}; + +int VirtualVoltageRegulatorAdapterInit(void) +{ + HDF_LOGI("VirtualVoltageRegulatorAdapterInit"); + int ret = platform_device_register(&g_virtualVoltageRegulatorPlatformDevice); + if(ret == 0) { + ret = platform_driver_register(&g_virtualVoltageRegulatorPlatformDriver); + } else { + HDF_LOGE("VirtualVoltageRegulatorAdapterInit:device register fail %d", ret); + } + return ret; +} + +static int __init VirtualVoltageRegulatorInit(void) +{ + HDF_LOGI("VirtualVoltageRegulatorInit"); + int ret = platform_device_register(&g_virtualVoltageRegulatorPlatformDevice); + if(ret == 0) { + ret = platform_driver_register(&g_virtualVoltageRegulatorPlatformDriver); + } + return ret; +} + +static void __exit VirtualVoltageRegulatorExit(void) +{ + HDF_LOGI("VirtualVoltageRegulatorExit"); + platform_device_unregister(&g_virtualVoltageRegulatorPlatformDevice); + platform_driver_unregister(&g_virtualVoltageRegulatorPlatformDriver); +} + +MODULE_DESCRIPTION("Virtual voltage Regulator Controller Platform Device Drivers"); +MODULE_LICENSE("GPL"); diff --git a/test/unittest/platform/virtual/regulator_linux_voltage_virtual_driver.h b/test/unittest/platform/virtual/regulator_linux_voltage_virtual_driver.h new file mode 100755 index 0000000000000000000000000000000000000000..706f0f2c60cba40b2907751e2f41a7201c693118 --- /dev/null +++ b/test/unittest/platform/virtual/regulator_linux_voltage_virtual_driver.h @@ -0,0 +1,15 @@ +/* + * Copyright (c) 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 REGULATOR_LINUX_VOLTAGE_VIRTUAL_DRIVER_H +#define REGULATOR_LINUX_VOLTAGE_VIRTUAL_DRIVER_H +#include "hdf_base.h" + +int VirtualVoltageRegulatorAdapterInit(void); + +#endif /* REGULATOR_LINUX_VOLTAGE_VIRTUAL_DRIVER_H */ diff --git a/test/unittest/platform/virtual/regulator_virtual.c b/test/unittest/platform/virtual/regulator_virtual.c new file mode 100755 index 0000000000000000000000000000000000000000..847f0993fd1130db23f694cd00857973bbfd3cb2 --- /dev/null +++ b/test/unittest/platform/virtual/regulator_virtual.c @@ -0,0 +1,301 @@ +/* + * Copyright (c) 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. + */ + + /* hcs topology for example +dev ---+-> Regulator-1(voltage) -+-> Regulator-2(voltage) -+-> Regulator-3(voltage) -+-> Regulator-4(voltage) + | | + | | -+-> Regulator-5(voltage) -+-> Regulator-6(voltage) -+-> Regulator-7(voltage) -+-> Regulator-8(voltage) + | | + | | -+-> Regulator-9 + | + ---+-> Regulator-10(current) + | + | + ---+-> Regulator-11(current) -+-> Regulator-12(current) -+-> Regulator-14(current) + | | + | | -+-> Regulator-13(current) +*/ + +#include "device_resource_if.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "regulator/regulator_core.h" + +#define HDF_LOG_TAG regulator_virtual +#define VOLTAGE_2500_UV 2500 +#define CURRENT_2500_UA 2500 + +static int32_t VirtualRegulatorEnable(struct RegulatorNode *node) +{ + if (node == NULL) { + HDF_LOGE("VirtualRegulatorEnable node null\n"); + return HDF_ERR_INVALID_OBJECT; + } + + node->regulatorInfo.status = REGULATOR_STATUS_ON; + HDF_LOGD("VirtualRegulatorEnable %s success !\n", node->regulatorInfo.name); + return HDF_SUCCESS; +} + +int32_t VirtualRegulatorDisable(struct RegulatorNode *node) +{ + if (node == NULL) { + HDF_LOGE("VirtualRegulatorDisable node null\n"); + return HDF_ERR_INVALID_OBJECT; + } + + node->regulatorInfo.status = REGULATOR_STATUS_OFF; + HDF_LOGD("VirtualRegulatorDisable %s success !\n", node->regulatorInfo.name); + return HDF_SUCCESS; +} + +static int32_t VirtualRegulatorSetVoltage(struct RegulatorNode *node, uint32_t minUv, uint32_t maxUv) +{ + if (node == NULL) { + HDF_LOGE("VirtualRegulatorEnable node null\n"); + return HDF_ERR_INVALID_OBJECT; + } + + HDF_LOGD("VirtualRegulatorSetVoltage %s [%d, %d] success!\n", + node->regulatorInfo.name, minUv, maxUv); + return HDF_SUCCESS; +} + +static int32_t VirtualRegulatorGetVoltage(struct RegulatorNode *node, uint32_t *voltage) +{ + if (node == NULL || voltage == NULL) { + HDF_LOGE("VirtualRegulatorGetVoltage param null\n"); + return HDF_ERR_INVALID_OBJECT; + } + + *voltage = VOLTAGE_2500_UV; + HDF_LOGD("VirtualRegulatorGetVoltage get %s %d success !\n", node->regulatorInfo.name, *voltage); + return HDF_SUCCESS; +} + +static int32_t VirtualRegulatorSetCurrent(struct RegulatorNode *node, uint32_t minUa, uint32_t maxUa) +{ + if (node == NULL) { + HDF_LOGE("VirtualRegulatorSetCurrent node null\n"); + return HDF_ERR_INVALID_OBJECT; + } + + HDF_LOGD("VirtualRegulatorSetCurrent %s [%d, %d] success!\n", + node->regulatorInfo.name, minUa, maxUa); + return HDF_SUCCESS; +} + +static int32_t VirtualRegulatorGetCurrent(struct RegulatorNode *node, uint32_t *current) +{ + if (node == NULL || current == NULL) { + HDF_LOGE("VirtualRegulatorGetCurrent param null\n"); + return HDF_ERR_INVALID_OBJECT; + } + + *current = CURRENT_2500_UA; + HDF_LOGD("VirtualRegulatorGetCurrent get %s %d success !\n", node->regulatorInfo.name, *current); + return HDF_SUCCESS; +} + +static int32_t VirtualRegulatorGetStatus(struct RegulatorNode *node, uint32_t *status) +{ + if (node == NULL || status == NULL) { + HDF_LOGE("VirtualRegulatorGetStatus param null\n"); + return HDF_ERR_INVALID_OBJECT; + } + + *status = node->regulatorInfo.status; + HDF_LOGD("VirtualRegulatorGetStatus get %s %d success !\n", node->regulatorInfo.name, *status); + return HDF_SUCCESS; +} + +static struct RegulatorMethod g_method = { + .enable = VirtualRegulatorEnable, + .disable = VirtualRegulatorDisable, + .setVoltage = VirtualRegulatorSetVoltage, + .getVoltage = VirtualRegulatorGetVoltage, + .setCurrent = VirtualRegulatorSetCurrent, + .getCurrent = VirtualRegulatorGetCurrent, + .getStatus = VirtualRegulatorGetStatus, +}; + +static int32_t VirtualRegulatorContinueReadHcs(struct RegulatorNode *regNode, const struct DeviceResourceNode *node) +{ + int32_t ret; + struct DeviceResourceIface *drsOps = NULL; + + HDF_LOGD("VirtualRegulatorContinueReadHcs enter:"); + + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + HDF_LOGE("%s: invalid drs ops fail!", __func__); + return HDF_FAILURE; + } + + ret = drsOps->GetUint32(node, "minUv", ®Node->regulatorInfo.constraints.minUv, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read minUv fail!", __func__); + return HDF_FAILURE; + } + + ret = drsOps->GetUint32(node, "maxUv", ®Node->regulatorInfo.constraints.maxUv, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read maxUv fail!", __func__); + return HDF_FAILURE; + } + + ret = drsOps->GetUint32(node, "minUa", ®Node->regulatorInfo.constraints.minUa, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read minUa fail!", __func__); + return HDF_FAILURE; + } + + ret = drsOps->GetUint32(node, "maxUa", ®Node->regulatorInfo.constraints.maxUa, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read maxUa fail!", __func__); + return HDF_FAILURE; + } + + HDF_LOGD("regulatorInfo:[%s][%d][%d]--[%d][%d]--[%d][%d]!", + regNode->regulatorInfo.name, regNode->regulatorInfo.constraints.alwaysOn, + regNode->regulatorInfo.constraints.mode, + regNode->regulatorInfo.constraints.minUv, regNode->regulatorInfo.constraints.maxUv, + regNode->regulatorInfo.constraints.minUa, regNode->regulatorInfo.constraints.maxUa); + + return HDF_SUCCESS; +} + +static int32_t VirtualRegulatorReadHcs(struct RegulatorNode *regNode, const struct DeviceResourceNode *node) +{ + int32_t ret; + struct DeviceResourceIface *drsOps = NULL; + + HDF_LOGD("VirtualRegulatorReadHcs enter:"); + + drsOps = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE); + if (drsOps == NULL || drsOps->GetString == NULL) { + HDF_LOGE("%s: invalid drs ops fail!", __func__); + return HDF_FAILURE; + } + + ret = drsOps->GetString(node, "name", &(regNode->regulatorInfo.name), "ERROR"); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read name fail!", __func__); + return HDF_FAILURE; + } + if (regNode->regulatorInfo.name != NULL) { + HDF_LOGD("VirtualRegulatorReadHcs:name[%s]", regNode->regulatorInfo.name); + } else { + HDF_LOGE("VirtualRegulatorReadHcs:name NULL"); + return HDF_FAILURE; + } + + ret = drsOps->GetString(node, "parentName", &(regNode->regulatorInfo.parentName), "ERROR"); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read parentName fail!", __func__); + return HDF_FAILURE; + } + if (regNode->regulatorInfo.parentName != NULL) { + HDF_LOGD("VirtualRegulatorReadHcs:parentName[%s]", regNode->regulatorInfo.parentName); + } + + regNode->regulatorInfo.constraints.alwaysOn = drsOps->GetBool(node, "alwaysOn"); + HDF_LOGD("VirtualRegulatorReadHcs:alwaysOn[%d]", regNode->regulatorInfo.constraints.alwaysOn); + + ret = drsOps->GetUint8(node, "mode", ®Node->regulatorInfo.constraints.mode, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read mode fail!", __func__); + return HDF_FAILURE; + } + + if (VirtualRegulatorContinueReadHcs(regNode, node) != HDF_SUCCESS) { + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t VirtualRegulatorParseAndInit(struct HdfDeviceObject *device, const struct DeviceResourceNode *node) +{ + int32_t ret; + struct RegulatorNode *regNode = NULL; + (void)device; + + regNode = (struct RegulatorNode *)OsalMemCalloc(sizeof(*regNode)); + if (regNode == NULL) { + HDF_LOGE("%s: malloc node fail!", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + HDF_LOGD("VirtualRegulatorParseAndInit"); + + ret = VirtualRegulatorReadHcs(regNode, node); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: read drs fail! ret:%d", __func__, ret); + goto __ERR__; + } + + regNode->priv = (void *)node; + regNode->ops = &g_method; + + ret = RegulatorNodeAdd(regNode); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: add regulator controller fail:%d!", __func__, ret); + goto __ERR__; + } + return HDF_SUCCESS; + +__ERR__: + HDF_LOGE("%s:fail ret:%d", __func__, ret); + if (regNode != NULL) { + OsalMemFree(regNode); + regNode = NULL; + } + return ret; +} + +static int32_t VirtualRegulatorInit(struct HdfDeviceObject *device) +{ + int32_t ret; + const struct DeviceResourceNode *childNode = NULL; + + if (device == NULL || device->property == NULL) { + HDF_LOGE("%s: device or property is NULL", __func__); + return HDF_ERR_INVALID_OBJECT; + } + + DEV_RES_NODE_FOR_EACH_CHILD_NODE(device->property, childNode) { + ret = VirtualRegulatorParseAndInit(device, childNode); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s:VirtualRegulatorParseAndInit fail", __func__); + return HDF_FAILURE; + } + } + HDF_LOGI("%s: success", __func__); + return HDF_SUCCESS; +} + +static void VirtualRegulatorRelease(struct HdfDeviceObject *device) +{ + HDF_LOGI("%s: enter", __func__); + + if (device == NULL || device->property == NULL) { + HDF_LOGE("%s: device or property is NULL", __func__); + return; + } + + RegulatorNodeRemoveAll(); +} + +struct HdfDriverEntry g_regulatorDriverEntry = { + .moduleVersion = 1, + .moduleName = "virtual_regulator_driver", + .Init = VirtualRegulatorInit, + .Release = VirtualRegulatorRelease, +}; +HDF_INIT(g_regulatorDriverEntry); diff --git a/test/unittest/pm/hdf_pm_driver_test.c b/test/unittest/pm/hdf_pm_driver_test.c new file mode 100755 index 0000000000000000000000000000000000000000..f07a77600f1865548be1752370f7dfa4713ca235 --- /dev/null +++ b/test/unittest/pm/hdf_pm_driver_test.c @@ -0,0 +1,627 @@ +/* + * Copyright (c) 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 "devmgr_service.h" +#include "devsvc_manager.h" +#include "devsvc_manager_clnt.h" +#include "hdf_device_desc.h" +#include "hdf_device_node.h" +#include "hdf_log.h" +#include "hdf_pm.h" +#include "hdf_pm_driver_test.h" +#include "hdf_power_manager.h" +#include "hdf_task_queue.h" +#include "osal_time.h" +#include "power_state_token.h" + +#define HDF_LOG_TAG pm_driver_test + +#define PM_TEST_COUNT_ONE 1 +#define PM_TEST_COUNT_TWO 2 +#define PM_TEST_COUNT_TEN 10 +#define PM_TEST_COUNT_HUNDRED 100 +#define PM_TEST_COUNT_THOUSAND 1000 + +#define PM_WAIT_TIME 10 +#define PM_WAIT_TIME_OUT 100 +#define PM_WAIT_LOAD_TIME 30 + +#define CHECK_VALUE(index, cnt) \ + (pmTestType[(index)].resumeCnt == (cnt) && pmTestType[(index)].suspendCnt == (cnt)) + +#define WAIT_TEST_END(value, idx) \ + while ((value) == false && (idx) < PM_WAIT_TIME_OUT) { \ + OsalMSleep(PM_WAIT_TIME); \ + (idx)++; \ + } \ + +enum { + HDF_TEST_DRIVER, + SAMPLE_TEST_DRIVER, + PM_TEST_DRIVER, +}; + +struct PmDriverPmListener { + struct IPowerEventListener powerListener; + void *p; +}; +typedef int32_t (*TestFunc)(void); + +struct TestCaseType { + uint32_t cmd; + TestFunc testFunc; +}; +int32_t HdfPmTestBegin(void); +int32_t HdfPmTestOneDriverOnce(void); +int32_t HdfPmTestOneDriverTwice(void); +int32_t HdfPmTestOneDriverTen(void); +int32_t HdfPmTestOneDriverHundred(void); +int32_t HdfPmTestOneDriverThousand(void); +int32_t HdfPmTestTwoDriverOnce(void); +int32_t HdfPmTestTwoDriverTwice(void); +int32_t HdfPmTestTwoDriverTen(void); +int32_t HdfPmTestTwoDriverHundred(void); +int32_t HdfPmTestTwoDriverThousand(void); +int32_t HdfPmTestThreeDriverOnce(void); +int32_t HdfPmTestThreeDriverTwice(void); +int32_t HdfPmTestThreeDriverTen(void); +int32_t HdfPmTestThreeDriverHundred(void); +int32_t HdfPmTestThreeDriverThousand(void); +int32_t HdfPmTestThreeDriverSeqHundred(void); +int32_t HdfPmTestThreeDriverHundredWithSync(void); +int32_t HdfPmTestEnd(void); + +static const struct TestCaseType testCases[] = { + { HDF_PM_TEST_BEGEN, HdfPmTestBegin }, + { HDF_PM_TEST_ONE_DRIVER_ONCE, HdfPmTestOneDriverOnce }, + { HDF_PM_TEST_ONE_DRIVER_TWICE, HdfPmTestOneDriverTwice }, + { HDF_PM_TEST_ONE_DRIVER_TEN, HdfPmTestOneDriverTen }, + { HDF_PM_TEST_ONE_DRIVER_HUNDRED, HdfPmTestOneDriverHundred }, + { HDF_PM_TEST_ONE_DRIVER_THOUSAND, HdfPmTestOneDriverThousand }, + { HDF_PM_TEST_TWO_DRIVER_ONCE, HdfPmTestTwoDriverOnce }, + { HDF_PM_TEST_TWO_DRIVER_TWICE, HdfPmTestTwoDriverTwice }, + { HDF_PM_TEST_TWO_DRIVER_TEN, HdfPmTestTwoDriverTen }, + { HDF_PM_TEST_TWO_DRIVER_HUNDRED, HdfPmTestTwoDriverHundred }, + { HDF_PM_TEST_TWO_DRIVER_THOUSAND, HdfPmTestTwoDriverThousand }, + { HDF_PM_TEST_THREE_DRIVER_ONCE, HdfPmTestThreeDriverOnce }, + { HDF_PM_TEST_THREE_DRIVER_TWICE, HdfPmTestThreeDriverTwice }, + { HDF_PM_TEST_THREE_DRIVER_TEN, HdfPmTestThreeDriverTen }, + { HDF_PM_TEST_THREE_DRIVER_HUNDRED, HdfPmTestThreeDriverHundred }, + { HDF_PM_TEST_THREE_DRIVER_THOUSAND, HdfPmTestThreeDriverThousand }, + { HDF_PM_TEST_THREE_DRIVER_SEQ_HUNDRED, HdfPmTestThreeDriverSeqHundred }, + { HDF_PM_TEST_THREE_DRIVER_HUNDRED_WITH_SYNC, HdfPmTestThreeDriverHundredWithSync }, + { HDF_PM_TEST_END, HdfPmTestEnd }, +}; + +static const char *serviceName[] = { "HDF_TEST", "sample_service", "pm_test_service" }; + +struct PmTestType { + const char *serviceName; + struct HdfDeviceObject *obj; + struct PmDriverPmListener listener; + const struct IPowerEventListener *listenerBak; + uint32_t resumeCnt; + uint32_t suspendCnt; +}; + +extern struct PmWorkQueue *HdfPmTaskQueueInit(HdfTaskFunc func); + +static struct PmTestType pmTestType[PM_TEST_DRIVER + 1]; + +static bool loopTest = false; + +int HdfPmHdfTestDozeResume(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("%s called", __func__); + return HDF_SUCCESS; +} + +int HdfPmHdfTestDozeSuspend(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("%s called", __func__); + return HDF_SUCCESS; +} + +int HdfPmHdfTestResume(struct HdfDeviceObject *deviceObject) +{ + if (loopTest == false) { + HDF_LOGI("%s called", __func__); + } + + pmTestType[HDF_TEST_DRIVER].resumeCnt++; + return HDF_SUCCESS; +} + +int HdfPmHdfTestSuspend(struct HdfDeviceObject *deviceObject) +{ + if (loopTest == false) { + HDF_LOGI("%s called", __func__); + } + pmTestType[HDF_TEST_DRIVER].suspendCnt++; + return HDF_SUCCESS; +} + +int HdfPmSampleDozeResume(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("%s called", __func__); + return HDF_SUCCESS; +} + +int HdfPmSampleDozeSuspend(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("%s called", __func__); + return HDF_SUCCESS; +} + +int HdfPmSampleResume(struct HdfDeviceObject *deviceObject) +{ + if (loopTest == false) { + HDF_LOGI("%s called", __func__); + } + pmTestType[SAMPLE_TEST_DRIVER].resumeCnt++; + return HDF_SUCCESS; +} + +int HdfPmSampleSuspend(struct HdfDeviceObject *deviceObject) +{ + if (loopTest == false) { + HDF_LOGI("%s called", __func__); + } + pmTestType[SAMPLE_TEST_DRIVER].suspendCnt++; + return HDF_SUCCESS; +} + +int HdfPmTestDozeResume(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("%s called", __func__); + return HDF_SUCCESS; +} + +int HdfPmTestDozeSuspend(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("%s called", __func__); + return HDF_SUCCESS; +} + +int HdfPmTestResume(struct HdfDeviceObject *deviceObject) +{ + if (loopTest == false) { + HDF_LOGI("%s called", __func__); + } + pmTestType[PM_TEST_DRIVER].resumeCnt++; + return HDF_SUCCESS; +} + +int HdfPmTestSuspend(struct HdfDeviceObject *deviceObject) +{ + if (loopTest == false) { + HDF_LOGI("%s called", __func__); + } + pmTestType[PM_TEST_DRIVER].suspendCnt++; + return HDF_SUCCESS; +} + +void HdfPmSetListeners() +{ + pmTestType[HDF_TEST_DRIVER].listener.powerListener.DozeResume = HdfPmHdfTestDozeResume; + pmTestType[HDF_TEST_DRIVER].listener.powerListener.DozeSuspend = HdfPmHdfTestDozeSuspend; + pmTestType[HDF_TEST_DRIVER].listener.powerListener.Resume = HdfPmHdfTestResume; + pmTestType[HDF_TEST_DRIVER].listener.powerListener.Suspend = HdfPmHdfTestSuspend; + + pmTestType[SAMPLE_TEST_DRIVER].listener.powerListener.DozeResume = HdfPmSampleDozeResume; + pmTestType[SAMPLE_TEST_DRIVER].listener.powerListener.DozeSuspend = HdfPmSampleDozeSuspend; + pmTestType[SAMPLE_TEST_DRIVER].listener.powerListener.Resume = HdfPmSampleResume; + pmTestType[SAMPLE_TEST_DRIVER].listener.powerListener.Suspend = HdfPmSampleSuspend; + + pmTestType[PM_TEST_DRIVER].listener.powerListener.DozeResume = HdfPmTestDozeResume; + pmTestType[PM_TEST_DRIVER].listener.powerListener.DozeSuspend = HdfPmTestDozeSuspend; + pmTestType[PM_TEST_DRIVER].listener.powerListener.Resume = HdfPmTestResume; + pmTestType[PM_TEST_DRIVER].listener.powerListener.Suspend = HdfPmTestSuspend; +} + +void HdfPmClearTestCnt() +{ + uint32_t index; + + for (index = 0; index <= PM_TEST_DRIVER; index++) { + pmTestType[index].resumeCnt = 0; + pmTestType[index].suspendCnt = 0; + } +} + +int32_t HdfPmRegisterTestListener(int32_t index) +{ + struct SubscriberCallback callback = {NULL}; + struct HdfDeviceNode *devNode = NULL; + + pmTestType[index].serviceName = serviceName[index]; + pmTestType[index].obj = DevSvcManagerClntGetDeviceObject(pmTestType[index].serviceName); + if (pmTestType[index].obj == NULL) { + DevSvcManagerClntSubscribeService(pmTestType[index].serviceName, callback); + OsalMSleep(PM_WAIT_LOAD_TIME); + pmTestType[index].obj = DevSvcManagerClntGetDeviceObject(pmTestType[index].serviceName); + } + + if (pmTestType[index].obj) { + devNode = (struct HdfDeviceNode *)HDF_SLIST_CONTAINER_OF( + struct HdfDeviceObject, pmTestType[index].obj, struct HdfDeviceNode, deviceObject); + if ((devNode->powerToken != NULL) && (devNode->powerToken->listener != NULL)) { + pmTestType[index].listenerBak = devNode->powerToken->listener; + HdfPmUnregisterPowerListener(pmTestType[index].obj, pmTestType[index].listenerBak); + } else { + pmTestType[index].listenerBak = NULL; + } + + HdfPmRegisterPowerListener(pmTestType[index].obj, &pmTestType[index].listener.powerListener); + } + HdfPmSetMode(pmTestType[index].obj, HDF_POWER_DYNAMIC_CTRL); + return HDF_SUCCESS; +} + +int32_t HdfPmBakListener(int32_t index) +{ + HdfPmUnregisterPowerListener(pmTestType[index].obj, &pmTestType[index].listener.powerListener); + if (pmTestType[index].listenerBak != NULL) { + HdfPmRegisterPowerListener(pmTestType[index].obj, pmTestType[index].listenerBak); + HdfPmSetMode(pmTestType[index].obj, HDF_POWER_SYS_CTRL); + } + return HDF_SUCCESS; +} + +void HdfPmTestAcquire(uint32_t index) +{ + HdfPmAcquireDeviceAsync(pmTestType[index].obj); +} + +void HdfPmTestRelease(uint32_t index) +{ + HdfPmReleaseDeviceAsync(pmTestType[index].obj); +} + +void HdfPmTestAcquireSync(uint32_t index) +{ + HdfPmAcquireDevice(pmTestType[index].obj); +} + +void HdfPmTestReleaseSync(uint32_t index) +{ + HdfPmReleaseDevice(pmTestType[index].obj); +} + +int32_t HdfPmTestBegin(void) +{ + uint32_t index; + + HdfPmTaskQueueInit(NULL); + HdfPmSetListeners(); + HdfPmClearTestCnt(); + + for (index = 0; index <= PM_TEST_DRIVER; index++) { + HdfPmRegisterTestListener(index); + } + return HDF_SUCCESS; +} + +int32_t HdfPmTestEnd(void) +{ + uint32_t index; + + for (index = 0; index <= PM_TEST_DRIVER; index++) { + HdfPmBakListener(index); + } + + HdfPowerManagerExit(); + HdfPmTaskQueueInit(NULL); + loopTest = false; + + return HDF_SUCCESS; +} + +int32_t HdfPmTestOneDriver(const int32_t times) +{ + uint32_t index; + uint32_t waitTime = 0; + uint64_t beginTimes = OsalGetSysTimeMs(); + uint32_t expendTimes; + + HdfPmClearTestCnt(); + + for (index = 0; index < times; index++) { + HdfPmTestAcquire(PM_TEST_DRIVER); + HdfPmTestRelease(PM_TEST_DRIVER); + } + + WAIT_TEST_END(CHECK_VALUE(PM_TEST_DRIVER, times), waitTime); + + HDF_LOGI("%s %d %d", __func__, pmTestType[PM_TEST_DRIVER].resumeCnt, pmTestType[PM_TEST_DRIVER].suspendCnt); + + expendTimes = OsalGetSysTimeMs() - beginTimes; + HDF_LOGI("%s test expend times:%d ms", __func__, expendTimes); + + return CHECK_VALUE(PM_TEST_DRIVER, times) ? HDF_SUCCESS : HDF_FAILURE; +} + +int32_t HdfPmTestTwoDriver(const int32_t times) +{ + uint32_t index; + uint32_t waitTime = 0; + uint64_t beginTimes = OsalGetSysTimeMs(); + uint32_t expendTimes; + + HdfPmClearTestCnt(); + + for (index = 0; index < times; index++) { + HdfPmTestAcquire(PM_TEST_DRIVER); + HdfPmTestAcquire(HDF_TEST_DRIVER); + HdfPmTestRelease(PM_TEST_DRIVER); + HdfPmTestRelease(HDF_TEST_DRIVER); + } + + WAIT_TEST_END(CHECK_VALUE(PM_TEST_DRIVER, times) && CHECK_VALUE(HDF_TEST_DRIVER, times), waitTime); + + HDF_LOGI("%s %d %d", __func__, pmTestType[PM_TEST_DRIVER].resumeCnt, pmTestType[PM_TEST_DRIVER].suspendCnt); + HDF_LOGI("%s %d %d", __func__, pmTestType[HDF_TEST_DRIVER].resumeCnt, pmTestType[HDF_TEST_DRIVER].suspendCnt); + + expendTimes = OsalGetSysTimeMs() - beginTimes; + HDF_LOGI("%s test expend times:%d ms", __func__, expendTimes); + + return (CHECK_VALUE(PM_TEST_DRIVER, times) && CHECK_VALUE(HDF_TEST_DRIVER, times)) ? HDF_SUCCESS : HDF_FAILURE; +} + +int32_t HdfPmTestThreeDriver(const int32_t times, bool sync) +{ + uint32_t index; + uint32_t total = times; + uint32_t waitTime = 0; + uint64_t beginTimes = OsalGetSysTimeMs(); + uint32_t expendTimes; + + HdfPmClearTestCnt(); + + if (sync) { + total += PM_TEST_COUNT_ONE; + } + + if (sync) { + HdfPmTestAcquireSync(PM_TEST_DRIVER); + HdfPmTestAcquireSync(HDF_TEST_DRIVER); + HdfPmTestAcquireSync(SAMPLE_TEST_DRIVER); + HdfPmTestReleaseSync(PM_TEST_DRIVER); + HdfPmTestReleaseSync(HDF_TEST_DRIVER); + HdfPmTestReleaseSync(SAMPLE_TEST_DRIVER); + } + + for (index = 0; index < times; index++) { + HdfPmTestAcquire(PM_TEST_DRIVER); + HdfPmTestAcquire(HDF_TEST_DRIVER); + HdfPmTestAcquire(SAMPLE_TEST_DRIVER); + + HdfPmTestRelease(PM_TEST_DRIVER); + HdfPmTestRelease(HDF_TEST_DRIVER); + HdfPmTestRelease(SAMPLE_TEST_DRIVER); + } + + WAIT_TEST_END(CHECK_VALUE(PM_TEST_DRIVER, total) && + CHECK_VALUE(HDF_TEST_DRIVER, total) && + CHECK_VALUE(SAMPLE_TEST_DRIVER, total), waitTime); + + HDF_LOGI("%s %d %d", __func__, pmTestType[PM_TEST_DRIVER].resumeCnt, pmTestType[PM_TEST_DRIVER].suspendCnt); + HDF_LOGI("%s %d %d", __func__, pmTestType[HDF_TEST_DRIVER].resumeCnt, pmTestType[HDF_TEST_DRIVER].suspendCnt); + HDF_LOGI("%s %d %d", __func__, + pmTestType[SAMPLE_TEST_DRIVER].resumeCnt, pmTestType[SAMPLE_TEST_DRIVER].suspendCnt); + + expendTimes = OsalGetSysTimeMs() - beginTimes; + HDF_LOGI("%s test expend times:%d ms", __func__, expendTimes); + + return (CHECK_VALUE(PM_TEST_DRIVER, total) && CHECK_VALUE(HDF_TEST_DRIVER, total) && + CHECK_VALUE(SAMPLE_TEST_DRIVER, total)) ? HDF_SUCCESS : HDF_FAILURE; +} + +int32_t HdfPmTestThreeDriverSeqHundred(void) +{ + uint32_t index; + uint32_t waitTime = 0; + uint64_t beginTimes = OsalGetSysTimeMs(); + uint32_t expendTimes; + + HdfPmClearTestCnt(); + + for (index = 0; index < PM_TEST_COUNT_TWO; index++) { + HdfPmTestAcquire(PM_TEST_DRIVER); + HdfPmTestAcquire(HDF_TEST_DRIVER); + HdfPmTestAcquire(SAMPLE_TEST_DRIVER); + } + + for (index = 0; index < PM_TEST_COUNT_TWO; index++) { + HdfPmTestRelease(PM_TEST_DRIVER); + HdfPmTestRelease(HDF_TEST_DRIVER); + HdfPmTestRelease(SAMPLE_TEST_DRIVER); + } + + WAIT_TEST_END(CHECK_VALUE(PM_TEST_DRIVER, PM_TEST_COUNT_ONE) && + CHECK_VALUE(HDF_TEST_DRIVER, PM_TEST_COUNT_ONE) && + CHECK_VALUE(SAMPLE_TEST_DRIVER, PM_TEST_COUNT_ONE), waitTime); + + HDF_LOGI("%s %d %d", __func__, pmTestType[PM_TEST_DRIVER].resumeCnt, pmTestType[PM_TEST_DRIVER].suspendCnt); + HDF_LOGI("%s %d %d", __func__, pmTestType[HDF_TEST_DRIVER].resumeCnt, pmTestType[HDF_TEST_DRIVER].suspendCnt); + HDF_LOGI("%s %d %d", __func__, + pmTestType[SAMPLE_TEST_DRIVER].resumeCnt, pmTestType[SAMPLE_TEST_DRIVER].suspendCnt); + + expendTimes = OsalGetSysTimeMs() - beginTimes; + HDF_LOGI("%s test expend times:%d ms", __func__, expendTimes); + + return (CHECK_VALUE(PM_TEST_DRIVER, PM_TEST_COUNT_ONE) && CHECK_VALUE(HDF_TEST_DRIVER, PM_TEST_COUNT_ONE) && + CHECK_VALUE(SAMPLE_TEST_DRIVER, PM_TEST_COUNT_ONE)) ? HDF_SUCCESS : HDF_FAILURE; +} + +int32_t HdfPmTestOneDriverOnce(void) +{ + loopTest = false; + return HdfPmTestOneDriver(PM_TEST_COUNT_ONE); +} + +int32_t HdfPmTestOneDriverTwice(void) +{ + loopTest = false; + return HdfPmTestOneDriver(PM_TEST_COUNT_TWO); +} + +int32_t HdfPmTestOneDriverTen(void) +{ + loopTest = true; + return HdfPmTestOneDriver(PM_TEST_COUNT_TEN); +} + +int32_t HdfPmTestOneDriverHundred(void) +{ + loopTest = true; + return HdfPmTestOneDriver(PM_TEST_COUNT_HUNDRED); +} + +int32_t HdfPmTestOneDriverThousand(void) +{ + loopTest = true; + return HdfPmTestOneDriver(PM_TEST_COUNT_THOUSAND); +} + +int32_t HdfPmTestTwoDriverOnce(void) +{ + loopTest = false; + return HdfPmTestTwoDriver(PM_TEST_COUNT_ONE); +} + +int32_t HdfPmTestTwoDriverTwice(void) +{ + loopTest = false; + return HdfPmTestTwoDriver(PM_TEST_COUNT_TWO); +} + +int32_t HdfPmTestTwoDriverTen(void) +{ + loopTest = true; + return HdfPmTestTwoDriver(PM_TEST_COUNT_TEN); +} + +int32_t HdfPmTestTwoDriverHundred(void) +{ + loopTest = true; + return HdfPmTestTwoDriver(PM_TEST_COUNT_HUNDRED); +} + +int32_t HdfPmTestTwoDriverThousand(void) +{ + loopTest = true; + return HdfPmTestTwoDriver(PM_TEST_COUNT_THOUSAND); +} + +int32_t HdfPmTestThreeDriverOnce(void) +{ + loopTest = false; + return HdfPmTestThreeDriver(PM_TEST_COUNT_ONE, false); +} + +int32_t HdfPmTestThreeDriverTwice(void) +{ + loopTest = false; + return HdfPmTestThreeDriver(PM_TEST_COUNT_TWO, false); +} + +int32_t HdfPmTestThreeDriverTen(void) +{ + loopTest = true; + return HdfPmTestThreeDriver(PM_TEST_COUNT_TEN, false); +} + +int32_t HdfPmTestThreeDriverHundred(void) +{ + loopTest = true; + return HdfPmTestThreeDriver(PM_TEST_COUNT_HUNDRED, false); +} + +int32_t HdfPmTestThreeDriverThousand(void) +{ + loopTest = true; + return HdfPmTestThreeDriver(PM_TEST_COUNT_THOUSAND, false); +} + +int32_t HdfPmTestThreeDriverHundredWithSync(void) +{ + loopTest = true; + return HdfPmTestThreeDriver(PM_TEST_COUNT_HUNDRED, true); +} + +void HdfPmDriverRelease(struct HdfDeviceObject *deviceObject) +{ + (void)deviceObject; + return; +} + +int32_t HdfPmDriverDispatch(struct HdfDeviceIoClient *client, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + int32_t ret = HDF_FAILURE; + uint32_t index; + + HDF_LOGI("%s %d enter!", __func__, cmdId); + + for (index = 0; index <= HDF_PM_TEST_END; index++) { + if (cmdId == testCases[index].cmd) { + ret = testCases[cmdId].testFunc(); + break; + } + } + + return ret; +} + +int HdfPmDriverBind(struct HdfDeviceObject *deviceObject) +{ + HDF_LOGI("%s enter", __func__); + if (deviceObject == NULL) { + return HDF_FAILURE; + } + static struct IDeviceIoService testService = { + .Dispatch = HdfPmDriverDispatch, + .Open = NULL, + .Release = NULL, + }; + deviceObject->service = &testService; + return HDF_SUCCESS; +} + +int HdfPmDriverInit(struct HdfDeviceObject *deviceObject) +{ + static struct PmDriverPmListener pmListener = {0}; + + HDF_LOGI("%s enter!", __func__); + if (deviceObject == NULL) { + HDF_LOGE("%s ptr is null!", __func__); + return HDF_FAILURE; + } + HDF_LOGD("%s Init success", __func__); + + pmListener.powerListener.DozeResume = HdfPmTestDozeResume; + pmListener.powerListener.DozeSuspend = HdfPmTestDozeSuspend; + pmListener.powerListener.Resume = HdfPmTestResume; + pmListener.powerListener.Suspend = HdfPmTestSuspend; + + int ret = HdfPmRegisterPowerListener(deviceObject, &pmListener.powerListener); + HDF_LOGI("%s register power listener, ret = %d", __func__, ret); + + return HDF_SUCCESS; +} + +struct HdfDriverEntry g_pmDriverEntry = { + .moduleVersion = 1, + .moduleName = "pm_test_driver", + .Bind = HdfPmDriverBind, + .Init = HdfPmDriverInit, + .Release = HdfPmDriverRelease, +}; + +HDF_INIT(g_pmDriverEntry); + diff --git a/test/unittest/pm/hdf_pm_driver_test.h b/test/unittest/pm/hdf_pm_driver_test.h new file mode 100755 index 0000000000000000000000000000000000000000..26078b601942276847192c1458d407a999692584 --- /dev/null +++ b/test/unittest/pm/hdf_pm_driver_test.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 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_PM_DRIVER_TEST_H +#define HDF_PM_DRIVER_TEST_H + +#include "hdf_object.h" + +#define SAMPLE_SERVICE "pm_service" + +enum { + HDF_PM_TEST_BEGEN = 0, + HDF_PM_TEST_ONE_DRIVER_ONCE, + HDF_PM_TEST_ONE_DRIVER_TWICE, + HDF_PM_TEST_ONE_DRIVER_TEN, + HDF_PM_TEST_ONE_DRIVER_HUNDRED, + HDF_PM_TEST_ONE_DRIVER_THOUSAND, + HDF_PM_TEST_TWO_DRIVER_ONCE, + HDF_PM_TEST_TWO_DRIVER_TWICE, + HDF_PM_TEST_TWO_DRIVER_TEN, + HDF_PM_TEST_TWO_DRIVER_HUNDRED, + HDF_PM_TEST_TWO_DRIVER_THOUSAND, + HDF_PM_TEST_THREE_DRIVER_ONCE, + HDF_PM_TEST_THREE_DRIVER_TWICE, + HDF_PM_TEST_THREE_DRIVER_TEN, + HDF_PM_TEST_THREE_DRIVER_HUNDRED, + HDF_PM_TEST_THREE_DRIVER_THOUSAND, + HDF_PM_TEST_THREE_DRIVER_SEQ_HUNDRED, + HDF_PM_TEST_THREE_DRIVER_HUNDRED_WITH_SYNC, + HDF_PM_TEST_END, +}; + +#endif // HDF_PM_DRIVER_TEST_H + diff --git a/test/unittest/sensor/hdf_sensor_test.c b/test/unittest/sensor/hdf_sensor_test.c index ce89c9eb3dcb9e0db9ed96cffbe9178214b1ae89..85871a99886260c14bc98f0b1d7a56e4532825df 100644 --- a/test/unittest/sensor/hdf_sensor_test.c +++ b/test/unittest/sensor/hdf_sensor_test.c @@ -141,8 +141,10 @@ static int32_t SensorDisableTest(void) static int32_t SensorSetBatchTest(int64_t samplingInterval, int64_t interval) { + struct SensorTestDrvData *drvData = NULL; (void)interval; - struct SensorTestDrvData *drvData = GetSensorTestDrvData(); + + drvData = GetSensorTestDrvData(); drvData->interval = samplingInterval; return HDF_SUCCESS; @@ -172,12 +174,13 @@ static int32_t SensorTestDispatch(struct HdfDeviceIoClient *client, int32_t BindSensorDriverTest(struct HdfDeviceObject *device) { - CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); - static struct IDeviceIoService service = { .object = {0}, .Dispatch = SensorTestDispatch, }; + + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + device->service = &service; return HDF_SUCCESS; } @@ -185,8 +188,6 @@ int32_t BindSensorDriverTest(struct HdfDeviceObject *device) int32_t InitSensorDriverTest(struct HdfDeviceObject *device) { int32_t ret; - (void)device; - struct SensorDeviceInfo deviceInfo = { .sensorInfo = { .sensorName = "sensor_test", @@ -208,6 +209,8 @@ int32_t InitSensorDriverTest(struct HdfDeviceObject *device) }, }; + (void)device; + ret = SensorInitTestConfig(); if (ret != HDF_SUCCESS) { HDF_LOGE("%s: sensor test config failed", __func__); @@ -226,9 +229,8 @@ int32_t InitSensorDriverTest(struct HdfDeviceObject *device) void ReleaseSensorDriverTest(struct HdfDeviceObject *device) { - (void)device; int32_t ret; - struct SensorTestDrvData *drvData = GetSensorTestDrvData(); + struct SensorTestDrvData *drvData = NULL; struct SensorDeviceInfo deviceInfo = { .sensorInfo = { .sensorName = "sensor_test", @@ -242,6 +244,8 @@ void ReleaseSensorDriverTest(struct HdfDeviceObject *device) .power = SENSOR_TEST_MAX_POWER, } }; + drvData = GetSensorTestDrvData(); + (void)device; (void)DeleteSensorDevice(&deviceInfo.sensorInfo); if (drvData->timer.realTimer != NULL) { diff --git a/test/unittest/ability/config/hcs_parser/unittest/hcs_config_test.c b/test/unittest/utils/hcs_parser/unittest/hcs_config_test.c similarity index 75% rename from test/unittest/ability/config/hcs_parser/unittest/hcs_config_test.c rename to test/unittest/utils/hcs_parser/unittest/hcs_config_test.c index b5757268eb086b737cd18db685398a5e5a30aa3a..71baeee70d86e890c700a86a705432d47c385972 100644 --- a/test/unittest/ability/config/hcs_parser/unittest/hcs_config_test.c +++ b/test/unittest/utils/hcs_parser/unittest/hcs_config_test.c @@ -75,13 +75,13 @@ int HcsTestCreateDMHcsToTree(void) static bool TestHcsGetNodeByMatchAttrSuccess(void) { + const struct DeviceResourceNode *fingerPrintNode = NULL; const struct DeviceResourceNode *audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); if (audioNode == NULL) { HDF_LOGE("%s failed, HcsGetNodeByMatchAttr failed, line: %d\n", __FUNCTION__, __LINE__); return false; } - const struct DeviceResourceNode *fingerPrintNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, - HW_FINGERPRINT_INFO); + fingerPrintNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_FINGERPRINT_INFO); if (fingerPrintNode == NULL) { HDF_LOGE("%s failed, HcsGetNodeByMatchAttr failed, line: %d\n", __FUNCTION__, __LINE__); return false; @@ -133,18 +133,20 @@ int HcsTestGetNodeByMatchAttrFail(void) static bool TestHcsAttrGetBoolSuccess(void) { + const struct DeviceResourceNode *fingerNode = NULL; const struct DeviceResourceNode *audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); bool primaryMic = g_devResInstance->GetBool(audioNode, "builtin_primary_mic_exist"); + bool dualFinger = NULL; if (!primaryMic) { HDF_LOGE("%s failed, HcsGetBool failed, line: %d\n", __FUNCTION__, __LINE__); return false; } - const struct DeviceResourceNode *fingerNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_FINGERPRINT_INFO); + fingerNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_FINGERPRINT_INFO); if (fingerNode == NULL) { HDF_LOGE("%s failed, HcsGetNodeByMatchAttr failed, line: %d\n", __FUNCTION__, __LINE__); return false; } - bool dualFinger = g_devResInstance->GetBool(fingerNode, DUAL_FINGERPRINT); + dualFinger = g_devResInstance->GetBool(fingerNode, DUAL_FINGERPRINT); if (dualFinger) { HDF_LOGE("%s failed, HcsGetBool failed, line: %d\n", __FUNCTION__, __LINE__); return false; @@ -165,17 +167,19 @@ int HcsTestGetBoolAttrValueSuccess(void) static bool TestHcsAttrGetBoolFailed(void) { + const struct DeviceResourceNode *fingerNode = NULL; const struct DeviceResourceNode *audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); + bool testReadBool = NULL; if (audioNode == NULL) { HDF_LOGE("%s failed, HcsGetNodeByMatchAttr failed, line: %d", __FUNCTION__, __LINE__); return false; } - bool testReadBool = g_devResInstance->GetBool(audioNode, INVALID_STRING); + testReadBool = g_devResInstance->GetBool(audioNode, INVALID_STRING); if (testReadBool) { HDF_LOGE("%s failed, HcsGetBool failed, line: %d", __FUNCTION__, __LINE__); return false; } - const struct DeviceResourceNode *fingerNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_FINGERPRINT_INFO); + fingerNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_FINGERPRINT_INFO); if (fingerNode == NULL) { HDF_LOGE("%s failed, HcsGetNodeByMatchAttr failed, line: %d", __FUNCTION__, __LINE__); return false; @@ -211,12 +215,14 @@ int HcsTestGetBoolAttrValueFail(void) int HcsTestGetUint8AttrValueSuccess(void) { + const struct DeviceResourceNode *audioNode = NULL; uint8_t data; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); - int32_t ret = g_devResInstance->GetUint8(audioNode, SMARTPA_NUM, &data, DEFAULT_UINT8_MAX); + audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); + ret = g_devResInstance->GetUint8(audioNode, SMARTPA_NUM, &data, DEFAULT_UINT8_MAX); if ((ret != HDF_SUCCESS) || (data != U8_DATA)) { HDF_LOGE("%s failed, line: %d, ret = %d, data = %u", __FUNCTION__, __LINE__, ret, data); return HDF_FAILURE; @@ -226,12 +232,14 @@ int HcsTestGetUint8AttrValueSuccess(void) int HcsTestGetUint8AttrValueFail(void) { + const struct DeviceResourceNode *audioNode = NULL; uint8_t data; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); - int32_t ret = g_devResInstance->GetUint8(audioNode, INVALID_STRING, &data, DEFAULT_UINT8_MAX); + audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); + ret = g_devResInstance->GetUint8(audioNode, INVALID_STRING, &data, DEFAULT_UINT8_MAX); if ((ret == HDF_SUCCESS) || (data != DEFAULT_UINT8_MAX)) { return HDF_FAILURE; } @@ -256,15 +264,17 @@ int HcsTestGetUint8AttrValueFail(void) int HcsTestGetUint8ArrayElemSuccess(void) { + const struct DeviceResourceNode *dataType = NULL; uint8_t data[DATA_TEST_ARRAY_LENGTH] = { 0 }; // the test data is 0, 1, 2, 3, 4, 5, 6, 7. uint8_t testData[DATA_TEST_ARRAY_LENGTH] = { 0, 1, 2, 3, 4, 5, 6, 7 }; uint32_t i; + int32_t count; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); - int32_t count = g_devResInstance->GetElemNum(dataType, TEST_U8_ELEM_DATA); + dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); + count = g_devResInstance->GetElemNum(dataType, TEST_U8_ELEM_DATA); if (count != DATA_TEST_ARRAY_LENGTH) { return HDF_FAILURE; } @@ -281,22 +291,24 @@ int HcsTestGetUint8ArrayElemSuccess(void) int HcsTestGetUint8ArrayElemFail(void) { + const struct DeviceResourceNode *dataType = NULL; + uint8_t data1[DATA_TYPE_NUM_U64] = { 0 }; uint8_t data; uint32_t i; + int32_t ret; + int32_t count; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); + dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); // the number of 8 is invalid value. - int32_t ret = g_devResInstance->GetUint8ArrayElem(dataType, TEST_U8_ELEM_DATA, 8, &data, - DEFAULT_UINT8_MAX); + ret = g_devResInstance->GetUint8ArrayElem(dataType, TEST_U8_ELEM_DATA, 8, &data, DEFAULT_UINT8_MAX); if ((ret == HDF_SUCCESS) || (data != DEFAULT_UINT8_MAX)) { HDF_LOGE("%s failed, line: %d, ret = %d, data = %x", __FUNCTION__, __LINE__, ret, data); return HDF_FAILURE; } - uint8_t data1[DATA_TYPE_NUM_U64] = { 0 }; dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); - int32_t count = g_devResInstance->GetElemNum(dataType, READ_FOUR_DATA_TYPE); + count = g_devResInstance->GetElemNum(dataType, READ_FOUR_DATA_TYPE); if (count != DATA_TYPE_NUM_U64) { return HDF_FAILURE; } @@ -314,13 +326,14 @@ int HcsTestGetUint8ArrayElemFail(void) int HcsTestGetUint8ArraySuccess(void) { + const struct DeviceResourceNode *dataType = NULL; uint8_t data[DATA_TEST_ARRAY_LENGTH] = { 0 }; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); - int32_t ret = g_devResInstance->GetUint8Array(dataType, TEST_U8_ELEM_DATA, data, DATA_TEST_ARRAY_LENGTH, - DEFAULT_UINT8_MAX); + dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); + ret = g_devResInstance->GetUint8Array(dataType, TEST_U8_ELEM_DATA, data, DATA_TEST_ARRAY_LENGTH, DEFAULT_UINT8_MAX); // the 0~7 represents the location in array or the value in hcs file. if ((ret != HDF_SUCCESS) || (data[0] != 0) || (data[1] != 1) || (data[2] != 2) || (data[3] != 3) || (data[4] != 4) || (data[5] != 5) || (data[6] != 6) || (data[7] != 7)) { @@ -331,12 +344,14 @@ int HcsTestGetUint8ArraySuccess(void) int HcsTestGetUint8ArrayFail(void) { + const struct DeviceResourceNode *dataType = NULL; uint8_t data[DATA_TYPE_NUM_U64 + 1] = { 0 }; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); - int32_t ret = g_devResInstance->GetUint8Array(dataType, READ_FOUR_DATA_TYPE, data, 0, DEFAULT_UINT8_MAX); + dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); + ret = g_devResInstance->GetUint8Array(dataType, READ_FOUR_DATA_TYPE, data, 0, DEFAULT_UINT8_MAX); // the 0, 1, 2 represents the location in array, the 0 of second param is default value. if ((ret == HDF_SUCCESS) || (data[0] != 0) || (data[1] != 0) || (data[2] != 0)) { return HDF_FAILURE; @@ -353,12 +368,14 @@ int HcsTestGetUint8ArrayFail(void) int HcsTestGetUint16AttrValueSuccess(void) { + const struct DeviceResourceNode *audioNode = NULL; uint16_t data; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); - int32_t ret = g_devResInstance->GetUint16(audioNode, SMARTPA_NUM, &data, DEFAULT_UINT16_MAX); + audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); + ret = g_devResInstance->GetUint16(audioNode, SMARTPA_NUM, &data, DEFAULT_UINT16_MAX); if ((ret != HDF_SUCCESS) || (data != U8_DATA)) { HDF_LOGE("%s failed, line: %d, ret = %d, data = %u", __FUNCTION__, __LINE__, ret, data); return HDF_FAILURE; @@ -373,12 +390,14 @@ int HcsTestGetUint16AttrValueSuccess(void) int HcsTestGetUint16AttrValueFail(void) { + const struct DeviceResourceNode *audioNode = NULL; uint16_t data; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); - int32_t ret = g_devResInstance->GetUint16(audioNode, INVALID_STRING, &data, DEFAULT_UINT16_MAX); + audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); + ret = g_devResInstance->GetUint16(audioNode, INVALID_STRING, &data, DEFAULT_UINT16_MAX); if ((ret == HDF_SUCCESS) || (data != DEFAULT_UINT16_MAX)) { return HDF_FAILURE; } @@ -399,16 +418,18 @@ int HcsTestGetUint16AttrValueFail(void) int HcsTestGetUint16ArrayElemSuccess(void) { + const struct DeviceResourceNode *dataType = NULL; // the length of data is 8. uint16_t data[DATA_TEST_ARRAY_LENGTH] = { 0 }; // the test data is 0, 1, 2, 3, 4, 5, 256, 257. uint16_t testData[DATA_TEST_ARRAY_LENGTH] = { 0, 1, 2, 3, 4, 5, 256, 257 }; uint32_t i; + int32_t count; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); - int32_t count = g_devResInstance->GetElemNum(dataType, TEST_U16_ELEM_DATA); + dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); + count = g_devResInstance->GetElemNum(dataType, TEST_U16_ELEM_DATA); if (count != DATA_TEST_ARRAY_LENGTH) { return HDF_FAILURE; } @@ -424,20 +445,23 @@ int HcsTestGetUint16ArrayElemSuccess(void) int HcsTestGetUint16ArrayElemFail(void) { + const struct DeviceResourceNode *dataType = NULL; + uint16_t data1[DATA_TYPE_NUM_U64] = { 0 }; uint16_t data; uint32_t i; + int32_t ret; + int32_t count; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); - int32_t ret = g_devResInstance->GetUint16ArrayElem(dataType, TEST_U16_ELEM_DATA, DATA_TEST_ARRAY_LENGTH, &data, + dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); + ret = g_devResInstance->GetUint16ArrayElem(dataType, TEST_U16_ELEM_DATA, DATA_TEST_ARRAY_LENGTH, &data, DEFAULT_UINT16_MAX); if ((ret == HDF_SUCCESS) || (data != DEFAULT_UINT16_MAX)) { return HDF_FAILURE; } - uint16_t data1[DATA_TYPE_NUM_U64] = { 0 }; dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); - int32_t count = g_devResInstance->GetElemNum(dataType, READ_FOUR_DATA_TYPE); + count = g_devResInstance->GetElemNum(dataType, READ_FOUR_DATA_TYPE); if (count != DATA_TYPE_NUM_U64) { return HDF_FAILURE; } @@ -454,12 +478,14 @@ int HcsTestGetUint16ArrayElemFail(void) int HcsTestGetUint16ArraySuccess(void) { + const struct DeviceResourceNode *dataType = NULL; uint16_t data[DATA_TEST_ARRAY_LENGTH] = { 0 }; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); - int32_t ret = g_devResInstance->GetUint16Array(dataType, TEST_U16_ELEM_DATA, data, DATA_TEST_ARRAY_LENGTH, + dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); + ret = g_devResInstance->GetUint16Array(dataType, TEST_U16_ELEM_DATA, data, DATA_TEST_ARRAY_LENGTH, DEFAULT_UINT16_MAX); // the data[0~7] represents the location in array, the test data is 0, 1, 2, 3, 4, 5, 256, 257. if ((ret != HDF_SUCCESS) || (data[0] != 0) || (data[1] != 1) || (data[2] != 2) || (data[3] != 3) || (data[4] != 4) @@ -471,12 +497,14 @@ int HcsTestGetUint16ArraySuccess(void) int HcsTestGetUint16ArrayFail(void) { + const struct DeviceResourceNode *dataType = NULL; uint16_t data[DATA_TYPE_NUM_U64 + 1] = { 0 }; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); - int32_t ret = g_devResInstance->GetUint16Array(dataType, READ_FOUR_DATA_TYPE, data, 0, DEFAULT_UINT16_MAX); + dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); + ret = g_devResInstance->GetUint16Array(dataType, READ_FOUR_DATA_TYPE, data, 0, DEFAULT_UINT16_MAX); // the 0, 1, 2 represents the location in array, the 0 of second param is default value. if ((ret == HDF_SUCCESS) || (data[0] != 0) || (data[1] != 0) || (data[2] != 0)) { return HDF_FAILURE; @@ -493,12 +521,14 @@ int HcsTestGetUint16ArrayFail(void) int HcsTestGetUint32AttrValueSuccess(void) { + const struct DeviceResourceNode *audioNode = NULL; uint32_t data; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); - int32_t ret = g_devResInstance->GetUint32(audioNode, SMARTPA_NUM, &data, DEFAULT_UINT32_MAX); + audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); + ret = g_devResInstance->GetUint32(audioNode, SMARTPA_NUM, &data, DEFAULT_UINT32_MAX); if ((ret != HDF_SUCCESS) || (data != U8_DATA)) { HDF_LOGE("%s failed, line: %d, ret = %d, data = %u", __FUNCTION__, __LINE__, ret, data); return HDF_FAILURE; @@ -518,12 +548,14 @@ int HcsTestGetUint32AttrValueSuccess(void) int HcsTestGetUint32AttrValueFail(void) { + const struct DeviceResourceNode *audioNode = NULL; uint32_t data; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); - int32_t ret = g_devResInstance->GetUint32(audioNode, INVALID_STRING, &data, DEFAULT_UINT32_MAX); + audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); + ret = g_devResInstance->GetUint32(audioNode, INVALID_STRING, &data, DEFAULT_UINT32_MAX); if ((ret == HDF_SUCCESS) || (data != DEFAULT_UINT32_MAX)) { return HDF_FAILURE; } @@ -536,14 +568,16 @@ int HcsTestGetUint32AttrValueFail(void) int HcsTestGetUint32ArrayElemSuccess(void) { + const struct DeviceResourceNode *fingerNode = NULL; uint32_t data[DATA_TYPE_NUM_U32] = { 0 }; uint32_t testData[DATA_TYPE_NUM_U32] = { U8_DATA, U16_DATA, U32_DATA }; int32_t i; + int32_t count; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *fingerNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_FINGERPRINT_INFO); - int32_t count = g_devResInstance->GetElemNum(fingerNode, READ_U32_INDEX); + fingerNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_FINGERPRINT_INFO); + count = g_devResInstance->GetElemNum(fingerNode, READ_U32_INDEX); if (count != DATA_TYPE_NUM_U32) { return HDF_FAILURE; } @@ -558,12 +592,14 @@ int HcsTestGetUint32ArrayElemSuccess(void) int HcsTestGetUint32ArrayElemFail(void) { + const struct DeviceResourceNode *fingerNode = NULL; uint32_t data; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *fingerNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_FINGERPRINT_INFO); - int32_t ret = g_devResInstance->GetUint32ArrayElem(fingerNode, READ_U32_INDEX, DATA_TYPE_NUM_U32, &data, + fingerNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_FINGERPRINT_INFO); + ret = g_devResInstance->GetUint32ArrayElem(fingerNode, READ_U32_INDEX, DATA_TYPE_NUM_U32, &data, DEFAULT_UINT32_MAX); if ((ret == HDF_SUCCESS) || (data != DEFAULT_UINT32_MAX)) { return HDF_FAILURE; @@ -574,10 +610,11 @@ int HcsTestGetUint32ArrayElemFail(void) int HcsTestGetUint32ArraySuccess(void) { uint32_t data[BOARDID_LENGTH] = { 0 }; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - int32_t ret = g_devResInstance->GetUint32Array(g_testRoot, BOARD_ID, data, BOARDID_LENGTH, DEFAULT_UINT32_MAX); + ret = g_devResInstance->GetUint32Array(g_testRoot, BOARD_ID, data, BOARDID_LENGTH, DEFAULT_UINT32_MAX); // the 0, 1 represents the location in array. if ((ret != HDF_SUCCESS) || (data[0] != U32_DATA) || (data[1] != U16_DATA)) { return HDF_FAILURE; @@ -588,10 +625,11 @@ int HcsTestGetUint32ArraySuccess(void) int HcsTestGetUint32ArrayFail(void) { uint32_t data[DATA_TYPE_NUM_U32] = { 0 }; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - int32_t ret = g_devResInstance->GetUint32Array(g_testRoot, BOARD_ID, data, 0, DEFAULT_UINT32_MAX); + ret = g_devResInstance->GetUint32Array(g_testRoot, BOARD_ID, data, 0, DEFAULT_UINT32_MAX); // the 0, 1, 2 represents the location in array, the 0 of second param is default value. if ((ret == HDF_SUCCESS) || (data[0] != 0) || (data[1] != 0) || (data[2] != 0)) { return HDF_FAILURE; @@ -606,12 +644,14 @@ int HcsTestGetUint32ArrayFail(void) int HcsTestGetUint64AttrValueSuccess(void) { + const struct DeviceResourceNode *audioNode = NULL; uint64_t data; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); - int32_t ret = g_devResInstance->GetUint64(audioNode, SMARTPA_NUM, &data, DEFAULT_UINT32_MAX); + audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); + ret = g_devResInstance->GetUint64(audioNode, SMARTPA_NUM, &data, DEFAULT_UINT32_MAX); if ((ret != HDF_SUCCESS) || (data != U8_DATA)) { HDF_LOGE("%s failed, line: %d", __FUNCTION__, __LINE__); return HDF_FAILURE; @@ -636,12 +676,14 @@ int HcsTestGetUint64AttrValueSuccess(void) int HcsTestGetUint64AttrValueFail(void) { + const struct DeviceResourceNode *audioNode = NULL; uint64_t data; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); - int32_t ret = g_devResInstance->GetUint64(audioNode, INVALID_STRING, &data, DEFAULT_UINT64_MAX); + audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); + ret = g_devResInstance->GetUint64(audioNode, INVALID_STRING, &data, DEFAULT_UINT64_MAX); if ((ret == HDF_SUCCESS) || (data != DEFAULT_UINT64_MAX)) { return HDF_FAILURE; } @@ -654,14 +696,16 @@ int HcsTestGetUint64AttrValueFail(void) int HcsTestGetUint64ArrayElemSuccess(void) { + const struct DeviceResourceNode *dataType = NULL; uint64_t data[DATA_TYPE_NUM_U64] = { 0 }; uint64_t testData[DATA_TYPE_NUM_U64] = { U8_DATA, U16_DATA, U32_DATA, U64_DATA }; uint32_t i; + int32_t count; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); - int32_t count = g_devResInstance->GetElemNum(dataType, READ_FOUR_DATA_TYPE); + dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); + count = g_devResInstance->GetElemNum(dataType, READ_FOUR_DATA_TYPE); if (count != DATA_TYPE_NUM_U64) { return HDF_FAILURE; } @@ -677,12 +721,14 @@ int HcsTestGetUint64ArrayElemSuccess(void) int HcsTestGetUint64ArrayElemFail(void) { + const struct DeviceResourceNode *dataType = NULL; uint64_t data; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); - int32_t ret = g_devResInstance->GetUint64ArrayElem(dataType, READ_FOUR_DATA_TYPE, DATA_TYPE_NUM_U64, &data, + dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); + ret = g_devResInstance->GetUint64ArrayElem(dataType, READ_FOUR_DATA_TYPE, DATA_TYPE_NUM_U64, &data, DEFAULT_UINT64_MAX); if ((ret == HDF_SUCCESS) || (data != DEFAULT_UINT64_MAX)) { return HDF_FAILURE; @@ -692,12 +738,14 @@ int HcsTestGetUint64ArrayElemFail(void) int HcsTestGetUint64ArraySuccess(void) { + const struct DeviceResourceNode *dataType = NULL; uint64_t data[DATA_TYPE_NUM_U64] = { 0 }; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); - int32_t ret = g_devResInstance->GetUint64Array(dataType, READ_FOUR_DATA_TYPE, data, DATA_TYPE_NUM_U64, + dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); + ret = g_devResInstance->GetUint64Array(dataType, READ_FOUR_DATA_TYPE, data, DATA_TYPE_NUM_U64, DEFAULT_UINT64_MAX); // the 0, 1, 2 represents the location in array. if ((ret != HDF_SUCCESS) || (data[0] != U8_DATA) || (data[1] != U16_DATA) || (data[2] != U32_DATA) || @@ -709,12 +757,14 @@ int HcsTestGetUint64ArraySuccess(void) int HcsTestGetUint64ArrayFail(void) { + const struct DeviceResourceNode *dataType = NULL; uint64_t data[DATA_TYPE_NUM_U64 + 1] = { 0 }; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); - int32_t ret = g_devResInstance->GetUint64Array(dataType, READ_FOUR_DATA_TYPE, data, 0, DEFAULT_UINT64_MAX); + dataType = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_DATA_TYPE_TEST); + ret = g_devResInstance->GetUint64Array(dataType, READ_FOUR_DATA_TYPE, data, 0, DEFAULT_UINT64_MAX); // the 0, 1, 2 represents the location in array, the 0 of second param is default value. if ((ret == HDF_SUCCESS) || (data[0] != 0) || (data[1] != 0) || (data[2] != 0)) { return HDF_FAILURE; @@ -731,14 +781,16 @@ int HcsTestGetUint64ArrayFail(void) int HcsTestGetElemNumSuccess(void) { + const struct DeviceResourceNode *fingerNode = NULL; + int32_t count; if (!TestGetRootNode()) { return HDF_FAILURE; } - int32_t count = g_devResInstance->GetElemNum(g_testRoot, BOARD_ID); + count = g_devResInstance->GetElemNum(g_testRoot, BOARD_ID); if (count != BOARDID_LENGTH) { return HDF_FAILURE; } - const struct DeviceResourceNode *fingerNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_FINGERPRINT_INFO); + fingerNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_FINGERPRINT_INFO); count = g_devResInstance->GetElemNum(fingerNode, READ_U32_INDEX); if (count != DATA_TYPE_NUM_U32) { return HDF_FAILURE; @@ -752,12 +804,14 @@ int HcsTestGetElemNumSuccess(void) int HcsTestGetElemNumFail(void) { + const struct DeviceResourceNode *fingerNode = NULL; + int32_t count; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *fingerNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_FINGERPRINT_INFO); + fingerNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_FINGERPRINT_INFO); // the dual_fingerprint attr do not array, so the count is HDF_FAILURE. - int32_t count = g_devResInstance->GetElemNum(fingerNode, DUAL_FINGERPRINT); + count = g_devResInstance->GetElemNum(fingerNode, DUAL_FINGERPRINT); if (count != HDF_FAILURE) { return HDF_FAILURE; } @@ -771,18 +825,21 @@ int HcsTestGetElemNumFail(void) int HcsTestGetChildNodeSuccess(void) { + const struct DeviceResourceNode *audioNode = NULL; + const struct DeviceResourceNode *fingerprintNode = NULL; + const struct DeviceResourceNode *oneNode = NULL; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *audioNode = g_devResInstance->GetChildNode(g_testRoot, AUDIO_INFO); + audioNode = g_devResInstance->GetChildNode(g_testRoot, AUDIO_INFO); if (audioNode == NULL) { return HDF_FAILURE; } - const struct DeviceResourceNode *fingerprintNode = g_devResInstance->GetChildNode(g_testRoot, FINGERPRINT_INFO); + fingerprintNode = g_devResInstance->GetChildNode(g_testRoot, FINGERPRINT_INFO); if (fingerprintNode == NULL) { return HDF_FAILURE; } - const struct DeviceResourceNode *oneNode = g_devResInstance->GetChildNode(fingerprintNode, "fingerprint_one"); + oneNode = g_devResInstance->GetChildNode(fingerprintNode, "fingerprint_one"); if (oneNode == NULL) { return HDF_FAILURE; } @@ -791,14 +848,16 @@ int HcsTestGetChildNodeSuccess(void) int HcsTestGetChildNodeFail(void) { + const struct DeviceResourceNode *twoNode = NULL; + const struct DeviceResourceNode *nullNode = NULL; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *twoNode = g_devResInstance->GetChildNode(g_testRoot, "fingerprint_two"); + twoNode = g_devResInstance->GetChildNode(g_testRoot, "fingerprint_two"); if (twoNode != NULL) { return HDF_FAILURE; } - const struct DeviceResourceNode *nullNode = g_devResInstance->GetChildNode(g_testRoot, INVALID_NODE); + nullNode = g_devResInstance->GetChildNode(g_testRoot, INVALID_NODE); if (nullNode != NULL) { return HDF_FAILURE; } @@ -815,14 +874,15 @@ int HcsTestGetChildNodeFail(void) int HcsTestTraverseAttrInNodeSuccess(void) { + const struct DeviceResourceNode *audioNode = NULL; + struct DeviceResourceAttr *pp = NULL; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *audioNode = g_devResInstance->GetChildNode(g_testRoot, AUDIO_INFO); + audioNode = g_devResInstance->GetChildNode(g_testRoot, AUDIO_INFO); if (audioNode == NULL) { return HDF_FAILURE; } - struct DeviceResourceAttr *pp = NULL; DEV_RES_NODE_FOR_EACH_ATTR(audioNode, pp) { if ((pp == NULL) || (pp->name == NULL)) { break; @@ -841,14 +901,16 @@ int HcsTestTraverseAttrInNodeSuccess(void) int HcsTestTraverseAttrInNodeFail(void) { + const struct DeviceResourceNode *fingerprintNode = NULL; + struct DeviceResourceAttr *pp = NULL; + const struct DeviceResourceNode *childNode = NULL; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *fingerprintNode = g_devResInstance->GetChildNode(g_testRoot, FINGERPRINT_INFO); + fingerprintNode = g_devResInstance->GetChildNode(g_testRoot, FINGERPRINT_INFO); if (fingerprintNode == NULL) { return HDF_FAILURE; } - struct DeviceResourceAttr *pp = NULL; DEV_RES_NODE_FOR_EACH_ATTR(fingerprintNode, pp) { if ((pp == NULL) || (pp->name == NULL)) { break; @@ -863,7 +925,6 @@ int HcsTestTraverseAttrInNodeFail(void) return HDF_FAILURE; } - const struct DeviceResourceNode *childNode = NULL; DEV_RES_NODE_FOR_EACH_CHILD_NODE(fingerprintNode, childNode) { if ((childNode == NULL) || (childNode->name == NULL)) { break; @@ -882,12 +943,14 @@ int HcsTestTraverseAttrInNodeFail(void) int HcsTestGetStringSuccess(void) { + const struct DeviceResourceNode *audioNode = NULL; + const char *type = NULL; + int32_t readString; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); - const char *type = NULL; - int32_t readString = g_devResInstance->GetString(audioNode, "cust_name", &type, NULL); + audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); + readString = g_devResInstance->GetString(audioNode, "cust_name", &type, NULL); if ((readString != HDF_SUCCESS) || (type == NULL) || (strcmp(type, "audio_custom_v2") != HDF_SUCCESS)) { return HDF_FAILURE; } @@ -896,12 +959,14 @@ int HcsTestGetStringSuccess(void) int HcsTestGetStringFail(void) { + const struct DeviceResourceNode *audioNode = NULL; + const char *type = NULL; + int32_t testReadString; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); - const char *type = NULL; - int32_t testReadString = g_devResInstance->GetString(audioNode, INVALID_STRING, &type, STRING_ATTR_VALUE); + audioNode = g_devResInstance->GetNodeByMatchAttr(g_testRoot, HW_AUDIO_INFO); + testReadString = g_devResInstance->GetString(audioNode, INVALID_STRING, &type, STRING_ATTR_VALUE); if ((testReadString == HDF_SUCCESS) || (type == NULL) || (strcmp(type, STRING_ATTR_VALUE) != HDF_SUCCESS)) { return HDF_FAILURE; } @@ -918,13 +983,15 @@ int HcsTestGetStringFail(void) int HcsTestGetStringArrayElemSuccess(void) { + const char *rawDataDts = NULL; + const struct DeviceResourceNode *fingerprintNode = NULL; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const char *rawDataDts = NULL; - const struct DeviceResourceNode *fingerprintNode = g_devResInstance->GetChildNode(g_testRoot, FINGERPRINT_INFO); + fingerprintNode = g_devResInstance->GetChildNode(g_testRoot, FINGERPRINT_INFO); // the third param(0) is the location in string_list_names array. - int32_t ret = g_devResInstance->GetStringArrayElem(fingerprintNode, STRING_LIST_NAMES, 0, &rawDataDts, NULL); + ret = g_devResInstance->GetStringArrayElem(fingerprintNode, STRING_LIST_NAMES, 0, &rawDataDts, NULL); if ((ret != HDF_SUCCESS) || (strcmp(rawDataDts, "first") != HDF_SUCCESS)) { return HDF_FAILURE; } @@ -943,14 +1010,15 @@ int HcsTestGetStringArrayElemSuccess(void) int HcsTestGetStringArrayElemFail(void) { + const char *rawDataDts = NULL; + const struct DeviceResourceNode *fingerprintNode = NULL; + int32_t ret; if (!TestGetRootNode()) { return HDF_FAILURE; } - const char *rawDataDts = NULL; - const struct DeviceResourceNode *fingerprintNode = g_devResInstance->GetChildNode(g_testRoot, FINGERPRINT_INFO); + fingerprintNode = g_devResInstance->GetChildNode(g_testRoot, FINGERPRINT_INFO); // the third param(3) is the location in string_list_names array. - int32_t ret = g_devResInstance->GetStringArrayElem(fingerprintNode, STRING_LIST_NAMES, 3, &rawDataDts, - STRING_ATTR_VALUE); + ret = g_devResInstance->GetStringArrayElem(fingerprintNode, STRING_LIST_NAMES, 3, &rawDataDts, STRING_ATTR_VALUE); if ((ret == HDF_SUCCESS) || (strcmp(rawDataDts, STRING_ATTR_VALUE) != HDF_SUCCESS)) { return HDF_FAILURE; } @@ -981,11 +1049,13 @@ int HcsTestGetStringArrayElemFail(void) int HcsTestGetNodeAttrRefSuccess(void) { + const struct DeviceResourceNode *fingerprintNode = NULL; + const struct DeviceResourceNode *ret = NULL; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *fingerprintNode = g_devResInstance->GetChildNode(g_testRoot, FINGERPRINT_INFO); - const struct DeviceResourceNode *ret = g_devResInstance->GetNodeByRefAttr(fingerprintNode, FINGER_INFO); + fingerprintNode = g_devResInstance->GetChildNode(g_testRoot, FINGERPRINT_INFO); + ret = g_devResInstance->GetNodeByRefAttr(fingerprintNode, FINGER_INFO); if (ret == NULL) { return HDF_FAILURE; } @@ -998,11 +1068,13 @@ int HcsTestGetNodeAttrRefSuccess(void) int HcsTestGetNodeAttrRefFail(void) { + const struct DeviceResourceNode *fingerprintNode = NULL; + const struct DeviceResourceNode *ret = NULL; if (!TestGetRootNode()) { return HDF_FAILURE; } - const struct DeviceResourceNode *fingerprintNode = g_devResInstance->GetChildNode(g_testRoot, FINGERPRINT_INFO); - const struct DeviceResourceNode *ret = g_devResInstance->GetNodeByRefAttr(fingerprintNode, DUAL_FINGERPRINT); + fingerprintNode = g_devResInstance->GetChildNode(g_testRoot, FINGERPRINT_INFO); + ret = g_devResInstance->GetNodeByRefAttr(fingerprintNode, DUAL_FINGERPRINT); if (ret != NULL) { return HDF_FAILURE; } diff --git a/test/unittest/ability/config/hcs_parser/unittest/hcs_config_test.h b/test/unittest/utils/hcs_parser/unittest/hcs_config_test.h similarity index 100% rename from test/unittest/ability/config/hcs_parser/unittest/hcs_config_test.h rename to test/unittest/utils/hcs_parser/unittest/hcs_config_test.h diff --git a/test/unittest/utils/hcs_parser/unittest/hcs_macro_cases.c b/test/unittest/utils/hcs_parser/unittest/hcs_macro_cases.c new file mode 100755 index 0000000000000000000000000000000000000000..d388cbaaaef5ceffbab8bf8fd39c86d21cdb78d8 --- /dev/null +++ b/test/unittest/utils/hcs_parser/unittest/hcs_macro_cases.c @@ -0,0 +1,399 @@ +/* + * 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_log.h" +#include "hcs_macro.h" +#include "hdf_macro_test.h" + +#define HDF_LOG_TAG hcs_macro_cases + +#define AUDIO_INFO_NODE_SMARTPA_ADDR 65536 +#define AUDIO_INFO_NODE_SMARTPA_NUM 1 +#define AUDIO_INFO_NODE_BUILDIN_PRIMARY_MIC_EXIST 1 +#define AUDIO_INFO_NODE_BUILDIN_SECOND_MIC_EXIST 1 +#define AUDIO_INFO_NODE_VOICE_LEVEL 256 +#define AUDIO_INFO_NODE_U64_DATA 0x100000000 +#define FP_NODE_U32_IDX_SIZE 3 +#define FP_INFO_NODE_STR_LIST_SIZE 3 +#define DATA_TEST_NODE_FOUR_DATA_SIZE 4 +#define DATA_TEST_NODE_U8_DATA_SIZE 8 +#define DATA_TEST_NODE_U16_DATA_SIZE 8 +#define BOARD_ID_DATA_SIZE 2 +#define MODEM_ID_DATA_SIZE 2 +#define BOARD_ID_VALUE 8000 +#define FP_ONE_IDX 0 +#define FP_TWO_IDX 1 +#define FP_THREE_IDX 2 + +#define CHECK_STRING_EQU(part1, part2) \ + if (strcmp(part1, part2)) { \ + HDF_LOGE("%s %s %d\n", part1, part2, __LINE__); \ + return HDF_FAILURE; \ + } + +#define CHECK_INT_EQU(part1, part2) \ + if ((part1) != (part2)) { \ + HDF_LOGE("%d\n", __LINE__); \ + return HDF_FAILURE; \ + } + +#define FP_CHILD_DEAL(node) \ + CHECK_STRING_EQU(HCS_PROP(node, status), g_fpData[index].child.status); + +#define FP_DEAL(node) \ + do { \ + CHECK_STRING_EQU(HCS_PROP(node, product), g_fpData[index].product); \ + CHECK_STRING_EQU(HCS_PROP(node, chip), g_fpData[index].chip); \ + node##_foreach_child(FP_CHILD_DEAL); \ + CHECK_STRING_EQU(HCS_PROP(node, status), g_fpData[index].status); \ + index++; \ + } while (0); + +#define FP_DEAL_(node) FP_DEAL(node) + +#define FP_CHILD_DEAL_VARGS(node, fpArgs, idx) \ + CHECK_STRING_EQU(HCS_PROP(node, status), fpArgs[idx].child.status); + +#define FP_DEAL_VARGS(node, fpArgs, idx) \ + do { \ + CHECK_STRING_EQU(HCS_PROP(node, product), fpArgs[(idx)].product); \ + CHECK_STRING_EQU(HCS_PROP(node, chip), fpArgs[(idx)].chip); \ + node##_foreach_child_vargs(FP_CHILD_DEAL_VARGS, fpArgs, idx); \ + CHECK_STRING_EQU(HCS_PROP(node, status), fpArgs[(idx)].status); \ + (idx)++; \ + } while (0); + +#define FP_DEAL_VARGS_(node, fpArgs, idx) FP_DEAL_VARGS(node, fpArgs, idx) + +struct OneChild { + const char *status; +}; +struct FingerPrint { + const char *product; + const char *chip; + struct OneChild child; + const char *status; +}; + +#define AUDIO_INFO_NODE HCS_NODE(HCS_ROOT, audio_info) +#define FP_INFO_NODE HCS_NODE(HCS_ROOT, fingerprint_info) +#define FP_INFO_ONE_NODE HCS_NODE(FP_INFO_NODE, fingerprint_one) +#define FP_INFO_TWO_NODE HCS_NODE(FP_INFO_NODE, fingerprint_two) +#define DATA_TYPE_TEST_NODE HCS_NODE(HCS_ROOT, data_type_test) +#define FP_INFO_THREE_NODE HCS_NODE(HCS_ROOT, fingerprint_three) +#define FP_INFO_AUDIO_NODE HCS_NODE(FP_INFO_NODE, audio_info) + +static struct FingerPrint g_fpData[] = { + { "test", "one", { "ok" }, "ok" }, + { "test", "two", { "ok" }, "disable" }, + { "test", "three", { "ok" }, "disable" } +}; + +static int TraversalInfoReadU32(void) +{ + const uint32_t infoReadU32[] = { 1, 256, 65536 }; + const uint32_t infoReadU32Gen[] = HCS_ARRAYS(HCS_NODE(FP_INFO_NODE, read_u32_index)); + int i; + + for (i = 0; i < HCS_ARRAYS_SIZE(HCS_NODE(FP_INFO_NODE, read_u32_index)); i++) { + CHECK_INT_EQU(infoReadU32Gen[i], infoReadU32[i]); + } + + return HDF_SUCCESS; +} + +static int TraversalStringListNames(void) +{ + const char *stringListNames[] = {"first", "second", "third"}; + const char *stringListNamesGen[] = HCS_ARRAYS(HCS_NODE(FP_INFO_NODE, string_list_names)); + int i; + + for (i = 0; i < HCS_ARRAYS_SIZE(HCS_NODE(FP_INFO_NODE, string_list_names)); i++) { + CHECK_STRING_EQU(stringListNamesGen[i], stringListNames[i]); + } + + return HDF_SUCCESS; +} + +static int TraversalReadFourDatas(void) +{ + const uint64_t readFourDatas[] = { 0x1, 0x100, 0x10000, 0x100000000 }; + const uint64_t readFourDatasGen[] = HCS_ARRAYS(HCS_NODE(DATA_TYPE_TEST_NODE, read_four_data_type)); + int i; + + for (i = 0; i < HCS_ARRAYS_SIZE(HCS_NODE(DATA_TYPE_TEST_NODE, read_four_data_type)); i++) { + CHECK_INT_EQU(readFourDatasGen[i], readFourDatas[i]); + } + + return HDF_SUCCESS; +} + +static int TraversalTestU8ElemData(void) +{ + const uint8_t testU8ElemData[] = { 0, 1, 2, 3, 4, 5, 6, 7 }; + const uint8_t testU8ElemDataGen[] = HCS_ARRAYS(HCS_NODE(DATA_TYPE_TEST_NODE, test_u8_elem_data)); + int i; + + for (i = 0; i < HCS_ARRAYS_SIZE(HCS_NODE(DATA_TYPE_TEST_NODE, test_u8_elem_data)); i++) { + CHECK_INT_EQU(testU8ElemDataGen[i], testU8ElemData[i]); + } + + return HDF_SUCCESS; +} +static int TraversalTestU16ElemData(void) +{ + const uint16_t testU16ElemData[] = { 0, 1, 2, 3, 4, 5, 256, 257 }; + const uint16_t testU16ElemDataGen[] = HCS_ARRAYS(HCS_NODE(DATA_TYPE_TEST_NODE, test_u16_elem_data)); + int i; + + for (i = 0; i < HCS_ARRAYS_SIZE(HCS_NODE(DATA_TYPE_TEST_NODE, test_u16_elem_data)); i++) { + CHECK_INT_EQU(testU16ElemDataGen[i], testU16ElemData[i]); + } + + return HDF_SUCCESS; +} +static int TraversalBoardId(void) +{ + const uint32_t boardId[] = { 65536, 256 }; + const uint32_t boardIdGen[] = HCS_ARRAYS(HCS_NODE(HCS_ROOT, board_id)); + int i; + + for (i = 0; i < HCS_ARRAYS_SIZE(HCS_NODE(HCS_ROOT, board_id)); i++) { + CHECK_INT_EQU(boardIdGen[i], boardId[i]); + } + + return HDF_SUCCESS; +} +static int TraversalModemId(void) +{ + const uint32_t modemId[] = { 0xF6B40136, 0x0 }; + const uint32_t modemIdGen[] = HCS_ARRAYS(HCS_NODE(HCS_ROOT, modem_id)); + int i; + + for (i = 0; i < HCS_ARRAYS_SIZE(HCS_NODE(HCS_ROOT, modem_id)); i++) { + CHECK_INT_EQU(modemIdGen[i], modemId[i]); + } + + return HDF_SUCCESS; +} + +static int TraversalAudio(void) +{ + CHECK_STRING_EQU(HCS_PROP(AUDIO_INFO_NODE, match_attr), "hw,hw_audio_info"); + CHECK_STRING_EQU(HCS_PROP(AUDIO_INFO_NODE, pa_identifier), "smartpakit"); + CHECK_INT_EQU(HCS_PROP(AUDIO_INFO_NODE, smartpa_addr), AUDIO_INFO_NODE_SMARTPA_ADDR); + CHECK_INT_EQU(HCS_PROP(AUDIO_INFO_NODE, smartpa_num), AUDIO_INFO_NODE_SMARTPA_NUM); + CHECK_INT_EQU(HCS_PROP(AUDIO_INFO_NODE, builtin_primary_mic_exist), AUDIO_INFO_NODE_BUILDIN_PRIMARY_MIC_EXIST); + CHECK_INT_EQU(HCS_PROP(AUDIO_INFO_NODE, builtin_second_mic_exist), AUDIO_INFO_NODE_BUILDIN_SECOND_MIC_EXIST); + CHECK_INT_EQU(HCS_PROP(AUDIO_INFO_NODE, voice_vol_level), AUDIO_INFO_NODE_VOICE_LEVEL); + CHECK_STRING_EQU(HCS_PROP(AUDIO_INFO_NODE, cust_name), "audio_custom_v2"); + CHECK_STRING_EQU(HCS_PROP(AUDIO_INFO_NODE, dual_smartpa_delay), "true"); + CHECK_INT_EQU(HCS_PROP(AUDIO_INFO_NODE, read_u64data), AUDIO_INFO_NODE_U64_DATA); + CHECK_STRING_EQU(HCS_PROP(AUDIO_INFO_NODE, status), "ok"); + + return HDF_SUCCESS; +} + +static int TraversalFPFingerInfo(void) +{ + int index = FP_ONE_IDX; + FP_DEAL_(HCS_NODE(FP_INFO_NODE, finger_info)); + return HDF_SUCCESS; +} + +static int TraversalFPAudio(void) +{ + CHECK_STRING_EQU(HCS_PROP(FP_INFO_AUDIO_NODE, match_attr), "hw,hw_audio_info"); + CHECK_STRING_EQU(HCS_PROP(FP_INFO_AUDIO_NODE, pa_identifier), "smartpakit"); + CHECK_INT_EQU(HCS_PROP(FP_INFO_AUDIO_NODE, smartpa_addr), AUDIO_INFO_NODE_SMARTPA_ADDR); + CHECK_INT_EQU(HCS_PROP(FP_INFO_AUDIO_NODE, smartpa_num), AUDIO_INFO_NODE_SMARTPA_NUM); + CHECK_INT_EQU(HCS_PROP(FP_INFO_AUDIO_NODE, builtin_primary_mic_exist), AUDIO_INFO_NODE_BUILDIN_PRIMARY_MIC_EXIST); + CHECK_INT_EQU(HCS_PROP(FP_INFO_AUDIO_NODE, builtin_second_mic_exist), AUDIO_INFO_NODE_BUILDIN_SECOND_MIC_EXIST); + CHECK_INT_EQU(HCS_PROP(FP_INFO_AUDIO_NODE, voice_vol_level), AUDIO_INFO_NODE_VOICE_LEVEL); + CHECK_STRING_EQU(HCS_PROP(FP_INFO_AUDIO_NODE, cust_name), "audio_custom_v2"); + CHECK_STRING_EQU(HCS_PROP(FP_INFO_AUDIO_NODE, dual_smartpa_delay), "true"); + CHECK_INT_EQU(HCS_PROP(FP_INFO_AUDIO_NODE, read_u64data), AUDIO_INFO_NODE_U64_DATA); + CHECK_STRING_EQU(HCS_PROP(FP_INFO_AUDIO_NODE, status), "ok"); + return HDF_SUCCESS; +} + +static int TraversalFPOne(void) +{ + int index = FP_ONE_IDX; + FP_DEAL_(HCS_NODE(FP_INFO_NODE, fingerprint_one)); + index = FP_ONE_IDX; + FP_DEAL_VARGS_(HCS_NODE(FP_INFO_NODE, fingerprint_one), g_fpData, index); + return HDF_SUCCESS; +} + +static int TraversalFPTwo(void) +{ + int index = FP_TWO_IDX; + FP_DEAL_(HCS_NODE(FP_INFO_NODE, fingerprint_two)); + index = FP_TWO_IDX; + FP_DEAL_VARGS_(HCS_NODE(FP_INFO_NODE, fingerprint_two), g_fpData, index); + return HDF_SUCCESS; +} + +static int TraversalPringerprintThree(void) +{ + int index = FP_THREE_IDX; + FP_DEAL_(HCS_NODE(HCS_ROOT, fingerprint_three)); + index = FP_THREE_IDX; + FP_DEAL_VARGS_(HCS_NODE(HCS_ROOT, fingerprint_three), g_fpData, index); + return HDF_SUCCESS; +} + +static int TraversalFPInfo(void) +{ + CHECK_STRING_EQU(HCS_PROP(FP_INFO_NODE, match_attr), "hw,hw_fingerprint_info"); + CHECK_INT_EQU(TraversalInfoReadU32(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalFPFingerInfo(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalFPAudio(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalFPOne(), HDF_SUCCESS); + CHECK_STRING_EQU(HCS_PROP(FP_INFO_NODE, dual_fingerprint), "false"); + CHECK_INT_EQU(TraversalFPTwo(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalStringListNames(), HDF_SUCCESS); + CHECK_STRING_EQU(HCS_PROP(FP_INFO_NODE, status), "ok"); + + return HDF_SUCCESS; +} + +static int TraversalDataTypeTest(void) +{ + CHECK_STRING_EQU(HCS_PROP(DATA_TYPE_TEST_NODE, match_attr), "hw,data_type_test"); + CHECK_INT_EQU(TraversalReadFourDatas(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalTestU8ElemData(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalTestU16ElemData(), HDF_SUCCESS); + return HDF_SUCCESS; +} + +int HcsMacroGetOneNode(void) +{ + CHECK_STRING_EQU(HCS_PROP(AUDIO_INFO_NODE, match_attr), "hw,hw_audio_info"); + return HDF_SUCCESS; +} + +int HcsMacroCheckNodeExists(void) +{ +#if HCS_NODE_EXISTS(AUDIO_INFO_NODE) + CHECK_STRING_EQU(HCS_PROP(AUDIO_INFO_NODE, match_attr), "hw,hw_audio_info"); + return HDF_SUCCESS; +#else + return HDF_FAILURE; +#endif +} + +int HcsMacroCheckNodeNotExists(void) +{ +#if HCS_NODE_EXISTS(HCS_NODE(AUDIO_INFO_NODE, node_not_exists)) + return HDF_FAILURE; +#else + return HDF_SUCCESS; +#endif +} + +int HcsMacroCheckPropExists(void) +{ +#if HCS_NODE_HAS_PROP(AUDIO_INFO_NODE, match_attr) + CHECK_STRING_EQU(HCS_PROP(AUDIO_INFO_NODE, match_attr), "hw,hw_audio_info"); + return HDF_SUCCESS; +#else + return HDF_FAILURE; +#endif +} + +int HcsMacroCheckPropNotExists(void) +{ +#if HCS_NODE_HAS_PROP(AUDIO_INFO_NODE, prop_not_exists) + return HDF_FAILURE; +#else + return HDF_SUCCESS; +#endif +} + +int HcsMacroGetOneNodeProp(void) +{ + CHECK_STRING_EQU(HCS_PROP(AUDIO_INFO_NODE, pa_identifier), "smartpakit"); + return HDF_SUCCESS; +} + +int HcsMacroTraversalOneNode(void) +{ + return TraversalAudio(); +} + +int HcsMacroGetArraySize(void) +{ + CHECK_INT_EQU(HCS_ARRAYS_SIZE(HCS_NODE(FP_INFO_NODE, read_u32_index)), FP_NODE_U32_IDX_SIZE); + CHECK_INT_EQU(HCS_ARRAYS_SIZE(HCS_NODE(FP_INFO_NODE, string_list_names)), FP_INFO_NODE_STR_LIST_SIZE); + CHECK_INT_EQU(HCS_ARRAYS_SIZE(HCS_NODE(DATA_TYPE_TEST_NODE, read_four_data_type)), DATA_TEST_NODE_FOUR_DATA_SIZE); + CHECK_INT_EQU(HCS_ARRAYS_SIZE(HCS_NODE(DATA_TYPE_TEST_NODE, test_u8_elem_data)), DATA_TEST_NODE_U8_DATA_SIZE); + CHECK_INT_EQU(HCS_ARRAYS_SIZE(HCS_NODE(DATA_TYPE_TEST_NODE, test_u16_elem_data)), DATA_TEST_NODE_U16_DATA_SIZE); + CHECK_INT_EQU(HCS_ARRAYS_SIZE(HCS_NODE(HCS_ROOT, board_id)), BOARD_ID_DATA_SIZE); + CHECK_INT_EQU(HCS_ARRAYS_SIZE(HCS_NODE(HCS_ROOT, modem_id)), MODEM_ID_DATA_SIZE); + return HDF_SUCCESS; +} + +int HcsMacroGetArrayElement(void) +{ + const uint32_t infoReadU32[] = { 1, 256, 65536 }; + const uint32_t infoReadU32Gen[] = HCS_ARRAYS(HCS_NODE(FP_INFO_NODE, read_u32_index)); + + CHECK_INT_EQU(infoReadU32Gen[0], infoReadU32[0]); + + return HDF_SUCCESS; +} + +int HcsMacroTraversalOneArray(void) +{ + return TraversalInfoReadU32(); +} + +int HcsMacroTraversalAllArray(void) +{ + CHECK_INT_EQU(TraversalInfoReadU32(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalStringListNames(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalReadFourDatas(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalTestU8ElemData(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalTestU16ElemData(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalBoardId(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalModemId(), HDF_SUCCESS); + return HDF_SUCCESS; +} + +int HcsMacroTraversalOneNodeChild(void) +{ + int index = 0; + + HCS_FOREACH_CHILD(FP_INFO_NODE, FP_DEAL); + return HDF_SUCCESS; +} + +int HcsMacroTraversalOneNodeChildVargs(void) +{ + int index = 0; + + HCS_FOREACH_CHILD_VARGS(FP_INFO_NODE, FP_DEAL_VARGS, g_fpData, index); + return HDF_SUCCESS; +} + +int HcsMacroGetOneFile(void) +{ + CHECK_STRING_EQU(HCS_PROP(HCS_ROOT, match_attr), "test,config"); + CHECK_INT_EQU(TraversalAudio(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalFPInfo(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalDataTypeTest(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalBoardId(), HDF_SUCCESS); + CHECK_STRING_EQU(HCS_PROP(HCS_ROOT, support_Device), "TP LCD Sensor"); + CHECK_INT_EQU(TraversalPringerprintThree(), HDF_SUCCESS); + CHECK_INT_EQU(TraversalModemId(), HDF_SUCCESS); + CHECK_INT_EQU(HCS_PROP(HCS_ROOT, boardId), BOARD_ID_VALUE); + + return HDF_SUCCESS; +} diff --git a/test/unittest/utils/hcs_parser/unittest/hcs_macro_cases.h b/test/unittest/utils/hcs_parser/unittest/hcs_macro_cases.h new file mode 100755 index 0000000000000000000000000000000000000000..e6f20857e17343e1690bde49a4bf19cdd731e8db --- /dev/null +++ b/test/unittest/utils/hcs_parser/unittest/hcs_macro_cases.h @@ -0,0 +1,39 @@ +/* + * 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 HCS_MACRO_CASES_H +#define HCS_MACRO_CASES_H + +#ifdef __cplusplus +#if __cplusplus +extern "C" { +#endif +#endif /* __cplusplus */ + +int HcsMacroGetOneNode(void); +int HcsMacroCheckNodeExists(void); +int HcsMacroCheckNodeNotExists(void); +int HcsMacroCheckPropExists(void); +int HcsMacroCheckPropNotExists(void); +int HcsMacroGetOneNodeProp(void); +int HcsMacroTraversalOneNode(void); +int HcsMacroGetArraySize(void); +int HcsMacroGetArrayElement(void); +int HcsMacroTraversalOneArray(void); +int HcsMacroTraversalAllArray(void); +int HcsMacroTraversalOneNodeChild(void); +int HcsMacroTraversalOneNodeChildVargs(void); +int HcsMacroGetOneFile(void); + +#ifdef __cplusplus +#if __cplusplus +} +#endif +#endif /* __cplusplus */ + +#endif /* HCS_MACRO_CASES_H */ diff --git a/test/unittest/config/hdf_config_test.c b/test/unittest/utils/hcs_parser/unittest/hcs_parser_test.c similarity index 80% rename from test/unittest/config/hdf_config_test.c rename to test/unittest/utils/hcs_parser/unittest/hcs_parser_test.c index 7cf001db626bbddcf7bb66146bce60ad19386990..d2cb0460187e41cdef93eab3710fe50ad835f355 100644 --- a/test/unittest/config/hdf_config_test.c +++ b/test/unittest/utils/hcs_parser/unittest/hcs_parser_test.c @@ -6,12 +6,9 @@ * See the LICENSE file in the root of this repository for complete details. */ -#include "hdf_config_test.h" -#include "device_resource_if.h" +#include "hcs_parser_test.h" #include "hcs_config_test.h" -#include "hdf_base.h" -#include "hdf_log.h" -#include "osal_mem.h" +#include "hcs_macro_cases.h" // add test case entry HdfTestCaseList g_hdfConfigTestCaseList[] = { @@ -56,6 +53,20 @@ HdfTestCaseList g_hdfConfigTestCaseList[] = { { HDF_GET_STRING_ARRAY_ELEM_ATTR_VALUE_002, HcsTestGetStringArrayElemFail }, { HDF_GET_NODE_BY_ATTR_REF_001, HcsTestGetNodeAttrRefSuccess }, { HDF_GET_NODE_BY_ATTR_REF_002, HcsTestGetNodeAttrRefFail }, + { HDF_MACRO_GET_ONE_NODE, HcsMacroGetOneNode }, + { HDF_MACRO_CHECK_NODE_EXISTS, HcsMacroCheckNodeExists }, + { HDF_MACRO_CHECK_NODE_NOT_EXISTS, HcsMacroCheckNodeNotExists }, + { HDF_MACRO_GET_ONE_NODE_PROP, HcsMacroCheckPropExists }, + { HDF_MACRO_CHECK_NODE_PROP_EXISTS, HcsMacroCheckPropNotExists }, + { HDF_MACRO_CHECK_NODE_PROP_NOT_EXISTS, HcsMacroGetOneNodeProp }, + { HDF_MACRO_TRAVERSAL_ONE_NODE, HcsMacroTraversalOneNode }, + { HDF_MACRO_GET_ARRAY_SIZE, HcsMacroGetArraySize }, + { HDF_MACRO_GET_ONE_ARRAY_ELEMENT, HcsMacroGetArrayElement }, + { HDF_MACRO_TRAVERSAL_ONE_ARRAY, HcsMacroTraversalOneArray }, + { HDF_MACRO_TRAVERSAL_ALL_ARRAY, HcsMacroTraversalAllArray }, + { HDF_MACRO_TRAVERSAL_NODE_CHILD, HcsMacroTraversalOneNodeChild }, + { HDF_MACRO_TRAVERSAL_NODE_CHILD_VARGS, HcsMacroTraversalOneNodeChildVargs }, + { HDF_MACRO_GET_ONE_FILE, HcsMacroGetOneFile }, }; int32_t HdfConfigEntry(HdfTestMsg *msg) diff --git a/test/unittest/config/hdf_config_test.h b/test/unittest/utils/hcs_parser/unittest/hcs_parser_test.h similarity index 77% rename from test/unittest/config/hdf_config_test.h rename to test/unittest/utils/hcs_parser/unittest/hcs_parser_test.h index 8c7193001277382138766c0144d2d7df798e48fd..12ffe49e0947cbaf28f124ea8d160507b43fa203 100644 --- a/test/unittest/config/hdf_config_test.h +++ b/test/unittest/utils/hcs_parser/unittest/hcs_parser_test.h @@ -6,8 +6,8 @@ * See the LICENSE file in the root of this repository for complete details. */ -#ifndef HDF_CONFIG_TEST_H -#define HDF_CONFIG_TEST_H +#ifndef HCS_PARSER_TEST_H +#define HCS_PARSER_TEST_H #include "hdf_main_test.h" @@ -53,8 +53,22 @@ enum HdfConfigTestCaseCmd { HDF_GET_STRING_ARRAY_ELEM_ATTR_VALUE_002, HDF_GET_NODE_BY_ATTR_REF_001, HDF_GET_NODE_BY_ATTR_REF_002, + HDF_MACRO_GET_ONE_NODE, + HDF_MACRO_CHECK_NODE_EXISTS, + HDF_MACRO_CHECK_NODE_NOT_EXISTS, + HDF_MACRO_GET_ONE_NODE_PROP, + HDF_MACRO_CHECK_NODE_PROP_EXISTS, + HDF_MACRO_CHECK_NODE_PROP_NOT_EXISTS, + HDF_MACRO_TRAVERSAL_ONE_NODE, + HDF_MACRO_GET_ARRAY_SIZE, + HDF_MACRO_GET_ONE_ARRAY_ELEMENT, + HDF_MACRO_TRAVERSAL_ONE_ARRAY, + HDF_MACRO_TRAVERSAL_ALL_ARRAY, + HDF_MACRO_TRAVERSAL_NODE_CHILD, + HDF_MACRO_TRAVERSAL_NODE_CHILD_VARGS, + HDF_MACRO_GET_ONE_FILE, }; int32_t HdfConfigEntry(HdfTestMsg *msg); -#endif // HDF_CONFIG_TEST_H +#endif // HCS_PARSER_TEST_H diff --git a/tools/hc-gen/BUILD.gn b/tools/hc-gen/BUILD.gn new file mode 100644 index 0000000000000000000000000000000000000000..a1340fe01aea1c5e285abb2a85832b4ba8b82d40 --- /dev/null +++ b/tools/hc-gen/BUILD.gn @@ -0,0 +1,20 @@ +# Copyright (c) 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. + +action("build_hc_gen") { + script = "/usr/bin/env" + if (defined(ohos_lite)) { + script = "//build/lite/run_shell_cmd.py" + } + outputs = [ "$target_out_dir/hc-gen" ] + args = [ + "make", + "-j", + "-C", + rebase_path("."), + "BUILD_DIR=" + rebase_path(target_out_dir), + ] +} diff --git a/tools/hc-gen/hc_gen.gni b/tools/hc-gen/hc_gen.gni new file mode 100644 index 0000000000000000000000000000000000000000..ce153e3ab04819955bed6969cb8061d23f512a7c --- /dev/null +++ b/tools/hc-gen/hc_gen.gni @@ -0,0 +1,92 @@ +# Copyright (c) 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. + +template("hc_gen") { + assert(defined(invoker.sources), "sources are must") + if (defined(invoker.outputs)) { + foreach(o, invoker.outputs) { + if (o == string_replace(o, "{{", "")) { + specified_output_name = true + } + } + } + if (defined(specified_output_name) && specified_output_name) { + target_type = "action" + } else { + target_type = "action_foreach" + } + target(target_type, target_name) { + deps = [ "//drivers/framework/tools/hc-gen:build_hc_gen" ] + script = "/usr/bin/env" + if (defined(ohos_lite)) { + script = "//build/lite/run_shell_cmd.py" + } + sources = invoker.sources + if (defined(invoker.hc_gen_hex) && invoker.hc_gen_hex) { + hc_flags = [ + "-b", + "-i", + "-a", + ] + output_suffix = "_hex.c" + output_suffix2 = ".hcb" + } else if (defined(invoker.hc_gen_c) && invoker.hc_gen_c) { + hc_flags = [ "-t" ] + output_suffix = ".c" + output_suffix2 = ".h" + } else if (defined(invoker.hc_gen_macro) && invoker.hc_gen_macro) { + hc_flags = [ "-m" ] + output_suffix = ".h" + } else { + hc_flags = [] + output_suffix = ".hcb" + } + + if (defined(invoker.outputs)) { + outputs = invoker.outputs + } else { + outputs = [ "$target_gen_dir/{{source_name_part}}$output_suffix" ] + } + if (defined(output_suffix2)) { + outputs += [ string_replace(outputs[0], output_suffix, output_suffix2) ] + } + if (target_type == "action") { + src = rebase_path(sources[0], root_build_dir) + } else { + src = "{{source}}" + } + + args = [ rebase_path(get_path_info("//drivers/framework/tools/hc-gen/", + "out_dir") + "/hc-gen") ] + args += hc_flags + args += [ + "-o", + rebase_path(string_replace(outputs[0], output_suffix, "")), + src, + ] + } +} + +template("hc_gen_c") { + hc_gen_c = true + hc_gen(target_name) { + forward_variables_from(invoker, "*") + } +} + +template("hc_gen_hex") { + hc_gen_hex = true + hc_gen(target_name) { + forward_variables_from(invoker, "*") + } +} + +template("hc_gen_macro") { + hc_gen_macro = true + hc_gen(target_name) { + forward_variables_from(invoker, "*") + } +} diff --git a/tools/hc-gen/src/bytecode_gen.cpp b/tools/hc-gen/src/bytecode_gen.cpp index 88e3bc2d499480763b2f02995d327015efdbe8be..7ff30a660aa99820d9ed8a1ea09f96ae78524b33 100644 --- a/tools/hc-gen/src/bytecode_gen.cpp +++ b/tools/hc-gen/src/bytecode_gen.cpp @@ -15,7 +15,7 @@ using namespace OHOS::Hardware; ByteCodeGen::ByteCodeGen(std::shared_ptr ast) : Generator(ast), - needAlign_(false) + needAlign_(false), dummyOutput_(false), writeSize_(0) { } diff --git a/tools/hc-gen/src/lexer.cpp b/tools/hc-gen/src/lexer.cpp index 8e2cf91e52c3f5e35657b52508ad51919cee7d08..38444f648c7dcf530f632a949472e739a9b66ee8 100644 --- a/tools/hc-gen/src/lexer.cpp +++ b/tools/hc-gen/src/lexer.cpp @@ -171,7 +171,7 @@ bool Lexer::FillBuffer() bool Lexer::ProcessComment() { - char c; + char c = 0; ConsumeChar();// skip first '/' if (!GetChar(c)) { Logger().Error() << *this << "unterminated comment"; @@ -254,7 +254,7 @@ bool Lexer::LexFromString(Token &token) bool Lexer::LexFromNumber(Token &token) { std::string value; - char c; + char c = 0; uint64_t v = 0; errno = 0; diff --git a/tools/hc-gen/src/macro_gen.cpp b/tools/hc-gen/src/macro_gen.cpp new file mode 100755 index 0000000000000000000000000000000000000000..4858a0a20b0af41b0cb3b1b8667cccd8758e2184 --- /dev/null +++ b/tools/hc-gen/src/macro_gen.cpp @@ -0,0 +1,292 @@ +/* + * Copyright (c) 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 "macro_gen.h" +#include +#include "file.h" +#include "logger.h" + +using namespace OHOS::Hardware; + +constexpr static const char *FILE_HEAD_COMMENT = \ + "/*\n" \ + " * This is an automatically generated HDF config file. Do not modify it manually.\n" \ + " */\n\n"; + +MacroGen::MacroGen(std::shared_ptr ast) : Generator(ast) +{ +} + +const std::string &MacroGen::ToUpperString(std::string &str) +{ + for (char &c : str) { + c = static_cast(toupper(c)); + } + + return str; +} + +bool MacroGen::HeaderTopOutput() +{ + ofs_ << FILE_HEAD_COMMENT; + std::string defMacro = std::string().append("HCS_CONFIG_").append(ToUpperString(outFileName_)).append("_HEADER_H"); + ofs_ << "#ifndef " << defMacro << '\n'; + ofs_ << "#define " << defMacro << '\n'; + ofs_ << "\r\n#include \"hdf_base.h\"\n"; + + return true; +} + +bool MacroGen::HeaderBottomOutput() +{ + std::string defMacro = std::string().append("HCS_CONFIG_").append(ToUpperString(outFileName_)).append("_HEADER_H"); + ofs_ << "\n#endif // " << defMacro << '\n'; + ofs_.close(); + return true; +} + +bool MacroGen::Output() +{ + if (!Initialize()) { + return false; + } + if (!TemplateNodeSeparate()) { + return false; + } + if (!HeaderTopOutput()) { + return false; + } + + if (!NodeWalk()) { + return false; + } + if (!HeaderBottomOutput()) { + return false; + } + return true; +} + +bool MacroGen::Initialize() +{ + auto opt = Option::Instance(); + std::string outFileName = Option::Instance().GetOutputName(); + if (outFileName.empty()) { + outFileName = Option::Instance().GetSourceNameBase(); + } + outFileName = Util::File::StripSuffix(outFileName).append(".h"); + outFileName_ = Util::File::FileNameBase(outFileName); + if (outFileName.find(".h") == std::string::npos) { + outFileName.append(".h"); + } + + ofs_.open(outFileName, std::ofstream::out | std::ofstream::binary); + if (!ofs_.is_open()) { + Logger().Error() << "failed to open output file: " << outFileName; + return false; + } + Logger().Debug() << "output: " << outFileName << outFileName_ << '\n'; + + return true; +} + +bool MacroGen::TemplateNodeSeparate() +{ + return ast_->WalkBackward([this](std::shared_ptr &object, uint32_t depth) { + if (object->IsNode() && ConfigNode::CastFrom(object)->GetNodeType() == NODE_TEMPLATE) { + object->Separate(); + return NOERR; + } + return NOERR; + }); +} + +std::string MacroGen::GenFullName(uint32_t depth, const std::shared_ptr &node, const std::string &sep) +{ + std::string name; + for (int i = 0; i < depth; i++) { + name.append(nodeNameMap_[i]).append(sep); + } + name.append(node->Name()); + return name; +} + +bool MacroGen::GenArray(const std::string &arrName, uint32_t &arrSize, uint32_t type, + const std::shared_ptr &node) +{ + static uint32_t index = 0; + const uint32_t ELEMENT_PER_LINE = 8; + + if (index == 0) { + ofs_ << "#define " << arrName << "_data {"; + } + + if (index % ELEMENT_PER_LINE == 0) { + ofs_ << " \\\n" << TAB; + } + + if (type == PARSEROP_STRING) { + ofs_ << '"' << node->StringValue() << '"'; + } else { + ofs_ << node->IntegerValue(); + } + + index++; + if (index == arrSize) { + index = 0; + arrSize = 0; + ofs_ << " \\\n}\n"; + } else { + if (index % ELEMENT_PER_LINE == 0) { + ofs_ << ","; + } else { + ofs_ << ", "; + } + } + + return true; +} + +bool MacroGen::GenNodeForeach(uint32_t depth, const std::shared_ptr &node) +{ + std::list subList; + auto child = node->Child(); + uint32_t count = 0; + + Logger().Debug() << "node:" << node->Name() << " child:" << " depth:" << depth; + while (child != nullptr) { + if (child->IsNode()) { + Logger().Debug() << " " << child->Name(); + subList.push_back(GenFullName(depth + 1, child, "_")); + count++; + } + child = child->Next(); + } + + ofs_ << "// hcs node macros: " << GenFullName(depth, node, "/") << std::endl; + ofs_ << "#define " << GenFullName(depth, node, "_").append("_exists 1") << std::endl; + if (count) { + uint32_t index = count; + std::list::iterator iter; + + ofs_ << "#define " << GenFullName(depth, node, "_").append("_foreach_child(func)") << " \\\n"; + for (iter = subList.begin(); iter != subList.end(); iter++) { + index--; + if (index) { + ofs_ << TAB << "func(" << *iter << ") \\\n"; + } else { + ofs_ << TAB << "func(" << *iter << ")\n"; + } + } + ofs_ << std::endl; + + index = count; + ofs_ << "#define " << GenFullName(depth, node, "_").append("_foreach_child_vargs(func, ...)") << " \\\n"; + for (iter = subList.begin(); iter != subList.end(); iter++) { + index--; + if (index) { + ofs_ << TAB << "func(" << *iter << ", __VA_ARGS__) \\\n"; + } else { + ofs_ << TAB << "func(" << *iter << ", __VA_ARGS__)\n"; + } + } + ofs_ << std::endl; + } + + return true; +} + +std::string MacroGen::GenRefObjName(uint32_t depth, const std::shared_ptr &object) +{ + std::string name(object->StringValue()); + if (name.find(".") == std::string::npos) { + name = GenFullName(depth - 1, object, "_").append(object->StringValue()); + } else { + for (char &c : name) { + if (c == '.') { + c = '_'; + } + } + } + return name; +} + +bool MacroGen::NodeWalk() +{ + return ast_->WalkForward([this](std::shared_ptr ¤t, uint32_t depth) { + auto type = current->Type(); + static uint32_t arraySize = 0; + + Logger().Debug() << "name,type:[" << current->Name() << "," << type \ + << "] depth:" << depth \ + << " arraySize:" << std::dec << arraySize << '\n'; + SetTypeData(type, current, arraySize, depth); + + return NOERR; + }); +} + +void MacroGen::SetTypeData(uint32_t type, const std::shared_ptr ¤t, + uint32_t &arraySize, uint32_t depth) +{ + static std::string nodeName; + static std::string arrayName; + static uint32_t arrayType = 0; + switch (type) { + case PARSEROP_UINT8: + case PARSEROP_UINT16: + case PARSEROP_UINT32: + case PARSEROP_UINT64: { + SetTypeDataUinit64(arrayName, arraySize, arrayType, current); + break; + } + case PARSEROP_STRING: + if (arraySize != 0) { + GenArray(arrayName, arraySize, arrayType, current); + } else { + ofs_ << " " << '"' << current->StringValue() << '"' << std::endl; + } + break; + case PARSEROP_CONFTERM: + ofs_ << "#define " << GenFullName(depth, current, "_") << "_exists 1" << std::endl; + ofs_ << "#define " << GenFullName(depth, current, "_"); + break; + case PARSEROP_CONFNODE: { + if (nodeName != current->Name()) { + ofs_ << std::endl; + } + nodeName = current->Name(); + nodeNameMap_[depth] = nodeName; + GenNodeForeach(depth, current); + break; + } + case PARSEROP_ARRAY: { + std::shared_ptr parent(current->Parent()); + arraySize = ConfigArray::CastFrom(current)->ArraySize(); + arrayType = ConfigArray::CastFrom(current)->ArrayType(); + ofs_ << "_array_size " << arraySize << std::endl; + arrayName = GenFullName(depth - 1, parent, "_"); + break; + } + case PARSEROP_NODEREF: { + ofs_ << " " << GenRefObjName(depth, current) << std::endl; + break; + } + default: + break; + } +} + +void MacroGen::SetTypeDataUinit64(const std::string &arrayName, uint32_t &arraySize, uint32_t arrayType, + const std::shared_ptr ¤t) +{ + if (arraySize != 0) { + GenArray(arrayName, arraySize, arrayType, current); + } else { + ofs_ << " " << current->IntegerValue() << std::endl; + } +} \ No newline at end of file diff --git a/tools/hc-gen/src/macro_gen.h b/tools/hc-gen/src/macro_gen.h new file mode 100755 index 0000000000000000000000000000000000000000..9325d3e1a46903e405093208eabcbe2adc653a5e --- /dev/null +++ b/tools/hc-gen/src/macro_gen.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 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 HC_GEN_MACRO_GEN_H +#define HC_GEN_MACRO_GEN_H + +#include "generator.h" +#include +#include + +namespace OHOS { +namespace Hardware { +class MacroGen : public Generator { +public: + explicit MacroGen(std::shared_ptr ast); + + ~MacroGen() override = default; + + bool Output() override; + +private: + bool Initialize(); + + bool TemplateNodeSeparate(); + + std::string GenFullName(uint32_t depth, const std::shared_ptr &node, const std::string &sep); + + bool GenNodeForeach(uint32_t depth, const std::shared_ptr &node); + + bool NodeWalk(); + + void SetTypeData(uint32_t type, const std::shared_ptr ¤t, uint32_t &arraySize, uint32_t depth); + + void SetTypeDataUinit64(const std::string &arrayName, uint32_t &arraySize, uint32_t arrayType, + const std::shared_ptr ¤t); + + bool HeaderTopOutput(); + + bool HeaderBottomOutput(); + + const std::string &ToUpperString(std::string &str); + + bool GenArray(const std::string &name, uint32_t &arrSize, uint32_t type, const std::shared_ptr &node); + + std::string GenRefObjName(uint32_t depth, const std::shared_ptr &object); + + std::ofstream ofs_; + std::string outFileName_; + std::map nodeNameMap_; +}; +} // Hardware +} // OHOS +#endif // HC_GEN_MACRO_GEN_H diff --git a/tools/hc-gen/src/main.cpp b/tools/hc-gen/src/main.cpp index 6e994a4ac00b023f9bc59a92bfc4725fe34e5812..f35979eef3451cba0d1fc52dba82e3e73e697a3b 100644 --- a/tools/hc-gen/src/main.cpp +++ b/tools/hc-gen/src/main.cpp @@ -8,6 +8,7 @@ #include "bytecode_gen.h" #include "decompile.h" +#include "macro_gen.h" #include "option.h" #include "parser.h" #include "text_gen.h" @@ -53,6 +54,11 @@ int main(int argc, char *argv[]) return EFAIL; } } + if (option.ShouldGenMacroConfig()) { + if (!MacroGen(parser.GetAst()).Output()) { + return EFAIL; + } + } return 0; } diff --git a/tools/hc-gen/src/option.cpp b/tools/hc-gen/src/option.cpp index 148644ab3655a376847e4c2f92bc763b823b9b9b..08aaa57a8c5b6a6da7c73b90efb7592d922ab4da 100644 --- a/tools/hc-gen/src/option.cpp +++ b/tools/hc-gen/src/option.cpp @@ -27,7 +27,7 @@ Option &Option::Instance() } static constexpr int OPTION_END = -1; -static constexpr const char *HCS_SUPPORT_ARGS = "o:ap:bditvVh"; +static constexpr const char *HCS_SUPPORT_ARGS = "o:ap:bditmvVh"; Option &Option::Parse(int argc, char **argv) { @@ -58,51 +58,62 @@ bool Option::ParseOptions(int argc, char **argv) int32_t op = 0; while (op != OPTION_END) { op = getopt(argc, argv, HCS_SUPPORT_ARGS); - switch (op) { - case 'o': - outputName_ = optarg; - break; - case 'a': - shouldAlign_ = true; - break; - case 'b': - shouldGenByteCodeConfig_ = true; - break; - case 't': - shouldGenTextConfig_ = true; - shouldGenByteCodeConfig_ = false; - break; - case 'p': - symbolNamePrefix_ = optarg; - break; - case 'i': - showGenHexDump_ = true; - break; - case 'V': - verboseLog_ = true; - break; - case 'd': - shouldDecompile_ = true; - break; - case 'v': - showVersion_ = true; - return false; - case 'h': /* fall-through */ - showUsage_ = true; - return false; - case '?': - showUsage_ = true; - optionError_ = true; - SetOptionError(); - return false; - default: - break; - } + SetOptionData(op); } return true; } +void Option::SetOptionData(char op) +{ + switch (op) { + case 'o': + outputName_ = optarg; + break; + case 'a': + shouldAlign_ = true; + break; + case 'b': + shouldGenByteCodeConfig_ = true; + break; + case 't': + shouldGenTextConfig_ = true; + shouldGenByteCodeConfig_ = false; + shouldGenMacroConfig_ = false; + break; + case 'm': + shouldGenTextConfig_ = false; + shouldGenByteCodeConfig_ = false; + shouldGenMacroConfig_ = true; + break; + case 'p': + symbolNamePrefix_ = optarg; + break; + case 'i': + showGenHexDump_ = true; + break; + case 'V': + verboseLog_ = true; + break; + case 'd': + shouldDecompile_ = true; + break; + case 'v': + showVersion_ = true; + break; + case 'h': /* fall-through */ + showUsage_ = true; + break; + case '?': + showUsage_ = true; + optionError_ = true; + SetOptionError(); + break; + default: + break; + } +} + void Option::ShowUsage() { Logger() << @@ -111,6 +122,7 @@ void Option::ShowUsage() ShowOption("-a", "hcb align with four bytes"); ShowOption("-b", "output binary output, default enable"); ShowOption("-t", "output config in C language source file style"); + ShowOption("-m", "output config in macro file style"); ShowOption("-i", "output binary hex dump in C language source file style"); ShowOption("-p ", "prefix of generated symbol name"); ShowOption("-d", "decompile hcb to hcs"); @@ -155,6 +167,11 @@ bool Option::ShouldGenTextConfig() const return shouldGenTextConfig_; } +bool Option::ShouldGenMacroConfig() const +{ + return shouldGenMacroConfig_; +} + bool Option::ShouldGenBinaryConfig() const { return shouldGenByteCodeConfig_; diff --git a/tools/hc-gen/src/option.h b/tools/hc-gen/src/option.h index de7389be1e432737660b3dde42090ef403167fab..1446abda446a309701d2e039bbe288f7345d071d 100644 --- a/tools/hc-gen/src/option.h +++ b/tools/hc-gen/src/option.h @@ -39,6 +39,8 @@ public: bool ShouldGenTextConfig() const; + bool ShouldGenMacroConfig() const; + bool ShouldGenBinaryConfig() const; bool ShouldGenHexDump() const; @@ -70,6 +72,7 @@ private: bool showVersion_ = false; bool shouldAlign_ = false; bool shouldGenTextConfig_ = false; + bool shouldGenMacroConfig_ = false; bool shouldGenByteCodeConfig_ = true; bool showGenHexDump_ = false; bool shouldDecompile_ = false; @@ -80,6 +83,7 @@ private: std::string sourceNameBase_; std::string outputName_; std::string sourceDir_; + void SetOptionData(char op); }; } // Hardware diff --git a/tools/hc-gen/test/update_case.py b/tools/hc-gen/test/update_case.py index 292ee0ab853a05e7e72372bc60dc0f0614a1b52e..6706b19764a4a86a82ec2c14ecc9f4bf623760d8 100755 --- a/tools/hc-gen/test/update_case.py +++ b/tools/hc-gen/test/update_case.py @@ -170,6 +170,33 @@ def build_text(hcgen_path, case_name): return True +def build_macro(hcgen_path, case_name): + source_file = os.path.join(WORK_DIR, case_name, 'case.hcs') + target_file = os.path.join(WORK_DIR, case_name, 'macro') + command = "%s -m -o %s %s" % (hcgen_path, target_file, source_file) + status, output = subprocess.getstatusoutput(command) + if case_name.endswith('_ei'): + if status == 0: + print("CASE_ERROR:error identify case " + + case_name + " expect build fail but success at macro mode") + print(output) + return False + elif status != 0: + print("CASE_ERROR:case " + case_name + + " expect build success but failed at macro mode") + print(output) + return False + output = output.replace(WORK_DIR, ".").replace('\\', '/') \ + .replace(ERROR_COLOR_PREFIX, "") \ + .replace(ERROR_COLOR_END, "").strip() + + save_compile_result('macro', case_name, status, output) + + if status == 0: + os.rename(target_file + '.h', target_file + '.h.gen') + return True + + def build_cases(hcgen_path, cases): index = 1 failed_cases = [] @@ -177,7 +204,8 @@ def build_cases(hcgen_path, cases): print('[%02d/%d] build %s' % (index, len(cases), case)) text_compile = build_text(hcgen_path, case) binary_compile = build_binary(hcgen_path, case) - if not text_compile or not binary_compile: + macro_compile = build_macro(hcgen_path, case) + if not text_compile or not binary_compile or not macro_compile: failed_cases.append(case) index += 1 diff --git a/tools/hdf_dev_eco_tool/command_line/__init__.py b/tools/hdf_dev_eco_tool/command_line/__init__.py new file mode 100755 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_add_handler.py b/tools/hdf_dev_eco_tool/command_line/hdf_add_handler.py new file mode 100755 index 0000000000000000000000000000000000000000..b4ac9059a8089ed2899e2f5622ccef5d857a61b6 --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_add_handler.py @@ -0,0 +1,341 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os +import json +import platform +from string import Template + +from .hdf_command_handler_base import HdfCommandHandlerBase +from .hdf_command_error_code import CommandErrorCode +from .hdf_device_info_hcs import HdfDeviceInfoHcsFile +from .hdf_vendor_build_file import HdfVendorBuildFile +from .hdf_vendor_kconfig_file import HdfVendorKconfigFile +from .hdf_vendor_mk_file import HdfVendorMkFile +from .hdf_driver_config_file import HdfDriverConfigFile +from hdf_tool_settings import HdfToolSettings +from hdf_tool_exception import HdfToolException +from .hdf_vendor_makefile import HdfVendorMakeFile +from .hdf_defconfig_patch import HdfDefconfigAndPatch +import hdf_utils + + +class HdfAddHandler(HdfCommandHandlerBase): + def __init__(self, args): + super(HdfAddHandler, self).__init__() + self.cmd = 'add' + self.handlers = { + 'vendor': self._add_vendor_handler, + 'module': self._add_module_handler, + 'driver': self._add_driver_handler, + 'config': self._add_config_handler, + } + self.parser.add_argument("--action_type", + help=' '.join(self.handlers.keys()), + required=True) + self.parser.add_argument("--root_dir", required=True) + self.parser.add_argument("--vendor_name") + self.parser.add_argument("--module_name") + self.parser.add_argument("--driver_name") + self.parser.add_argument("--board_name") + self.parser.add_argument("--kernel_name") + self.args = self.parser.parse_args(args) + + @staticmethod + def _render(template_path, output_path, data_model): + if not os.path.exists(template_path): + return + raw_content = hdf_utils.read_file(template_path) + contents = Template(raw_content).safe_substitute(data_model) + hdf_utils.write_file(output_path, contents) + + def _file_gen_lite(self, template, out_dir, filename, model): + templates_dir = hdf_utils.get_templates_lite_dir() + template_path = os.path.join(templates_dir, template) + file_path = os.path.join(out_dir, filename) + self._render(template_path, file_path, model) + + def _add_vendor_handler(self): + self.check_arg_raise_if_not_exist("vendor_name") + root, vendor, _, _, board = self.get_args() + target_dir = hdf_utils.get_vendor_hdf_dir(root, vendor) + if os.path.exists(target_dir): + raise HdfToolException( + "%s already exists" % + target_dir, CommandErrorCode.TARGET_ALREADY_EXIST) + os.makedirs(target_dir) + self._file_gen_lite('hdf_vendor_kconfig.template', target_dir, + 'Kconfig', {}) + board_parent_path = HdfToolSettings().get_board_parent_path(board) + if not board_parent_path: + board_parent_path = 'vendor/hisilicon' + data_model = { + "board_parent_path": board_parent_path + } + self._file_gen_lite('hdf_vendor_mk.template', target_dir, + 'hdf_vendor.mk', data_model) + + def _add_module_handler(self): + self.check_arg_raise_if_not_exist("vendor_name") + self.check_arg_raise_if_not_exist("module_name") + self.check_arg_raise_if_not_exist("kernel_name") + self.check_arg_raise_if_not_exist("board_name") + self.check_arg_raise_if_not_exist("driver_name") + + args_tuple = self.get_args() + root, vendor, module, driver, board, kernel = args_tuple + board_list = HdfToolSettings().get_board_list() + if board in board_list: + converter = hdf_utils.WordsConverter(self.args.module_name) + driver_name_converter = hdf_utils.WordsConverter( + self.args.driver_name) + framework_hdf = hdf_utils.get_vendor_hdf_dir_framework(root) + if not os.path.exists(framework_hdf): + raise HdfToolException( + ' framework model path "%s" not exist' % + framework_hdf, CommandErrorCode.TARGET_NOT_EXIST) + # framework create file .c + framework_drv_root_dir = hdf_utils.get_drv_root_dir( + root, vendor, module) + if os.path.exists(framework_drv_root_dir): + raise HdfToolException('module "%s" already exist' % module, + CommandErrorCode.TARGET_ALREADY_EXIST) + os.makedirs(framework_drv_root_dir) + + # create .c template driver file + state, driver_file_path = self._add_driver_handler(*args_tuple) + if not state: + raise HdfToolException( + 'create drivers file fail "%s" ' % + driver_file_path.split("\\")[-1]) + adapter_hdf = hdf_utils.get_vendor_hdf_dir_adapter(root, kernel) + if not os.path.exists(adapter_hdf): + raise HdfToolException( + ' adapter model path "%s" not exist' % + adapter_hdf, CommandErrorCode.TARGET_NOT_EXIST) + + # create module folder under the adapter path + adapter_model_path = os.path.join(adapter_hdf, 'model', module) + if not os.path.exists(adapter_model_path): + os.makedirs(adapter_model_path) + + data_model = { + "module_upper_case": converter.upper_case(), + "module_lower_case": converter.lower_case(), + "driver_file_name": ("%s_driver.c" % + driver_name_converter.lower_case()), + "driver_name": driver_name_converter.lower_case() + } + + # create files in the module under the adapter + if kernel == 'liteos': + file_path, model_level_config_file_path = \ + self._add_module_handler_liteos( + framework_hdf, adapter_model_path, + data_model, converter, *args_tuple) + + elif kernel == "linux": + file_path, model_level_config_file_path = \ + self._add_module_handler_linux( + framework_hdf, adapter_model_path, + data_model, *args_tuple) + else: + file_path = {} + model_level_config_file_path = {} + config_item = { + 'module_name': module, + 'module_path': file_path, + 'driver_name': "%s_driver.c" % driver, + 'driver_file_path': driver_file_path, + 'enabled': True + } + config_file_out = { + 'module_name': module, + 'module_path': file_path, + 'driver_name': "%s_driver.c" % driver, + 'driver_file_path': driver_file_path, + 'module_level_config_path': model_level_config_file_path + } + config_file = hdf_utils.read_file( + os.path.join('resources', 'create_model.config')) + config_file_json = json.loads(config_file) + config_file_json[module] = config_file_out + if platform.system() == "Windows": + config_file_replace = json.dumps(config_file_json, indent=4).\ + replace(root.replace('\\', '\\\\') + '\\\\', "") + hdf_utils.write_file( + os.path.join('resources', 'create_model.config'), + config_file_replace.replace('\\\\', '/')) + if platform.system() == "Linux": + config_file_replace = json.dumps(config_file_json, indent=4).\ + replace(root + '/', "") + hdf_utils.write_file( + os.path.join('resources', 'create_model.config'), + config_file_replace) + return json.dumps(config_item) + else: + raise HdfToolException( + 'supported boards name : %s not exits ' % board) + + def _add_module_handler_liteos(self, framework_hdf, adapter_model_path, + data_model, converter, *args_tuple): + root, vendor, module, driver, board, kernel = args_tuple + liteos_file_path = {} + liteos_level_config_file_path = {} + liteos_file_name = ['BUILD.gn', 'Kconfig', 'Makefile'] + template_path = "/".join([framework_hdf] + + ["tools", "hdf_dev_eco_tool", + "resources", "templates", "lite"]) + for file_name in liteos_file_name: + for i in os.listdir(template_path): + if i.find(file_name.split(".")[0]) > 0: + out_path = os.path.join(adapter_model_path, file_name) + self._render(os.path.join(template_path, i), + out_path, data_model) + liteos_file_path[file_name] = out_path + + # Modify Kconfig file + vendor_k = HdfVendorKconfigFile(root, vendor, kernel, path="") + vendor_k_path = vendor_k.add_module([module, 'Kconfig']) + liteos_level_config_file_path[module+"_Kconfig"] = vendor_k_path + + # Modify hdf_lite.mk file + vendor_mk = HdfVendorMkFile(root, vendor) + vendor_mk_path = vendor_mk.add_module(module) + liteos_level_config_file_path[module + "_hdf_lite"] = vendor_mk_path + + # Modify Build.gn file + vendor_gn = HdfVendorBuildFile(root, vendor) + vendor_gn_path = vendor_gn.add_module(module) + liteos_level_config_file_path[module + "Build"] = vendor_gn_path + + # Modify config file + device_info = HdfDeviceInfoHcsFile( + root, vendor, module, board, driver, path="") + hcs_file_path = device_info.add_model_hcs_file_config() + liteos_file_path["devices_info.hcs"] = hcs_file_path + + dot_file_list = hdf_utils.get_dot_configs_path(root, vendor, board) + template_string = "LOSCFG_DRIVERS_HDF_${module_upper_case}=y\n" + new_demo_config = Template(template_string).substitute( + {"module_upper_case": converter.upper_case()}) + for dot_file in dot_file_list: + file_lines = hdf_utils.read_file_lines(dot_file) + file_lines[-1] = file_lines[-1].strip() + "\n" + if new_demo_config != file_lines[-1]: + file_lines.append(new_demo_config) + hdf_utils.write_file_lines(dot_file, file_lines) + liteos_level_config_file_path[module + "_dot_configs"] = dot_file_list + return liteos_file_path, liteos_level_config_file_path + + def _add_module_handler_linux(self, framework_hdf, adapter_model_path, + data_model, *args_tuple): + root, vendor, module, driver, board, kernel = args_tuple + linux_file_path = {} + linux_level_config_file_path = {} + linux_file_name = ['Kconfig', 'Makefile'] + template_path = "/".join([framework_hdf] + + ["tools", "hdf_dev_eco_tool", + "resources", "templates", "lite"]) + for file_name in linux_file_name: + for i in hdf_utils.template_filename_filtrate( + template_path, kernel): + if i.find(file_name.split(".")[0]) > 0: + out_path = os.path.join(adapter_model_path, file_name) + self._render(os.path.join(template_path, i), + out_path, data_model) + linux_file_path[file_name] = out_path + + # Modify Kconfig file + vendor_k = HdfVendorKconfigFile(root, vendor, kernel, path="") + vendor_k_path = vendor_k.add_module([module, 'Kconfig']) + linux_level_config_file_path[module + "_Kconfig"] = vendor_k_path + + # Modify Makefile file + vendor_mk = HdfVendorMakeFile(root, vendor, kernel, path='') + vendor_mk_path = vendor_mk.add_module(data_model) + linux_level_config_file_path[module + "_Makefile"] = vendor_mk_path + + # device_info.hcs + device_info = HdfDeviceInfoHcsFile( + root, vendor, module, board, driver, path="") + hcs_file_path = device_info.add_model_hcs_file_config() + linux_file_path["devices_info.hcs"] = hcs_file_path + + # dot_configs config file + template_string = "CONFIG_DRIVERS_HDF_${module_upper_case}=y\n" + new_demo_config = Template(template_string).substitute(data_model) + defconfig_patch = HdfDefconfigAndPatch( + root, vendor, kernel, board, + data_model, new_demo_config) + + config_path = defconfig_patch.get_config_config() + files = [] + patch_list = defconfig_patch.add_module(config_path, files=files) + config_path = defconfig_patch.get_config_patch() + files1 = [] + defconfig_list = defconfig_patch.add_module(config_path, files=files1) + linux_level_config_file_path[module + "_dot_configs"] = \ + list(set(patch_list + defconfig_list)) + return linux_file_path, linux_level_config_file_path + + def _add_driver_handler(self, *args_tuple): + root, vendor, module, driver, board, kernel = args_tuple + drv_converter = hdf_utils.WordsConverter(self.args.driver_name) + drv_src_dir = hdf_utils.get_drv_src_dir(root, vendor, module) + if os.path.exists(os.path.join(drv_src_dir, '%s_driver.c' % driver)): + raise HdfToolException( + 'driver "%s" already exist' % + driver, CommandErrorCode.TARGET_ALREADY_EXIST) + data_model = { + 'driver_lower_case': drv_converter.lower_case(), + 'driver_upper_camel_case': drv_converter.upper_camel_case(), + 'driver_lower_camel_case': drv_converter.lower_camel_case(), + 'driver_upper_case': drv_converter.upper_case() + } + self._file_gen_lite('hdf_driver.c.template', drv_src_dir, + '%s_driver.c' % driver, data_model) + driver_file_path = os.path.join( + drv_src_dir, '%s_driver.c' % driver) + return True, driver_file_path + + def _add_config_handler(self): + self.check_arg_raise_if_not_exist("module_name") + self.check_arg_raise_if_not_exist("driver_name") + self.check_arg_raise_if_not_exist("board_name") + root, _, module, driver, board = self.get_args() + drv_config = HdfDriverConfigFile(root, board, module, driver) + drv_config.create_driver() + return drv_config.get_drv_config_path() + + diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_command_error_code.py b/tools/hdf_dev_eco_tool/command_line/hdf_command_error_code.py new file mode 100755 index 0000000000000000000000000000000000000000..2d16c9cff7fb60c1fe2852f4cb6c3420e879e24d --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_command_error_code.py @@ -0,0 +1,41 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + + +class CommandErrorCode(object): + MESSAGE_FORMAT_WRONG = 1001 + INTERFACE_ERROR = 1002 + TARGET_NOT_EXIST = 1003 + TARGET_ALREADY_EXIST = 1004 + FILE_FORMAT_WRONG = 1005 + UNKNOWN_ERROR = 1111 diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_command_handler_base.py b/tools/hdf_dev_eco_tool/command_line/hdf_command_handler_base.py new file mode 100755 index 0000000000000000000000000000000000000000..93eee0c1c53b89c93e5c4d40e12dc757424f53bd --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_command_handler_base.py @@ -0,0 +1,99 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os + +from .hdf_command_error_code import CommandErrorCode +from .hdf_tool_argument_parser import HdfToolArgumentParser +from hdf_tool_exception import HdfToolException +import hdf_utils + + +class HdfCommandHandlerBase(object): + def __init__(self): + self.cmd = 'base' + self.action_type = 'base_action_type' + self.handlers = {} + self.args = {} + self.parser = HdfToolArgumentParser() + + def run(self): + self.action_type = self._get_action_type() + if self.action_type in self.handlers: + return self.handlers[self.action_type]() + else: + raise HdfToolException( + 'unknown action_type: "%s" for "%s" cmd' % + (self.action_type, self.cmd), + CommandErrorCode.INTERFACE_ERROR) + + def _get_action_type(self): + try: + return getattr(self.args, 'action_type') + except AttributeError: + return '' + + def check_arg_raise_if_not_exist(self, arg): + try: + value = getattr(self.args, arg) + if not value: + raise AttributeError() + except AttributeError: + raise HdfToolException( + 'argument "--%s" is required for "%s" cmd' % + (arg, self.cmd), CommandErrorCode.INTERFACE_ERROR) + + def _get_arg(self, arg): + try: + value = getattr(self.args, arg) + return value + except AttributeError: + return '' + + def get_args(self): + args = ['vendor_name', 'module_name', + 'driver_name', 'board_name', 'kernel_name'] + ret = [self._get_arg('root_dir')] + for arg in args: + value = self._get_arg(arg) + if value: + value = hdf_utils.WordsConverter(value).lower_case() + ret.append(value) + return tuple(ret) + + @staticmethod + def check_path_raise_if_not_exist(full_path): + if not os.path.exists(full_path): + raise HdfToolException( + '%s not exist' % + full_path, CommandErrorCode.TARGET_NOT_EXIST) diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_command_line_server.py b/tools/hdf_dev_eco_tool/command_line/hdf_command_line_server.py new file mode 100755 index 0000000000000000000000000000000000000000..060c0c9fa7e98514dc66a625298501d7810ff36b --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_command_line_server.py @@ -0,0 +1,144 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import sys +import argparse + +from .hdf_tool_commands import HdfToolCommands +from .hdf_tool_argument_parser import HdfToolArgumentParser +from command_line.hdf_command_error_code import CommandErrorCode +from hdf_tool_exception import HdfToolException + + +class Message(object): + TYPE_REQ = 'request' + TYPE_QUIT = 'quit' + TYPE_ERROR = 'error' + TYPE_SUCCESS = 'success' + + def __init__(self, msg_type, content): + self.msg_type = msg_type + self.content = content + + def is_quit(self): + return self.msg_type.lower() == Message.TYPE_ERROR + + +def pack_message(msg_type, content, err_code=None): + body = bytearray(content, 'utf-8') + if not err_code: + header = bytearray('{},{}\n'.format(msg_type, len(body)), 'utf-8') + else: + header = bytearray('{},{},{}\n'.format(msg_type, len(body), err_code), + 'utf-8') + bytes_packet = bytearray().join([header, body]) + return bytes_packet + + +def decode_header(header): + header_parts = header.split(',') + if len(header_parts) < 2: + return -1, '', 0 + msg_type = header_parts[0] + body_len = int(header_parts[1]) + return 0, msg_type, body_len + + +def decode_body(body): + arg_parser = HdfToolArgumentParser() + arg_parser.add_argument('cmd') + arg_parser.add_argument('remainder_args', nargs=argparse.REMAINDER) + args = arg_parser.parse_args(body.strip().split(' ')) + remainder = [arg for arg in args.remainder_args if len(arg) != 0] + return args.cmd, remainder + + +class HdfCommandLineServer(object): + def __init__(self, input_obj, output_obj): + self.input_obj = input_obj + self.output_obj = output_obj + self.commands = HdfToolCommands() + + def _send_back(self, msg_type, content, error_code=None): + message_bytes = pack_message(msg_type, content, error_code) + self.output_obj.write(message_bytes) + self.output_obj.flush() + + def _send_back_success(self, content): + self._send_back(Message.TYPE_SUCCESS, content) + + def _send_back_error(self, error_code, content): + self._send_back(Message.TYPE_ERROR, content, error_code) + + def _read_header(self): + head_bytes = self.input_obj.readline() + msg_header = str(head_bytes, encoding="utf-8") + return decode_header(msg_header) + + def _read_body(self, body_len): + body_bytes = self.input_obj.read(body_len) + body = str(body_bytes, encoding='utf-8') + return decode_body(body) + + def run(self): + while True: + try: + ret, msg_type, body_len = self._read_header() + if ret != 0: + err_code = CommandErrorCode.MESSAGE_FORMAT_WRONG + self._send_back_error(err_code, 'header wrong') + continue + if msg_type == Message.TYPE_QUIT: + self._send_back_success('Bye bye!') + break + if body_len < 0: + err_code = CommandErrorCode.MESSAGE_FORMAT_WRONG + self._send_back_error(err_code, 'body len wrong') + continue + cmd, args = self._read_body(body_len) + ret = self.commands.run(cmd, args) + if ret: + self._send_back_success(str(ret)) + else: + self._send_back_success('') + except HdfToolException as exc: + try: + self._send_back_error(exc.error_code, exc.exc_msg) + except OSError: + sys.exit(-1) + except Exception as exc: + try: + self._send_back_error(CommandErrorCode.UNKNOWN_ERROR, + str(exc)) + except OSError: + sys.exit(-1) diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_defconfig_patch.py b/tools/hdf_dev_eco_tool/command_line/hdf_defconfig_patch.py new file mode 100755 index 0000000000000000000000000000000000000000..4e33656f08ca43754e151ccf91c701cbd0640e66 --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_defconfig_patch.py @@ -0,0 +1,112 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os +import re +from string import Template + +from hdf_tool_settings import HdfToolSettings +from .hdf_command_error_code import CommandErrorCode +from hdf_tool_exception import HdfToolException +import hdf_utils + + +class HdfDefconfigAndPatch(object): + def __init__(self, root, vendor, kernel, + board, data_model, new_demo_config): + self.root = root + self.vendor = vendor + self.kernel = kernel + self.board = board + self.data_model = data_model + self.new_demo_config = new_demo_config + self.file_path = hdf_utils.get_template_file_path(root, vendor) + self.drivers_path_list = HdfToolSettings().\ + get_board_parent_file(self.board) + + def get_config_config(self): + return os.path.join(self.root, "kernel", self.kernel, "config") + + def get_config_patch(self): + return os.path.join(self.root, "kernel", self.kernel, "patches") + + def add_module(self, path, files): + for filename in os.listdir(path): + new_path = os.path.join(path, filename) + if not os.path.isdir(new_path): + self.find_file(new_path, files) + else: + self.add_module(new_path, files=files) + return files + + def delete_module(self, path): + lines = hdf_utils.read_file_lines(path) + if self.new_demo_config in lines or \ + ("+" + self.new_demo_config) in lines: + if path.split(".")[-1] != "patch": + lines.remove(self.new_demo_config) + else: + lines.remove("+" + self.new_demo_config) + hdf_utils.write_file_lines(path, lines) + + def rename_vendor(self): + pattern = r'vendor/([a-zA-Z0-9_\-]+)/' + replacement = 'vendor/%s/' % self.vendor + new_content = re.sub(pattern, replacement, self.contents) + hdf_utils.write_file(self.file_path, new_content) + + def find_file(self, path, files): + if path.split("\\")[-1] in self.drivers_path_list or \ + path.split("/")[-1] in self.drivers_path_list: + files.append(path) + codetype = "utf-8" + with open(path, "r+", encoding=codetype) as fread: + data = fread.readlines() + insert_index = None + state = False + for index, line in enumerate(data): + if line.find("CONFIG_DRIVERS_HDF_INPUT=y") >= 0: + insert_index = index + elif line.find(self.new_demo_config) >= 0: + files.remove(path) + state = True + if not state: + if path.split(".")[-1] != "patch": + data.insert(insert_index + 1, + self.new_demo_config) + else: + data.insert(insert_index + 1, + "+" + self.new_demo_config) + with open(path, "w", encoding=codetype) as fwrite: + fwrite.writelines(data) + return files diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_delete_handler.py b/tools/hdf_dev_eco_tool/command_line/hdf_delete_handler.py new file mode 100755 index 0000000000000000000000000000000000000000..b2e590c0cbd02a7455a290e1856f2a06dc9e8293 --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_delete_handler.py @@ -0,0 +1,223 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + + +import json +import os +import shutil +from string import Template + +from hdf_tool_exception import HdfToolException +from .hdf_command_error_code import CommandErrorCode +from .hdf_command_handler_base import HdfCommandHandlerBase +from .hdf_defconfig_patch import HdfDefconfigAndPatch +from .hdf_device_info_hcs import HdfDeviceInfoHcsFile +from .hdf_vendor_build_file import HdfVendorBuildFile +from .hdf_vendor_kconfig_file import HdfVendorKconfigFile +from .hdf_vendor_makefile import HdfVendorMakeFile +from .hdf_vendor_mk_file import HdfVendorMkFile +from .hdf_module_kconfig_file import HdfModuleKconfigFile +from .hdf_module_mk_file import HdfModuleMkFile +from .hdf_driver_config_file import HdfDriverConfigFile +import hdf_utils + + +class HdfDeleteHandler(HdfCommandHandlerBase): + def __init__(self, args): + super(HdfDeleteHandler, self).__init__() + self.cmd = 'delete' + self.handlers = { + 'vendor': self._delete_vendor_handler, + 'module': self._delete_module_handler, + 'driver': self._delete_driver_handler, + } + self.parser.add_argument("--action_type", + help=' '.join(self.handlers.keys()), + required=True) + self.parser.add_argument("--root_dir", required=True) + self.parser.add_argument("--vendor_name") + self.parser.add_argument("--module_name") + self.parser.add_argument("--driver_name") + self.parser.add_argument("--board_name") + self.parser.add_argument("--kernel_name") + self.args = self.parser.parse_args(args) + + def _delete_vendor_handler(self): + self.check_arg_raise_if_not_exist("vendor_name") + self.check_arg_raise_if_not_exist("board_name") + root, vendor, _, _, _ = self.get_args() + vendor_hdf_dir = hdf_utils.get_vendor_hdf_dir(root, vendor) + print(vendor_hdf_dir) + if not os.path.exists(vendor_hdf_dir): + return + for module in os.listdir(vendor_hdf_dir): + mod_dir = os.path.join(vendor_hdf_dir, module) + if os.path.isdir(mod_dir): + self._delete_module(root, module) + shutil.rmtree(vendor_hdf_dir) + + def _delete_module(self, root, model, model_info): + for key, path_value in model_info.items(): + if key.split("_")[-1] == "name": + pass + elif key == "driver_file_path": + driver_file = os.path.join( + root, path_value.split(model)[0], model) + if os.path.exists(driver_file): + shutil.rmtree(driver_file) + else: + self._delete_file_func(root, key, model_info, model) + create_model_data = self._delete_model_info() + delete_model_info = hdf_utils.get_create_model_info( + root=root, create_data=json.dumps(create_model_data)) + return delete_model_info + + def _delete_model_info(self): + self.check_arg_raise_if_not_exist("root_dir") + self.check_arg_raise_if_not_exist("module_name") + root, _, module, _, _, _ = self.get_args() + adapter_framework = hdf_utils.get_vendor_hdf_dir_framework(root=root) + if not os.path.exists(adapter_framework): + raise HdfToolException( + ' adapter model path "%s" not exist' % + adapter_framework, CommandErrorCode.TARGET_NOT_EXIST) + create_file_save_path = os.path.join( + adapter_framework, "tools", "hdf_dev_eco_tool", + "resources", "create_model.config") + if not os.path.exists(create_file_save_path): + raise HdfToolException( + 'create file config "%s" not exist' % + create_file_save_path, CommandErrorCode.TARGET_NOT_EXIST) + data = hdf_utils.read_file(create_file_save_path) + write_data = json.loads(data) + write_data.pop(module) + hdf_utils.write_file(create_file_save_path, + json.dumps(write_data, indent=4)) + return write_data + + def _delete_module_handler(self): + self.check_arg_raise_if_not_exist("root_dir") + self.check_arg_raise_if_not_exist("module_name") + root, _, module, _, _, _ = self.get_args() + adapter_framework = hdf_utils.get_vendor_hdf_dir_framework(root=root) + if not os.path.exists(adapter_framework): + raise HdfToolException( + ' adapter model path "%s" not exist' % + adapter_framework, CommandErrorCode.TARGET_NOT_EXIST) + create_file_save_path = os.path.join( + adapter_framework, "tools", "hdf_dev_eco_tool", + "resources", "create_model.config") + if not os.path.exists(create_file_save_path): + raise HdfToolException( + 'create file config "%s" not exist' % + create_file_save_path, CommandErrorCode.TARGET_NOT_EXIST) + data = hdf_utils.read_file(create_file_save_path) + file_info = json.loads(data) + model_info = file_info.get(module, None) + if model_info is None: + raise HdfToolException( + ' delete model "%s" not exist' % + module, CommandErrorCode.TARGET_NOT_EXIST) + else: + return self._delete_module(root, module, model_info) + + def _delete_driver(self, module, driver): + root, vendor, _, _, board = self.get_args() + drv_dir = hdf_utils.get_drv_dir(root, vendor, module, driver) + if os.path.exists(drv_dir): + shutil.rmtree(drv_dir) + k_path = hdf_utils.get_module_kconfig_path(root, vendor, module) + HdfModuleKconfigFile(root, module, k_path).delete_driver(driver) + HdfModuleMkFile(root, vendor, module).delete_driver(driver) + HdfDriverConfigFile(root, board, module, driver).delete_driver() + + def _delete_driver_handler(self): + self.check_arg_raise_if_not_exist("vendor_name") + self.check_arg_raise_if_not_exist("module_name") + self.check_arg_raise_if_not_exist("driver_name") + self.check_arg_raise_if_not_exist("board_name") + _, _, module, driver, _ = self.get_args() + self._delete_driver(module, driver) + + def _delete_file_func(self, root, key, model_info, model): + if key == "module_level_config_path": + for key1, value1 in model_info[key].items(): + if key1 == "%s_Makefile" % model: + HdfVendorMakeFile( + root, vendor="", kernel="", + path=os.path.join(root, value1)).delete_module(model) + elif key1 == "%s_Kconfig" % model: + HdfVendorKconfigFile( + root, vendor="", kernel="", + path=os.path.join(root, value1)).delete_module(model) + elif key1 == "%sBuild" % model: + HdfVendorBuildFile( + root, vendor="").delete_module( + file_path=os.path.join(root, value1), model=model) + elif key1 == "%s_hdf_lite" % model: + HdfVendorMkFile( + root, vendor="").delete_module( + file_path=os.path.join(root, value1), module=model) + elif key1 == "%s_dot_configs" % model: + for dot_path in value1: + if dot_path.split(".")[-1] == "config": + template_string = \ + "LOSCFG_DRIVERS_HDF_${module_upper_case}=y\n" + else: + template_string = \ + "CONFIG_DRIVERS_HDF_${module_upper_case}=y\n" + new_demo_config = Template(template_string).\ + substitute({"module_upper_case": model.upper()}) + defconfig_patch = HdfDefconfigAndPatch( + root=root, vendor="", kernel="", board="", + data_model="", new_demo_config=new_demo_config) + defconfig_patch.delete_module( + path=os.path.join(root, dot_path)) + elif key == "module_path": + for _, value2 in model_info[key].items(): + if value2.endswith("hcs"): + hcs_path = os.path.join(root, value2) + HdfDeviceInfoHcsFile( + root=root, vendor="", module="", + board="", driver="", path=hcs_path). \ + delete_driver(module=model) + else: + if value2: + file_path = os.path.join(root, value2) + if os.path.exists(file_path): + os.remove(file_path) + model_dir_path = "/".join(file_path.split("/")[:-1]) + if os.path.exists(model_dir_path): + file_list = os.listdir(model_dir_path) + if not file_list: + shutil.rmtree(model_dir_path) diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_device_info_hcs.py b/tools/hdf_dev_eco_tool/command_line/hdf_device_info_hcs.py new file mode 100755 index 0000000000000000000000000000000000000000..61ecca6922e07b9f7a304d7e63f1c82356a47803 --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_device_info_hcs.py @@ -0,0 +1,155 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os +import re +from string import Template + + +from .hdf_command_error_code import CommandErrorCode +from hdf_tool_exception import HdfToolException +import hdf_utils + + +class HdfDeviceInfoHcsFile(object): + def __init__(self, root, vendor, module, board, driver, path): + if not path: + self.module = module + self.vendor = vendor + self.board = board + self.root = root + self.driver = driver + self.lines = None + self.hcspath = hdf_utils.get_hcs_file_path( + self.root, self.vendor, self.board) + else: + self.hcspath = path + self.root = root + self.file_path = hdf_utils.get_template_file_path(root) + if not os.path.exists(self.file_path): + raise HdfToolException( + 'template file: %s not exist' % + self.file_path, CommandErrorCode.TARGET_NOT_EXIST) + if not os.path.exists(self.hcspath): + raise HdfToolException( + 'hcs file: %s not exist' % + self.hcspath, CommandErrorCode.TARGET_NOT_EXIST) + + def _save(self): + if self.lines: + hdf_utils.write_file(self.hcspath, ''.join(self.lines)) + + def _find_line(self, pattern): + for index, line in enumerate(self.lines): + if re.search(pattern, line): + return index, line + return 0, '' + + def _find_last_include(self): + if not self.lines: + return 0 + i = len(self.lines) - 1 + while i >= 0: + line = self.lines[i] + if re.search(self.include_pattern, line): + return i + 1 + i -= 1 + return 0 + + def _create_makefile(self): + mk_path = os.path.join(self.file_dir, 'Makefile') + template_str = hdf_utils.get_template('hdf_hcs_makefile.template') + hdf_utils.write_file(mk_path, template_str) + + def check_and_create(self): + if self.lines: + return + if not os.path.exists(self.file_dir): + os.makedirs(self.file_dir) + self._create_makefile() + self.lines.append('#include "hdf_manager/manager_config.hcs"\n') + self._save() + + def add_driver(self, module, driver): + target_line = self.line_template % (module, driver) + target_pattern = self.line_pattern % (module, driver) + idx, line = self._find_line(target_pattern) + if line: + self.lines[idx] = target_line + else: + pos = self._find_last_include() + self.lines.insert(pos, target_line) + self._save() + + def delete_driver(self, module): + hcs_config = hdf_utils.read_file_lines(self.hcspath) + index_info = {} + count = 0 + for index, line in enumerate(hcs_config): + if line.find("%s :: host" % module) > 0: + index_info["start_index"] = index + for child_index in range( + index_info["start_index"], len(hcs_config)): + if hcs_config[child_index].strip().endswith("{"): + count += 1 + elif hcs_config[child_index].strip() == "}": + count -= 1 + if count == 0: + index_info["end_index"] = child_index + break + break + if index_info: + self.lines = hcs_config[0:index_info["start_index"]] \ + + hcs_config[index_info["end_index"] + 1:] + self._save() + return True + + def add_model_hcs_file_config(self): + template_path = os.path.join(self.file_path, + 'device_info_hcs.template') + lines = list(map(lambda x: "\t\t" + x, + hdf_utils.read_file_lines(template_path))) + old_lines = list(filter(lambda x: x != "\n", + hdf_utils.read_file_lines(self.hcspath))) + new_data = old_lines[:-2] + lines + old_lines[-2:] + data = { + "driver_name": self.driver, + "model_name": self.module, + } + for index, _ in enumerate(new_data): + new_data[index] = Template(new_data[index]).substitute(data) + codetype = "utf-8" + with open(self.hcspath, "w+", encoding=codetype) as lwrite: + for j in new_data: + lwrite.write(j) + return self.hcspath diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_dot_config_file.py b/tools/hdf_dev_eco_tool/command_line/hdf_dot_config_file.py new file mode 100755 index 0000000000000000000000000000000000000000..a40f642102e43560a02d9309fa1ca648e723da0d --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_dot_config_file.py @@ -0,0 +1,154 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os +import re + +import hdf_utils + + +class ConfigItem(object): + def __init__(self, index, line): + self.index = index + self.line = line + + +class HdfDotConfigFile(object): + def __init__(self, dot_config_path): + self.file_path = dot_config_path + if os.path.exists(dot_config_path): + self.lines = hdf_utils.read_file_lines(dot_config_path) + self.dot_config_exist = True + else: + self.lines = [] + self.dot_config_exist = False + self.cache = {} + self.hdf_item = 'LOSCFG_DRIVERS_HDF' + self.prefix = 'LOSCFG_' + + def save(self): + if not self.dot_config_exist: + return + with open(self.file_path, 'r+', newline='\n') as file: + file.truncate() + file.write(''.join(self.lines)) + + def _update_cache(self, item, index, line): + self.cache[item] = ConfigItem(index, line) + + def _find(self, item): + if item in self.cache: + index = self.cache[item].index + line = self.cache[item].line + return index, line + for index, line in enumerate(self.lines): + item_pattern = r'%s\s*(=|is)' % item + if re.search(item_pattern, line): + line_ = line.strip() + self._update_cache(item, index, line_) + return index, line_ + return 0, '' + + @staticmethod + def _is_line_enabled(line): + if line.strip().startswith('#'): + return False + return True + + def _enable(self, item): + if not item: + return + new_line = '%s=y\n' % item + index, line = self._find(item) + if line: + if self._is_line_enabled(line): + return + self.lines[index] = new_line + self._update_cache(item, index, new_line) + return + else: + count = len(self.lines) + self.lines.append(new_line) + self._update_cache(item, count, new_line) + + def _disable(self, item): + if not item: + return + new_line = '# %s is not set\n' % item + index, line = self._find(item) + if not line: + return + if not self._is_line_enabled(line): + return + self.lines[index] = new_line + self._update_cache(item, index, new_line) + + def _is_enabled(self, item): + if not item: + return False + index, line = self._find(item) + if not line: + return False + return self._is_line_enabled(line) + + def _add_prefix(self, item): + if not item.startswith(self.prefix): + item = '%s%s' % (self.prefix, item) + return item + + def is_enabled(self, item, depends_on_item): + if item: + item = self._add_prefix(item) + if depends_on_item: + depends_on_item = self._add_prefix(depends_on_item) + if depends_on_item: + if not self._is_enabled(depends_on_item): + return False + return self._is_enabled(item) + + def enable(self, item, depends_on_item): + if item: + item = self._add_prefix(item) + if depends_on_item: + depends_on_item = self._add_prefix(depends_on_item) + self._enable(self.hdf_item) + self._enable(depends_on_item) + self._enable(item) + + def disable(self, item): + if item: + item = self._add_prefix(item) + self._disable(item) + + def add_dot_config(self): + hdf_utils.get_dot_configs_path() diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_driver_config_file.py b/tools/hdf_dev_eco_tool/command_line/hdf_driver_config_file.py new file mode 100755 index 0000000000000000000000000000000000000000..a4d045e451c38f36ed1caeb3d58e5473351bd992 --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_driver_config_file.py @@ -0,0 +1,95 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os +from string import Template + +from .hdf_manager_config_file import HdfManagerConfigFile +from .hdf_hcs_file import HdfHcsFile +from hdf_tool_settings import HdfToolSettings +from hdf_tool_exception import HdfToolException +from command_line.hdf_command_error_code import CommandErrorCode +import hdf_utils + + +class HdfDriverConfigFile(object): + def __init__(self, root, board, module, driver, kernel, only_path=False): + self.root = root + self.board = board + self.module = module + self.driver = driver + self.kernel = kernel + bpp = HdfToolSettings().get_board_parent_path(self.board) + board_path = os.path.join(self.root, bpp, self.board) + + if not os.path.exists(board_path): + raise HdfToolException('board: %s not exist' % board_path, + CommandErrorCode.TARGET_NOT_EXIST) + self.config_dir = os.path.join(board_path, 'hdf_config') + self.drv_dir = os.path.join(self.config_dir, self.module) + self.drv_config_path = os.path.join( + self.drv_dir, '%s_config.hcs' % self.driver) + if only_path: + return + manager_hcs_path = os.path.join(self.config_dir, 'device_info', + 'device_info.hcs') + self.manager_hcs = HdfManagerConfigFile(manager_hcs_path) + hdf_hcs_path = os.path.join(self.config_dir, 'hdf.hcs') + self.hdf_hcs = HdfHcsFile(hdf_hcs_path) + + def _check_and_create_common_config(self): + self.manager_hcs.check_and_create() + self.hdf_hcs.check_and_create() + if not os.path.exists(self.drv_dir): + os.makedirs(self.drv_dir) + + def create_driver(self): + self._check_and_create_common_config() + template_str = hdf_utils.get_template('hdf_driver_config.template') + config_content = Template(template_str).safe_substitute({}) + hdf_utils.write_file(self.drv_config_path, config_content) + self.manager_hcs.add_device(self.module, self.driver) + self.hdf_hcs.add_driver(self.module, self.driver) + + def delete_driver(self): + if not os.path.exists(self.drv_config_path): + return + os.remove(self.drv_config_path) + self.manager_hcs.delete_device(self.module, self.driver) + self.hdf_hcs.delete_driver(self.module, self.driver) + + def get_drv_config_path(self): + if os.path.exists(self.drv_config_path): + return os.path.realpath(self.drv_config_path) + else: + return '' diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_get_handler.py b/tools/hdf_dev_eco_tool/command_line/hdf_get_handler.py new file mode 100755 index 0000000000000000000000000000000000000000..2a5f4906e0f8910c7d3f8dfaa2244092e0d49932 --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_get_handler.py @@ -0,0 +1,230 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os +import json + +from .hdf_command_handler_base import HdfCommandHandlerBase +from .hdf_linux_scann import HdfLinuxScan +from .hdf_lite_mk_file import HdfLiteMkFile +from .hdf_liteos_scann import HdfLiteScan +from .hdf_vendor_kconfig_file import HdfVendorKconfigFile +from .hdf_module_kconfig_file import HdfModuleKconfigFile +from .hdf_driver_config_file import HdfDriverConfigFile +from command_line.hdf_command_error_code import CommandErrorCode +from hdf_tool_settings import HdfToolSettings +from hdf_tool_exception import HdfToolException +import hdf_tool_version +import hdf_utils + + +class HdfGetHandler(HdfCommandHandlerBase): + HDF_VERSION_MAJOR = 0 + HDF_VERSION_MINOR = 1 + + def __init__(self, args): + super(HdfGetHandler, self).__init__() + self.cmd = 'get' + self.handlers = { + 'vendor_list': self._get_vendor_list_handler, + 'current_vendor': self._get_current_vendor_handler, + 'vendor_parent_path': self._get_vendor_parent_path_handler, + 'individual_vendor_path': self._get_individual_vendor_path_handler, + 'board_list': self._get_board_list_handler, + 'driver_list': self._get_driver_list_handler, + 'driver_file': self._get_driver_file_handler, + 'drv_config_file': self._get_drv_config_file_handler, + 'hdf_tool_core_version': self._get_version_handler, + 'model_list': self._get_model_dict, + 'model_scan': self._mode_scan, + 'version': self.__get_version, + } + self.parser.add_argument("--action_type", + help=' '.join(self.handlers.keys()), + required=True) + self.parser.add_argument("--root_dir") + self.parser.add_argument("--vendor_name") + self.parser.add_argument("--module_name") + self.parser.add_argument("--driver_name") + self.parser.add_argument("--board_name") + self.args = self.parser.parse_args(args) + + def _get_vendor_list_handler(self): + self.check_arg_raise_if_not_exist("root_dir") + root = self.args.root_dir + vendor_root_dir = hdf_utils.get_vendor_root_dir(root) + vendors = [] + if os.path.exists(vendor_root_dir): + for vendor in os.listdir(vendor_root_dir): + hdf = hdf_utils.get_vendor_hdf_dir(root, vendor) + if os.path.exists(hdf): + vendors.append(vendor) + return ','.join(vendors) + + def _get_current_vendor_handler(self): + self.check_arg_raise_if_not_exist("root_dir") + return HdfLiteMkFile(self.args.root_dir).get_current_vendor() + + @staticmethod + def _get_board_list_handler(): + settings = HdfToolSettings() + return settings.get_supported_boards() + + def _get_vendor_parent_path_handler(self): + self.check_arg_raise_if_not_exist("root_dir") + target = hdf_utils.get_vendor_root_dir(self.args.root_dir) + return os.path.realpath(target) + + def _get_individual_vendor_path_handler(self): + self.check_arg_raise_if_not_exist("root_dir") + self.check_arg_raise_if_not_exist("vendor_name") + root, vendor, _, _, _ = self.get_args() + target = hdf_utils.get_vendor_dir(root, vendor) + return os.path.realpath(target) + + @staticmethod + def _get_version_handler(): + return hdf_tool_version.get_version() + + def _get_driver_list_handler(self): + self.check_arg_raise_if_not_exist("root_dir") + self.check_arg_raise_if_not_exist("vendor_name") + root, vendor, _, _, _ = self.get_args() + hdf_dir = hdf_utils.get_vendor_hdf_dir(root, vendor) + if not os.path.exists(hdf_dir): + raise HdfToolException('vendor "%s" not exist' % vendor, + CommandErrorCode.TARGET_NOT_EXIST) + modules = os.listdir(hdf_dir) + vendor_k = HdfVendorKconfigFile(root, vendor) + module_items = vendor_k.get_module_and_config_path() + drivers = {} + for item in module_items: + module, k_path = item + if module in modules: + models = \ + HdfModuleKconfigFile(root, module, + k_path).get_models() + drivers[module] = models + return json.dumps(drivers) + + def _get_driver_file_handler(self): + self.check_arg_raise_if_not_exist("root_dir") + self.check_arg_raise_if_not_exist("vendor_name") + self.check_arg_raise_if_not_exist("module_name") + self.check_arg_raise_if_not_exist("driver_name") + root = os.path.realpath(self.args.root_dir) + _, vendor, module, driver, _ = self.get_args() + drv_dir = hdf_utils.get_drv_dir(root, vendor, module, driver) + if not os.path.exists(drv_dir): + raise HdfToolException( + 'driver directory: %s not exist' % + drv_dir, CommandErrorCode.TARGET_NOT_EXIST) + for root_path, dirs, files in os.walk(drv_dir): + for file in files: + if file.endswith('.c'): + return os.path.realpath(os.path.join(root_path, file)) + return '' + + def _get_drv_config_file_handler(self): + self.check_arg_raise_if_not_exist("root_dir") + self.check_arg_raise_if_not_exist("module_name") + self.check_arg_raise_if_not_exist("driver_name") + self.check_arg_raise_if_not_exist("board_name") + root, _, module, driver, board = self.get_args() + drv_config = HdfDriverConfigFile(root, board, module, driver, True) + return drv_config.get_drv_config_path() + + def _get_model_dict(self): + self.check_arg_raise_if_not_exist("root_dir") + root, _, _, _, _, _ = self.get_args() + adapter_framework = hdf_utils.get_vendor_hdf_dir_framework(root=root) + if not os.path.exists(adapter_framework): + raise HdfToolException( + ' adapter model path "%s" not exist' % + adapter_framework, CommandErrorCode.TARGET_NOT_EXIST) + create_file_save_path = os.path.join( + adapter_framework, "tools", "hdf_dev_eco_tool", + "resources", "create_model.config") + if not os.path.exists(create_file_save_path): + raise HdfToolException( + 'create file config "%s" not exist' % + create_file_save_path, CommandErrorCode.TARGET_NOT_EXIST) + out_model_list = [] + data = hdf_utils.read_file(create_file_save_path) + json_type = json.loads(data) + if not json_type: + return out_model_list + file_key_list = list(list(json_type. + items())[0][-1].keys())[:-1] + for k, _ in json_type.items(): + model_file_path = {} + for key in file_key_list: + if key.split("_")[-1] == "path": + path_dict = json_type[k][key] + model_file_path = self._model_info( + path_dict, root, model_file_path, key) + out_model_list.append({k: model_file_path}) + return out_model_list + + def __get_version(self): + version_end = "\nCopyright (c) 2020-2021 Huawei Device Co., Ltd." + version_head = "hdf_dev_eco_tool version : " + return version_head + str(self.HDF_VERSION_MAJOR) \ + + "." + str(self.HDF_VERSION_MINOR) + version_end + + def _model_info(self, path_dict, root, model_file_path, key): + if isinstance(path_dict, dict): + for k_filename, file_path in path_dict.items(): + if not os.path.exists(os.path.join(root, file_path)): + model_file_path[k_filename] = " " + else: + model_file_path[k_filename] = path_dict[k_filename] + else: + hcs_file_path = os.path.join(root, path_dict) + if not os.path.exists(hcs_file_path): + model_file_path[key] = " " + else: + model_file_path[key] = path_dict + return model_file_path + + def _mode_scan(self): + self.check_arg_raise_if_not_exist("root_dir") + self.check_arg_raise_if_not_exist("vendor_name") + self.check_arg_raise_if_not_exist("board_name") + root, vendor, _, _, board, _ = self.get_args() + if board.split("_")[-1] != "linux": + return HdfLiteScan( + root=root, vendor=vendor, board=board).get_model_scan() + else: + return HdfLinuxScan( + root=root, vendor=vendor, board=board).get_model_scan() \ No newline at end of file diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_hcs_file.py b/tools/hdf_dev_eco_tool/command_line/hdf_hcs_file.py new file mode 100755 index 0000000000000000000000000000000000000000..9cb614cfe49386e26f30529f629f36e4edf0cebd --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_hcs_file.py @@ -0,0 +1,104 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os +import re + +import hdf_utils + + +class HdfHcsFile(object): + def __init__(self, file_path): + self.file_path = file_path + self.file_dir = os.path.dirname(self.file_path) + if os.path.exists(self.file_path): + self.lines = hdf_utils.read_file_lines(self.file_path) + else: + self.lines = [] + self.line_template = '#include "%s/%s_config.hcs"\n' + self.line_pattern = r'^\s*#include\s+"%s/%s_config.hcs"' + self.include_pattern = r'^\s*#include' + + def _save(self): + if self.lines: + hdf_utils.write_file(self.file_path, ''.join(self.lines)) + + def _find_line(self, pattern): + for index, line in enumerate(self.lines): + if re.search(pattern, line): + return index, line + return 0, '' + + def _find_last_include(self): + if not self.lines: + return 0 + i = len(self.lines) - 1 + while i >= 0: + line = self.lines[i] + if re.search(self.include_pattern, line): + return i + 1 + i -= 1 + return 0 + + def _create_makefile(self): + mk_path = os.path.join(self.file_dir, 'Makefile') + template_str = hdf_utils.get_template('hdf_hcs_makefile.template') + hdf_utils.write_file(mk_path, template_str) + + def check_and_create(self): + if self.lines: + return + if not os.path.exists(self.file_dir): + os.makedirs(self.file_dir) + self._create_makefile() + self.lines.append('#include "hdf_manager/manager_config.hcs"\n') + self._save() + + def add_driver(self, module, driver): + target_line = self.line_template % (module, driver) + target_pattern = self.line_pattern % (module, driver) + idx, line = self._find_line(target_pattern) + if line: + self.lines[idx] = target_line + else: + pos = self._find_last_include() + self.lines.insert(pos, target_line) + self._save() + + def delete_driver(self, module, driver): + target_pattern = self.line_pattern % (module, driver) + idx, line = self._find_line(target_pattern) + if not line: + return + self.lines[idx] = '' + self._save() diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_linux_scann.py b/tools/hdf_dev_eco_tool/command_line/hdf_linux_scann.py new file mode 100755 index 0000000000000000000000000000000000000000..91d5a51be3bc9916b10a92e12845e1271bffde30 --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_linux_scann.py @@ -0,0 +1,112 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +import json +import os +import re + +from .hdf_command_error_code import CommandErrorCode +from hdf_tool_exception import HdfToolException +import hdf_utils + + +class HdfLinuxScan(object): + def __init__(self, root, vendor, board): + self.root = root + self.vendor = vendor + self.board = board + self.kernel = "linux" + + self.makefile_path = hdf_utils.get_vendor_makefile_path( + root, kernel="linux") + if not os.path.exists(self.makefile_path): + raise HdfToolException( + 'Makefile: %s not exist' % self.makefile_path, + CommandErrorCode.TARGET_NOT_EXIST) + + self.framework_dir = hdf_utils.get_module_dir(self.root, vendor) + if not os.path.exists(self.framework_dir): + raise HdfToolException( + 'file: %s not exist' % self.framework_dir, + CommandErrorCode.TARGET_NOT_EXIST) + + self.hcs_path = hdf_utils.get_hcs_file_path( + self.root, self.vendor, self.board) + if not os.path.exists(self.hcs_path): + raise HdfToolException('file: %s not exist' % self.hcs_path, + CommandErrorCode.TARGET_NOT_EXIST) + self.contents = hdf_utils.read_file_lines(self.makefile_path) + self.re_temp2 = r'model/[a-z 0-9]+' + + def scan_makefile(self): + model_list = [] + for i in self.contents: + result = re.search(self.re_temp2, i) + if result: + model_name = result.group().split('/')[-1] + if model_name not in model_list: + model_list.append(model_name) + return list(set(model_list)) + + def _get_model_file_dict(self): + model_file_dict = {} + for model_name in self.scan_makefile(): + model_file_dict[model_name] = [] + path = os.path.join(self.framework_dir, model_name) + for root_path, dirs, files in os.walk(path): + for file in files: + model_file_dict[model_name].append( + os.path.join(root_path, file)) + return model_file_dict + + def get_model_scan(self): + model_dict = {} + linux_model_info = {} + model_list = self.scan_makefile() + for model_name in model_list: + adapter_model_path = os.path.join( + hdf_utils.get_vendor_hdf_dir_adapter( + self.root, self.kernel), 'model', model_name) + if os.path.exists(adapter_model_path): + model_dict[model_name] = {} + model_config_list = [] + for roots, dirs, files in os.walk(adapter_model_path): + for file in files: + model_config_list.append(os.path.join(roots, file)) + model_dict[model_name]["model_configs"] = model_config_list + model_dict[model_name]['model_drivers'] = \ + self._get_model_file_dict()[model_name] + + linux_model_info["model_dict"] = model_dict + linux_model_info["linux_hcs"] = self.hcs_path + + return json.dumps(linux_model_info, indent=4) \ No newline at end of file diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_lite_kconfig_file.py b/tools/hdf_dev_eco_tool/command_line/hdf_lite_kconfig_file.py new file mode 100755 index 0000000000000000000000000000000000000000..077d7f20047b5b15fe789f285e2476c09c616167 --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_lite_kconfig_file.py @@ -0,0 +1,88 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os +import re + +from hdf_tool_settings import HdfToolSettings +import hdf_utils + + +class HdfLiteKconfigFile(object): + def __init__(self, root): + self.file_path = hdf_utils.get_hdf_lite_kconfig_path(root) + self.orig_exist = False + if os.path.exists(self.file_path): + self.lines = hdf_utils.read_file_lines(self.file_path) + self.orig_exist = True + else: + self.lines = [] + self.vendor_pattern = r'source\s+".*/vendor/.*/Kconfig"' + self.target_pattern_format = r'source\s+".*/vendor/%s/.*/Kconfig"' + self.target_index = -1 + + def _save(self): + if self.orig_exist: + hdf_utils.write_file(self.file_path, ''.join(self.lines)) + + def _find_all_vendors(self, target_vendor): + vendors = [] + for index, line in enumerate(self.lines): + if self.target_index == -1: + if re.search(self.target_pattern_format % target_vendor, line): + self.target_index = index + continue + if re.search(self.vendor_pattern, line): + vendors.append(index) + return vendors + + def _comment_other_vendors(self, other_vendors): + for index in other_vendors: + if not hdf_utils.is_commented_line(self.lines[index], '#'): + self.lines[index] = '# %s' % self.lines[index] + + def set_vendor(self, current_vendor): + other_vendors = self._find_all_vendors(current_vendor) + self._comment_other_vendors(other_vendors) + drivers_path = HdfToolSettings().get_drivers_path() + new_line = 'source "../../vendor/%s/%s/Kconfig"\n' % \ + (current_vendor, drivers_path) + if self.target_index != -1: + self.lines[self.target_index] = new_line + else: + pos = len(self.lines) - 1 + while pos > 0 and len(self.lines[pos].strip()) == 0: + pos -= 1 + pos += 1 + self.lines.insert(pos, new_line) + self._save() diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_lite_mk_file.py b/tools/hdf_dev_eco_tool/command_line/hdf_lite_mk_file.py new file mode 100755 index 0000000000000000000000000000000000000000..e7dc12e823c01d5b38b75e045c9ecdba61e4fc97 --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_lite_mk_file.py @@ -0,0 +1,105 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os +import re + +from hdf_tool_settings import HdfToolSettings +import hdf_utils + + +class HdfLiteMkFile(object): + def __init__(self, root): + self.file_path = hdf_utils.get_hdf_lite_mk_path(root) + self.orig_exist = False + if os.path.exists(self.file_path): + self.lines = hdf_utils.read_file_lines(self.file_path) + self.orig_exist = True + else: + self.lines = [] + self.end_line_pattern = r'LITEOS_BASELIB\s*[+]=\s*--no-whole-archive' + self.vendor_pattern = r'include.*hdf_vendor[.]mk' + self.target_format = r'include .*vendor/%s/.*/hdf_vendor[.]mk' + self.end_line_index = -1 + self.target_line_index = -1 + self.current_vendor_pattern = r'^\s*include.*/device/(.*)/lite.mk' + + def _save(self): + if self.orig_exist: + hdf_utils.write_file(self.file_path, ''.join(self.lines)) + + def _find_all_vendors(self, current_vendor): + vendor_lines = [] + for index, line in enumerate(self.lines): + if self.target_line_index == -1: + if re.search(self.target_format % current_vendor, line): + self.target_line_index = index + continue + if self.end_line_index == -1: + if re.search(self.end_line_pattern, line): + self.end_line_index = index + continue + if re.search(self.vendor_pattern, line): + vendor_lines.append(index) + return vendor_lines + + def _comment_other_vendors(self, other_vendors): + for index in other_vendors: + if not hdf_utils.is_commented_line(self.lines[index], '#'): + self.lines[index] = '# %s' % self.lines[index] + + def set_vendor(self, current_vendor): + other_vendors = self._find_all_vendors(current_vendor) + self._comment_other_vendors(other_vendors) + drivers_path = HdfToolSettings().get_drivers_path() + new_line = \ + 'include $(LITEOSTOPDIR)/../../vendor/%s/%s/hdf_vendor.mk\n' % \ + (current_vendor, drivers_path) + if self.target_line_index != -1: + self.lines[self.target_line_index] = new_line + elif self.end_line_index != -1: + self.lines.insert(self.end_line_index, new_line) + else: + self.lines.append(new_line) + self._save() + + def get_current_vendor(self): + for line in self.lines: + match_obj = re.search(self.current_vendor_pattern, line) + if match_obj: + vendor_drivers_path = match_obj.group(1) + parts = vendor_drivers_path.split('/') + valid_parts = [part for part in parts if part] + if valid_parts: + return valid_parts[0] + return '' diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_lite_settings_mk_file.py b/tools/hdf_dev_eco_tool/command_line/hdf_lite_settings_mk_file.py new file mode 100755 index 0000000000000000000000000000000000000000..e163130eaf93c74ca607a8685c4366420aebbee6 --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_lite_settings_mk_file.py @@ -0,0 +1,110 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os +import re + +from .hdf_command_error_code import CommandErrorCode +from hdf_tool_exception import HdfToolException +import hdf_utils + + +class HdfLiteSettingsMkFile(object): + def __init__(self, root_dir): + self.root_dir = root_dir + self.file_path = hdf_utils.get_hdf_lite_settings_mk_path(root_dir) + if os.path.exists(self.file_path): + self.lines = hdf_utils.read_file_lines(self.file_path) + else: + dir_path = os.path.dirname(self.file_path) + if not os.path.exists(dir_path): + os.makedirs(dir_path) + self.lines = [] + self.line_pattern = r'(%s\s*:=\s*)(.*)' + self.hdf_vendor_var_name = 'HDF_COMPILE_VENDOR' + self.board_vendor_path_var_name = 'HDF_SET_BOARD_VENDOR_PATH' + + def _save(self): + if self.lines: + hdf_utils.write_file(self.file_path, ''.join(self.lines)) + + def _append(self, new_line): + self.lines.append(new_line) + self._save() + + def _find_var_line(self, var_name): + for index, line in enumerate(self.lines): + if var_name in line: + return index, line + return 0, '' + + def _is_vendor_valid(self, vendor_name): + vendor_hdf_path = \ + hdf_utils.get_vendor_hdf_dir(self.root_dir, vendor_name) + if os.path.exists(vendor_hdf_path): + return True + return False + + def _set_var_value(self, var_name, var_value): + idx, var_line = self._find_var_line(var_name) + if var_line: + self.lines[idx] = re.sub(self.line_pattern % var_name, + r'\g<1>%s' % var_value, var_line) + self._save() + else: + new_line = '\n%s := %s' % (var_name, var_value) + self._append(new_line) + + def _get_var_value(self, var_name): + idx, var_line = self._find_var_line(var_name) + var_value = '' + if var_line: + match_obj = re.search(self.line_pattern % var_name, var_line) + if match_obj: + var_value = match_obj.group(2) + return var_value.strip() + + def set_vendor(self, vendor_name): + if not self._is_vendor_valid(vendor_name): + raise HdfToolException('vendor: "%s" not exist' % vendor_name, + CommandErrorCode.TARGET_NOT_EXIST) + self._set_var_value(self.hdf_vendor_var_name, vendor_name) + + def get_vendor(self): + vendor_name = self._get_var_value(self.hdf_vendor_var_name) + if self._is_vendor_valid(vendor_name): + return vendor_name + return '' + + def set_board_vendor_path(self, board_vendor_path): + self._set_var_value(self.board_vendor_path_var_name, board_vendor_path) diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_liteos_scann.py b/tools/hdf_dev_eco_tool/command_line/hdf_liteos_scann.py new file mode 100755 index 0000000000000000000000000000000000000000..473a36f57d438c29ad51ea86428601f17faee45b --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_liteos_scann.py @@ -0,0 +1,120 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. +import json +import os +import re + +from .hdf_command_error_code import CommandErrorCode +from hdf_tool_exception import HdfToolException +import hdf_utils + + +class HdfLiteScan(object): + def __init__(self, root, vendor, board): + self.root = root + self.vendor = vendor + self.board = board + + self.build_path = hdf_utils.get_vendor_gn_path(self.root) + if not os.path.exists(self.build_path): + raise HdfToolException('file: %s not exist' % self.build_path, + CommandErrorCode.TARGET_NOT_EXIST) + + self.framework_dir = hdf_utils.get_module_dir(self.root, vendor) + if not os.path.exists(self.framework_dir): + raise HdfToolException('file: %s not exist' % self.framework_dir, + CommandErrorCode.TARGET_NOT_EXIST) + + self.hcs_path = hdf_utils.get_hcs_file_path(self.root, vendor, board) + if not os.path.exists(self.hcs_path): + raise HdfToolException('file: %s not exist' % self.hcs_path, + CommandErrorCode.TARGET_NOT_EXIST) + self.contents = hdf_utils.read_file_lines(self.build_path) + self.re_temp = r"^group" + self.re_temp2 = r'"model/[a-z 0-9]+' + + def scan_build(self): + start_index = 0 + end_index = 0 + state = 0 + for index, line in enumerate(self.contents): + if re.compile(self.re_temp).match(line): + start_index = index + state += 1 + elif line.strip() == "{" and start_index > 0: + state += 1 + elif line.strip() == "}" and start_index > 0: + state -= 1 + if state == 0: + end_index = index + 1 + + model_list = [] + for i in self.contents[start_index: end_index]: + model_name = re.compile(self.re_temp2).match(i.strip()) + if model_name: + model_list.append(model_name.group().split('/')[-1]) + return list(set(model_list)) + + def _get_model_file_dict(self): + model_file_dict = {} + for model_name in self.scan_build(): + model_file_dict[model_name] = [] + path = os.path.join(self.framework_dir, model_name) + for root_path, dirs, files in os.walk(path): + for file in files: + model_file_dict[model_name].append( + os.path.join(root_path, file)) + return model_file_dict + + def get_model_scan(self): + model_dict = {} + liteos_model_info = {} + model_list = self.scan_build() + for model_name in model_list: + adapter_model_path = os.path.join( + hdf_utils.get_vendor_hdf_dir_adapter(root=self.root), + 'model', model_name) + if os.path.exists(adapter_model_path): + model_dict[model_name] = {} + model_config_list = [] + for roots, dirs, files in os.walk(adapter_model_path): + for file in files: + model_config_list.append(os.path.join(roots, file)) + model_dict[model_name]["model_configs"] = model_config_list + model_dict[model_name]['model_drivers'] = \ + self._get_model_file_dict()[model_name] + + liteos_model_info["model_dict"] = model_dict + liteos_model_info["liteos_hcs"] = self.hcs_path + + return json.dumps(liteos_model_info, indent=4) \ No newline at end of file diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_manager_config_file.py b/tools/hdf_dev_eco_tool/command_line/hdf_manager_config_file.py new file mode 100755 index 0000000000000000000000000000000000000000..d856a393e792488ad74dc5f6eb1a84850d94d64d --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_manager_config_file.py @@ -0,0 +1,174 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os +import re +from string import Template + +from hdf_tool_exception import HdfToolException +from command_line.hdf_command_error_code import CommandErrorCode +import hdf_utils + + +class HdfManagerConfigFile(object): + def __init__(self, file_path): + self.file_path = file_path + self.file_dir = os.path.dirname(self.file_path) + self.host_pattern = r'%s\s*::\s*host\s*{' + self.hdf_manager_pattern = r'device_info\s*{' + self.contents = '' + self._read_contents() + + def _read_contents(self): + if os.path.exists(self.file_path): + self.contents = hdf_utils.read_file(self.file_path) + else: + self.contents = '' + + def check_and_create(self): + if self.contents: + return + template_str = \ + hdf_utils.get_template('hdf_driver_manager_config.template') + self.contents = Template(template_str).safe_substitute({}) + if not os.path.exists(self.file_dir): + os.makedirs(self.file_dir) + hdf_utils.write_file(self.file_path, self.contents) + + def _find_range(self, pattern): + match_obj = re.search(pattern, self.contents) + if not match_obj: + return None + start = match_obj.start() + if start == -1: + return None + braces = [] + start += len(match_obj.group(0)) - 1 + end = start + for i in range(start, len(self.contents)): + if '{' == self.contents[i]: + braces.append('{') + elif '}' == self.contents[i]: + count = len(braces) + if count == 0: + return None + if count == 1: + end = i + break + braces.pop() + if end != start: + while end > start + 1: + end -= 1 + if self.contents[end] not in [' ', '\t']: + break + return hdf_utils.SectionRange(start, end) + return None + + @staticmethod + def _begin_end(module, driver): + dev_id = hdf_utils.get_id(module, driver) + device_begin = '\n/* 0: + del lines[index] + hdf_utils.write_file_lines(file_path, lines) + + def rename_vendor(self): + pattern = r'vendor/([a-zA-Z0-9_\-]+)/' + replacement = 'vendor/%s/' % self.vendor + new_content = re.sub(pattern, replacement, self.contents) + hdf_utils.write_file(self.file_path, new_content) diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_vendor_kconfig_file.py b/tools/hdf_dev_eco_tool/command_line/hdf_vendor_kconfig_file.py new file mode 100755 index 0000000000000000000000000000000000000000..a7071413d2411fa7e5106b300ddc1f28c1559a6b --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_vendor_kconfig_file.py @@ -0,0 +1,126 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os +import re + +from hdf_tool_settings import HdfToolSettings +import hdf_utils + + +class HdfVendorKconfigFile(object): + def __init__(self, root, vendor, kernel, path): + if not path: + self.kernel = kernel + self.root = root + self.vendor = vendor + self.kconfig_path = hdf_utils.\ + get_vendor_kconfig_path(self.root, self.kernel) + else: + self.kconfig_path = path + if os.path.exists(self.kconfig_path): + self.lines = hdf_utils.read_file_lines(self.kconfig_path) + else: + self.lines = [] + drivers_path = HdfToolSettings().get_drivers_path_adapter() + if kernel.capitalize() == "Liteos" or re.search( + r'liteos/Kconfig', self.kconfig_path): + line_pattern = \ + r'^\s*source\s+"../../(%s/([a-zA-Z0-9_\-]+)/.*)"'\ + % (drivers_path) + self.line_re = re.compile(line_pattern) + self.line_prefix = 'source "../../%s/%s/%s"'\ + % (drivers_path, 'liteos', 'model') + elif kernel.capitalize() == "Linux" or re.search( + r'linux/Kconfig', self.kconfig_path): + line_pattern = \ + r'^\s*source\s+"../../(%s/([a-zA-Z0-9_\-]+)/.*)"'\ + % (drivers_path) + self.line_re = re.compile(line_pattern) + self.line_prefix = 'source "drivers/hdf/khdf/model/%s/Kconfig"\n' + + def _save(self): + if self.lines: + hdf_utils.write_file(self.kconfig_path, ''.join(self.lines)) + + def get_module_and_config_path(self): + tuples = [] + for line in self.lines: + match_obj = self.line_re.search(line) + if match_obj: + k_path_raw = match_obj.group(1).replace('/', os.sep) + k_path = os.path.join(self.root, k_path_raw) + tuples.append((match_obj.group(2), k_path)) + return tuples + + def _find_line(self, line_part): + for index, line in enumerate(self.lines): + if line_part in line: + return index, line + return 0, '' + + def add_module(self, module_to_k_path_parts): + module_k_part = '/'.join(module_to_k_path_parts) + index, line = self._find_line("model/"+module_k_part) + if line: + return + line = '\n%s/%s"\n' % (self.line_prefix, module_k_part) + if self.lines: + if self.lines[-1].endswith('\n'): + if self.kernel.capitalize() == "Liteos": + line = '%s/%s"\n' % (self.line_prefix[:-1], module_k_part) + elif self.kernel.capitalize() == "Linux": + line = self.line_prefix % (module_to_k_path_parts[0]) + for file_index, file_line in enumerate(self.lines): + if file_line.strip() == "endif": + self.lines.insert(file_index - 1, line) + break + self._save() + return self.kconfig_path + + def delete_module(self, module): + if self.line_prefix.find("Kconfig") > 0: + line_part = self.line_prefix % module + else: + line_part = '%s/%s/Kconfig"\n' % (self.line_prefix[:-1], module) + index, line = self._find_line(line_part) + if line: + self.lines[index] = '' + self._save() + + def rename_vendor(self, ): + for i, line in enumerate(self.lines): + pattern = r'vendor/([a-zA-Z0-9_\-]+)/' + replacement = 'vendor/%s/' % self.vendor + self.lines[i] = re.sub(pattern, replacement, line) + self._save() diff --git a/tools/hdf_dev_eco_tool/command_line/hdf_vendor_makefile.py b/tools/hdf_dev_eco_tool/command_line/hdf_vendor_makefile.py new file mode 100755 index 0000000000000000000000000000000000000000..7153cc7e40a9776c291b0560253574462e31c668 --- /dev/null +++ b/tools/hdf_dev_eco_tool/command_line/hdf_vendor_makefile.py @@ -0,0 +1,89 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os +import re +from string import Template + +from .hdf_command_error_code import CommandErrorCode +from hdf_tool_exception import HdfToolException +import hdf_utils + + +class HdfVendorMakeFile(object): + def __init__(self, root, vendor, kernel, path): + if path: + self.file_path = path + else: + self.vendor = vendor + self.kernel = kernel + self.file_path = hdf_utils.\ + get_vendor_makefile_path(root, self.kernel) + if not os.path.exists(self.file_path): + raise HdfToolException('file: %s not exist' % self.file_path, + CommandErrorCode.TARGET_NOT_EXIST) + self.contents = hdf_utils.read_file_lines(self.file_path) + self.template_str = \ + "obj-$(CONFIG_DRIVERS_HDF_${module_upper_case}) " \ + "+= model/${module_lower_case}/\n" + + def _begin_end(self, module): + module_id = hdf_utils.get_id(self.vendor, module) + begin = '\n# pos_range.end_pos + 1: + file.write(file_content[pos_range.end_pos + 1:]) + + +def append_and_save(file_content, file_path, new_section): + if not file_content or not file_path or not new_section: + return + with open(file_path, 'w', newline='\n') as file: + file.write(file_content) + _write_one_section(file, new_section) + + +def delete_and_save(file_content, file_path, delete_range): + if not file_content or not file_path or not delete_range: + return + length = len(file_content) + with open(file_path, 'w', newline='\n') as file: + file.write(file_content[:delete_range.start_pos]) + if delete_range.end_pos + 1 < length: + file.write(file_content[delete_range.end_pos + 1:]) + + +def replace_and_save(file_content, file_path, old_range, new_section): + if not file_content or not file_path or not old_range or not new_section: + return + with open(file_path, 'w', newline='\n') as file: + file.write(file_content[:old_range.start_pos]) + _write_one_section(file, new_section) + file.write(file_content[old_range.end_pos + 1:]) + + +def get_id(part2): + full_name = part2 + return hashlib.sha256(full_name.encode('utf8')).hexdigest()[:32] + + +def create_dirs(dir_path): + if dir_path and not os.path.exists(dir_path): + try: + os.makedirs(dir_path) + except Exception: + raise HdfToolException('create dirs fail: %s' % dir_path) + + +def read_file(file_path): + with open(file_path, encoding="utf-8") as file: + content = file.read() + return content + + +def read_file_lines(file_path, code_type="utf-8"): + with open(file_path, encoding=code_type) as file: + lines = file.readlines() + return lines + + +def write_file(file_path, content): + with open(file_path, 'w+', newline='\n') as file: + file.write(content) + + +def write_file_lines(file_path, content, code_type="utf-8"): + with open(file_path, 'w', encoding=code_type) as file: + file.writelines(content) + + +def get_framework_lite_dir(root): + return os.path.join(root, 'drivers', 'adapter', 'khdf', 'liteos') + + +def get_vendor_root_dir(root): + return os.path.join(root, 'vendor') + + +def get_vendor_dir(root, vendor): + return os.path.join(get_vendor_root_dir(root), vendor) + + +def get_vendor_hdf_dir_framework(root): + relative_path = HdfToolSettings().get_drivers_path_framework() + return os.path.join(root, relative_path) + + +def get_vendor_hdf_dir_adapter(root, kernel='liteos'): + relative_path = HdfToolSettings().get_drivers_path_adapter() + return os.path.join(root, relative_path, kernel) + + +def get_vendor_lite_mk_path(root): + return os.path.join(get_vendor_hdf_dir_adapter(root), 'hdf_lite.mk') + + +def get_vendor_makefile_path(root, kernel): + return os.path.join(get_vendor_hdf_dir_adapter(root, kernel), 'Makefile') + + +def get_dot_configs_path(root, vendor, board): + path = os.path.join(root, "vendor", vendor, board, 'kernel_configs') + return [os.path.join(path, i) for i in os.listdir(path)] + + +def get_module_dir(root, vendor, module=""): + return os.path.join(get_vendor_hdf_dir_framework(root), 'model', module) + + +def get_drv_root_dir(root, vendor, module): + return os.path.join(get_module_dir(root, vendor, module), 'driver') + + +def get_drv_dir(root, vendor, module, driver): + return os.path.join(get_drv_root_dir(root, vendor, module), driver) + + +def get_drv_src_dir(root, vendor, module): + return get_drv_root_dir(root, vendor, module) + + +def get_drv_include_dir(root, vendor, module, driver): + return os.path.join(get_drv_dir(root, vendor, module, driver), 'include') + + +def get_vendor_kconfig_path(root, kernel): + hdf_dir = get_vendor_hdf_dir_adapter(root, kernel) + return os.path.join(hdf_dir, 'Kconfig') + + +def get_module_kconfig_path(root, vendor, module): + return os.path.join(get_drv_root_dir(root, vendor, module), 'Kconfig') + + +def get_module_mk_path(root, vendor, module): + return os.path.join(get_drv_root_dir(root, vendor, module), 'Makefile') + + +def get_liteos_a_dot_config_path(root): + return os.path.join(root, 'kernel', 'liteos_a', '.config') + + +def get_resources_dir(): + cur_dir = os.path.realpath(os.path.dirname(__file__)) + return os.path.join(cur_dir, 'resources') + + +def get_templates_dir(): + return os.path.join(get_resources_dir(), 'templates') + + +def get_templates_lite_dir(): + return os.path.join(get_templates_dir(), 'lite') + + +def get_template(template_name, type_='lite'): + templates_dir = os.path.join(get_templates_dir(), type_) + template = os.path.join(templates_dir, template_name) + with open(template) as file: + template_str = file.read() + return template_str + + +def get_hdf_lite_settings_mk_path(root_dir): + return os.path.join(get_framework_lite_dir(root_dir), + 'hdf_lite_settings.mk') + + +def get_hdf_lite_mk_path(root_dir): + return os.path.join(get_framework_lite_dir(root_dir), + 'hdf_lite.mk') + + +def get_hdf_lite_kconfig_path(root_dir): + return os.path.join(get_framework_lite_dir(root_dir), + 'Kconfig') + + +def is_commented_line(line, comment_start): + if line.strip().startswith(comment_start): + return True + else: + return False + + +def get_vendor_gn_path(root): + return os.path.join(get_vendor_hdf_dir_adapter(root), 'BUILD.gn') + + +def get_template_file_path(root, kernel='liteos'): + template_relative_path = HdfToolSettings().get_template_path() + relative_path2 = HdfToolSettings().get_drivers_path_framework() + return os.path.join(root, relative_path2, template_relative_path) + + +def get_hcs_file_path(root, vendor, board): + return os.path.join(root, "vendor", vendor, board, + "hdf_config", "device_info", "device_info.hcs") + + +def template_filename_filtrate(dir_path, kernal): + filename_list = [] + for filename in os.listdir(dir_path): + if filename.split("_")[0] == kernal.capitalize(): + filename_list.append(filename) + return filename_list + + +def get_create_model_info(root, create_data): + data = json.loads(create_data) + out_model_list = [] + if not data: + return [] + file_key_list = list(list(data.items())[0][-1].keys())[:-1] + for k, _ in data.items(): + model_file_path = {} + for key in file_key_list: + if key.split("_")[-1] == "path": + path_dict = data[k][key] + if isinstance(path_dict, dict): + for k_filename, file_path in path_dict.items(): + if not os.path.exists(os.path.join(root, file_path)): + model_file_path[k_filename] = " " + else: + model_file_path[k_filename] = path_dict[k_filename] + else: + hcs_file_path = os.path.join(root, path_dict) + if not os.path.exists(hcs_file_path): + model_file_path[key] = " " + else: + model_file_path[key] = path_dict + out_model_list.append({k: model_file_path}) + return out_model_list \ No newline at end of file diff --git a/tools/hc-gen/build_hcs.py b/tools/hdf_dev_eco_tool/main.py similarity index 52% rename from tools/hc-gen/build_hcs.py rename to tools/hdf_dev_eco_tool/main.py index d67bbd2400b9cb0b83be9bf450f9dbd39280cf8d..a9aa14688ab4e0bfe9cc8cd3511a41190ab19a16 100755 --- a/tools/hc-gen/build_hcs.py +++ b/tools/hdf_dev_eco_tool/main.py @@ -31,72 +31,44 @@ # ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE # POSSIBILITY OF SUCH DAMAGE. -import fcntl -import os import sys import argparse -import platform -import subprocess -import time -_LOCK_FILE_NAME = "._lock" -_BUILD_DIR = 'build' -_LOCK_FILE = '' - - -def lock(): - global _LOCK_FILE - global _BUILD_DIR - global _LOCK_FILE_NAME - if not os.path.exists(_BUILD_DIR): - os.mkdir(_BUILD_DIR) - lock_file = os.path.join(_BUILD_DIR, _LOCK_FILE_NAME) - if not os.path.exists(lock_file): - with open(lock_file, 'w') as l_file: - l_file.write("lock") - l_file.close - print('hc-gen lock file ' + lock_file) - _LOCK_FILE = open(lock_file, 'r') - fcntl.flock(_LOCK_FILE.fileno(), fcntl.LOCK_EX) - - -def unlock(): - global _LOCK_FILE - _LOCK_FILE.close() - - -def exec_command(cmd): - process = subprocess.Popen(cmd) - process.wait() - ret_code = process.returncode - - if ret_code != 0: - raise Exception("{} failed, return code is {}".format(cmd, ret_code)) - - -def make_hc_gen(current_dir): - exec_command(['make', '-C', current_dir, '-j8']) - - -def prepare(current_dir): - make_hc_gen(current_dir) - - -def main(argv): - lock() - current_dir = os.path.split(os.path.realpath(__file__))[0] - hc_gen = os.path.join(current_dir, 'build', 'hc-gen') - - host_hc_gen = argv[1] - if (os.path.exists(host_hc_gen)): - build_hcs_cmd = argv[1:] - else: - prepare(current_dir) - build_hcs_cmd = [hc_gen] + argv[1:] - - prepare(current_dir) - exec_command(build_hcs_cmd) - unlock() - -if __name__ == '__main__': - sys.exit(main(sys.argv)) +from command_line.hdf_tool_commands import HdfToolCommands +from hdf_tool_daemon_server import HdfToolDaemonServer +from hdf_tool_exception import HdfToolException +from command_line.hdf_command_error_code import CommandErrorCode + + +def check_python_version(): + if sys.version_info < (3, 0): + print('Please run with python version >= 3.0') + sys.exit(-1) + + +def main(): + check_python_version() + commands = HdfToolCommands() + help_info = 'Tools backend for hdf driver development.' + arg_parser = argparse.ArgumentParser(description=help_info) + arg_parser.add_argument('--run_as_daemon', action='store_true') + arg_parser.add_argument('--server_type', help='command_line or ls_hcs,' + 'default command_line', default='command_line') + arg_parser.add_argument('command', help=commands.help()) + arg_parser.add_argument('remainder_args', nargs=argparse.REMAINDER) + args = arg_parser.parse_args() + if args.run_as_daemon: + HdfToolDaemonServer(args.server_type).run() + return + try: + ret = commands.run(args.command, args.remainder_args) + if ret or isinstance(ret, list): + print(ret) + except HdfToolException as exc: + print('error: {}, {}'.format(exc.error_code, exc.exc_msg)) + except Exception as exc: + print('error: {}, {}'.format(CommandErrorCode.UNKNOWN_ERROR, str(exc))) + + +if __name__ == "__main__": + main() diff --git a/tools/hdf_dev_eco_tool/resources/create_model.config b/tools/hdf_dev_eco_tool/resources/create_model.config new file mode 100755 index 0000000000000000000000000000000000000000..9e26dfeeb6e641a33dae4961196235bdb965b21b --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/create_model.config @@ -0,0 +1 @@ +{} \ No newline at end of file diff --git a/tools/hdf_dev_eco_tool/resources/settings.json b/tools/hdf_dev_eco_tool/resources/settings.json new file mode 100755 index 0000000000000000000000000000000000000000..c38733ee51b040f1fe92973828129ce1d7742bf3 --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/settings.json @@ -0,0 +1,18 @@ +{ + "supported_boards": { + "hispark_taurus": { + "board_parent_path": "vendor/hisilicon/hispark_taurus", + "dot_config_path": "kernel/liteos_a/tools/build/config", + "dot_configs": ["hispark_taurus_debug_shell_tee.config", "hispark_taurus_debug_shell.config" + ,"hispark_taurus_release_tee.config", "hispark_taurus_release.config" + , "hispark_taurus_clang_release_tee.config", "hispark_taurus_clang_release.config"] + }, + "hispark_taurus_linux": { + "patch_and_config": ["hi3516dv300.patch", "hi3516dv300_small_defconfig", "hi3516dv300_standard_defconfig", + "small_common_defconfig", "standard_common_defconfig"] + } + }, + "drivers_path_relative_to_vendor": "drivers/framework", + "drivers_path_relative_adapter": "drivers/adapter/khdf", + "template_file_path": "tools/hdf_dev_eco_tool/resources/templates/lite" +} diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/Linux_Kconfig.template b/tools/hdf_dev_eco_tool/resources/templates/lite/Linux_Kconfig.template new file mode 100755 index 0000000000000000000000000000000000000000..952d17e018bbe388d81fdedb2c6e4e14a9bdbc5b --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/Linux_Kconfig.template @@ -0,0 +1,34 @@ +# Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this list of +# conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, this list +# of conditions and the following disclaimer in the documentation and/or other materials +# provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its contributors may be used +# to endorse or promote products derived from this software without specific prior written +# permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +config DRIVERS_HDF_${module_upper_case} + bool "Enable HDF ${module_lower_case} driver" + default n + depends on DRIVERS_HDF + help + Answer Y to enable HDF ${module_lower_case} driver. \ No newline at end of file diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/Linux_Makefile.template b/tools/hdf_dev_eco_tool/resources/templates/lite/Linux_Makefile.template new file mode 100755 index 0000000000000000000000000000000000000000..d1a0267ebd7a7e399d613263a4cbb0084a36d537 --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/Linux_Makefile.template @@ -0,0 +1,33 @@ +# +# Copyright (c) 2020-2021 Huawei Device Co., Ltd. +# +# This software is licensed under the terms of the GNU General Public +# License version 2, as published by the Free Software Foundation, and +# may be copied, distributed, and modified under those terms. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# + +${module_upper_case}_ROOT_DIR = ../../../../../framework/model/${module_lower_case}/driver + +obj-$(CONFIG_DRIVERS_HDF_${module_upper_case}) += \ + $(${module_upper_case}_ROOT_DIR)/${driver_name}_driver.o + +ccflags-y += -I$(srctree)/drivers/hdf/framework/include/core \ + -I$(srctree)/drivers/hdf/framework/core/common/include/host \ + -I$(srctree)/drivers/hdf/framework/include/utils \ + -I$(srctree)/drivers/hdf/framework/include/osal \ + -I$(srctree)/drivers/hdf/framework/ability/sbuf/include \ + -I$(srctree)/drivers/hdf/framework/include/platform \ + -I$(srctree)/drivers/hdf/framework/include/config \ + -I$(srctree)/drivers/hdf/framework/core/host/include \ + -I$(srctree)/drivers/hdf/framework/core/shared/include \ + -I$(srctree)/drivers/hdf/framework/utils/include \ + -I$(srctree)/drivers/hdf/khdf/osal/include + +ccflags-y +=-I$(srctree)/bounds_checking_function/include \ + -I$(srctree)/drivers/hdf/evdev \ No newline at end of file diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/Linux_built-in.template b/tools/hdf_dev_eco_tool/resources/templates/lite/Linux_built-in.template new file mode 100755 index 0000000000000000000000000000000000000000..9cf4aa1b484097c0d8d9ef49e666b41ae76277a8 --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/Linux_built-in.template @@ -0,0 +1,4 @@ +! +// 56 ` +../../../../../framework/model/${module_lower_case}/${module_lower_case}.o/ +/0 0 0 0 644 1912 ` \ No newline at end of file diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/Liteos_BUILD_gn.template b/tools/hdf_dev_eco_tool/resources/templates/lite/Liteos_BUILD_gn.template new file mode 100755 index 0000000000000000000000000000000000000000..9b648355eb7d5aa0d3a22b5087058c55462efa3b --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/Liteos_BUILD_gn.template @@ -0,0 +1,41 @@ +# Copyright (c) 2013-2019 Huawei Technologies Co., Ltd. All rights reserved. +# Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this list of +# conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, this list +# of conditions and the following disclaimer in the documentation and/or other materials +# provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its contributors may be used +# to endorse or promote products derived from this software without specific prior written +# permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import("//drivers/adapter/khdf/liteos/hdf.gni") +module_switch = defined(LOSCFG_DRIVERS_HDF_${module_upper_case}) +module_name = "hdf_${module_lower_case}_driver" +hdf_driver(module_name) { + FRAMEWORKS_${module_upper_case}_ROOT = "$HDF_FRAMEWORKS_PATH/model/${module_lower_case}" + sources = ["$FRAMEWORKS_${module_upper_case}_ROOT/driver/${driver_file_name}"] + + include_dirs = [ + "//third_party/FreeBSD/sys/dev/evdev/" + ] +} + diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/Liteos_Device_Info_Hcs.template b/tools/hdf_dev_eco_tool/resources/templates/lite/Liteos_Device_Info_Hcs.template new file mode 100755 index 0000000000000000000000000000000000000000..64e5b0c460cf7975a2835eebb6a590c61940e537 --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/Liteos_Device_Info_Hcs.template @@ -0,0 +1,15 @@ +${driver_name} :: host{ + hostName = "${driver_name}_host"; // hostÃû³Æ£¬host½ÚµãÊÇÓÃÀ´´æ·ÅijһÀàÇý¶¯µÄÈÝÆ÷ + priority = 100; // hostÆô¶¯ÓÅÏȼ¶£¨0-200£©£¬ÖµÔ½´óÓÅÏȼ¶Ô½µÍ£¬½¨ÒéĬÈÏÅä100£¬ÓÅÏȼ¶ÏàͬÔò²»±£Ö¤hostµÄ¼ÓÔØ˳Ðò + device_${driver_name} :: device { // ${driver_name}É豸½Úµã + device0 :: deviceNode { // ${driver_name}Çý¶¯µÄDeviceNode½Úµã + policy = 2; // policy×Ö¶ÎÊÇÇý¶¯·þÎñ·¢²¼µÄ²ßÂÔ + priority= 100; // Çý¶¯Æô¶¯ÓÅÏȼ¶£¨0-200£©£¬ÖµÔ½´óÓÅÏȼ¶Ô½µÍ£¬½¨ÒéĬÈÏÅä100£¬ÓÅÏȼ¶ÏàͬÔò²»±£Ö¤deviceµÄ¼ÓÔØ˳Ðò + preload = 0; // Çý¶¯°´Ðè¼ÓÔØ×ֶΠ+ permission = 0664; // Çý¶¯´´½¨É豸½ÚµãȨÏÞ + moduleName = "${driver_name}_driver"; // Çý¶¯Ãû³Æ£¬¸Ã×ֶεÄÖµ±ØÐëºÍÇý¶¯Èë¿Ú½á¹¹µÄmoduleNameÖµÒ»Ö + serviceName = "${driver_name}_service"; // Çý¶¯¶ÔÍâ·¢²¼·þÎñµÄÃû³Æ£¬±ØÐëΨһ + deviceMatchAttr = ""; // Çý¶¯Ë½ÓÐÊý¾ÝÆ¥ÅäµÄ¹Ø¼ü×Ö£¬±ØÐëºÍÇý¶¯Ë½ÓÐÊý¾ÝÅäÖñíÖеÄmatch_attrÖµÏàµÈ + } + } +} diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/Liteos_Kconfig.template b/tools/hdf_dev_eco_tool/resources/templates/lite/Liteos_Kconfig.template new file mode 100755 index 0000000000000000000000000000000000000000..bb09830c85d108bbb4c4714cee09d7c02747e567 --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/Liteos_Kconfig.template @@ -0,0 +1,34 @@ +# Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this list of +# conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, this list +# of conditions and the following disclaimer in the documentation and/or other materials +# provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its contributors may be used +# to endorse or promote products derived from this software without specific prior written +# permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +config DRIVERS_HDF_${module_upper_case} + bool "Enable HDF ${module_lower_case} driver" + default n + depends on DRIVERS_HDF + help + Answer Y to enable HDF ${module_lower_case} driver. \ No newline at end of file diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/Liteos_Makefile.template b/tools/hdf_dev_eco_tool/resources/templates/lite/Liteos_Makefile.template new file mode 100755 index 0000000000000000000000000000000000000000..e4574aff02ca7ca39debbeee3b860cd4358ad12c --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/Liteos_Makefile.template @@ -0,0 +1,39 @@ +# Copyright (c) 2020-2021 Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# 1. Redistributions of source code must retain the above copyright notice, this list of +# conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright notice, this list +# of conditions and the following disclaimer in the documentation and/or other materials +# provided with the distribution. +# +# 3. Neither the name of the copyright holder nor the names of its contributors may be used +# to endorse or promote products derived from this software without specific prior written +# permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, +# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR +# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +# EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +# PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; +# OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +# WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR +# OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF +# ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +include $(LITEOSTOPDIR)/../../drivers/adapter/khdf/liteos/lite.mk + +${module_upper_case}_ROOT_DIR = $(LITEOSTOPDIR)/../../drivers/framework/model/${module_lower_case} + +ifeq ($(LOSCFG_DRIVERS_HDF_${module_upper_case}), y) +MODULE_NAME := hdf_${module_lower_case}_driver +LOCAL_INCLUDE := $(${module_upper_case}_ROOT_DIR)/../../../../../third_party/FreeBSD/sys/dev/evdev +LOCAL_SRCS += $(${module_upper_case}_ROOT_DIR)/driver/${driver_file_name} + +endif +include $(HDF_DRIVER) diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/device_info_hcs.template b/tools/hdf_dev_eco_tool/resources/templates/lite/device_info_hcs.template new file mode 100755 index 0000000000000000000000000000000000000000..edcb42bc575353f0885207bcc29c1e908a5e85cd --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/device_info_hcs.template @@ -0,0 +1,15 @@ +${model_name} :: host{ + hostName = "${model_name}_host"; // Host name. The host node is used to store a certain type of drivers. + priority = 100; //Host startup priority (0-200). A larger value indicates a lower priority. The default value 100 is recommended. If the priorities are the same, the host loading sequence is random. + device_${model_name} :: device { // Device node of sample + device0 :: deviceNode { // DeviceNode of the sample driver + policy = 2; // Driver service release policy. For details, see section Driver Service Management. + priority= 100; // Driver startup priority (0-200). A larger value indicates a lower priority. The default value 100 is recommended. If the priorities are the same, the device loading sequence is random. + preload = 0; // On-demand loading of the driver. For details, see "NOTE" at the end of this section. + permission = 0664; // Permission for the driver to create device nodes. + moduleName = "${driver_name}_driver"; // Driver name. The value of this field must be the same as the value of moduleName in the driver entry structure. + serviceName = "${driver_name}_service"; // Name of the service released by the driver. The name must be unique. + deviceMatchAttr = ""; // Keyword matching the private data of the driver. The value must be the same as that of match_attr in the private data configuration table of the driver. + } + } +} diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver.c.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver.c.template new file mode 100755 index 0000000000000000000000000000000000000000..3ec5439c8ad360595e1042cab4e027b2ece59edb --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver.c.template @@ -0,0 +1,39 @@ +#include "hdf_device_desc.h" // Header file that describes the APIs provided by the HDF to the driver. +#include "hdf_log.h" // Header file that describes the log APIs provided by the HDF. + +#define HDF_LOG_TAG ${driver_lower_case}_driver // Tag contained in logs. If no tag is not specified, the default HDF_TAG is used. + +// The driver service struct definition +struct ITestDriverService { + struct IDeviceIoService ioService; // The first member of the service structure must be a member of type IDeviceIoService +}; + +// The driver service interface must be bound to the HDF for you to use the service capability. +static int32_t Hdf${driver_upper_camel_case}DriverBind(struct HdfDeviceObject *deviceObject) { + HDF_LOGI("${driver_lower_case} driver bind success"); + return 0; +} + +// Initialize the driver service. +static int32_t Hdf${driver_upper_camel_case}DriverInit(struct HdfDeviceObject *deviceObject) { + HDF_LOGI("Hello world"); + return 0; +} + +// Release the driver resources. +static void Hdf${driver_upper_camel_case}DriverRelease(struct HdfDeviceObject *deviceObject) { + HDF_LOGI("${driver_lower_case} driver Release success"); + return; +} + +// Define the object of the driver entry. The object must be a global variable of the HdfDriverEntry type (defined in hdf_device_desc.h). +struct HdfDriverEntry g_${driver_lower_case}DriverEntry = { + .moduleVersion = 1, + .moduleName = "${driver_lower_case}_driver", + .Bind = Hdf${driver_upper_camel_case}DriverBind, + .Init = Hdf${driver_upper_camel_case}DriverInit, + .Release = Hdf${driver_upper_camel_case}DriverRelease, +}; + +// Call HDF_INIT to register the driver entry with the HDF framework. When loading the driver, call the Bind function and then the Init function. If the Init function fails to be called, the HDF will call Release to release the driver resource and exit. +HDF_INIT(g_${driver_lower_case}DriverEntry); diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver.h.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver.h.template new file mode 100755 index 0000000000000000000000000000000000000000..3e462409471bf66a767e75772500fc7109b78773 --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver.h.template @@ -0,0 +1,10 @@ +#ifndef _${driver_upper_case}_DRIVER_H +#define _${driver_upper_case}_DRIVER_H + +#include "hdf_device_desc.h" + +struct ${driver_upper_camel_case}DriverService { + struct IDeviceIoService ${driver_lower_camel_case}Service; +}; + +#endif/*_${driver_upper_case}_DRIVER_H*/ diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_config.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_config.template new file mode 100755 index 0000000000000000000000000000000000000000..0657e42b742d17241e1674f90405beb9e1efcec9 --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_config.template @@ -0,0 +1,3 @@ +root { + +} \ No newline at end of file diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_kconfig.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_kconfig.template new file mode 100755 index 0000000000000000000000000000000000000000..ade08c636aa2aea31496185191f3be414fa3fe94 --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_kconfig.template @@ -0,0 +1,6 @@ +config DRIVERS_HDF_${driver_upper_case} + bool "Enable HDF ${driver_lower_case} driver" + default n + depends on DRIVERS_HDF_${module_upper_case} + help + Answer Y to enable HDF ${driver_lower_case} driver. \ No newline at end of file diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_makefile.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_makefile.template new file mode 100755 index 0000000000000000000000000000000000000000..19d4f048c58354c90f933820b1f0f580c951be89 --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_makefile.template @@ -0,0 +1,10 @@ +include $(LITEOSTOPDIR)/../../drivers/adapter/khdf/liteos/lite.mk + +MODULE_NAME := hdf${module_lower_case} + +LOCAL_INCLUDE := ./include +LOCAL_INCLUDE += ./src + +LOCAL_SRCS += $(wildcard ./src/*.c) + +include $(HDF_DRIVER) diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_manager_config.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_manager_config.template new file mode 100755 index 0000000000000000000000000000000000000000..2695a43a1f73605d96473b9cf6745e7896a24789 --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_manager_config.template @@ -0,0 +1,38 @@ +root { + device_info { + match_attr = "hdf_manager"; + template host { + hostName = ""; + priority = 100; + template device { + template deviceNode { + policy = 0; + priority = 100; + preload = 0; + permission = 0666; + moduleName = ""; + serviceName = ""; + deviceMatchAttr = ""; + } + } + } + platform :: host { + hostName = "platform_host"; + } + display :: host { + hostName = "display_host"; + } + network :: host { + hostName = "network_host"; + } + storage :: host { + hostName = "storage_host"; + } + media :: host { + hostName = "media_host"; + } + common :: host { + hostName = "common_host"; + } + } +} diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_manager_config_device.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_manager_config_device.template new file mode 100755 index 0000000000000000000000000000000000000000..04806197d6af761f6efef028d8a859d84b3b219e --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_manager_config_device.template @@ -0,0 +1,10 @@ + device_${driver_lower_case} :: device { + device0 :: deviceNode { + policy = 1; + priority = 100; + preload = 0; + permission = 0666; + moduleName = "${driver_lower_case}"; + serviceName = "${driver_lower_camel_case}Service"; + } + } \ No newline at end of file diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_manager_config_host.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_manager_config_host.template new file mode 100755 index 0000000000000000000000000000000000000000..1dac297e3f7928b8a86ff751c0660b495e69ec5a --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_driver_manager_config_host.template @@ -0,0 +1,3 @@ + ${module_lower_case} :: host { + hostName = "${module_lower_case}_host"; + } \ No newline at end of file diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_hcs_makefile.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_hcs_makefile.template new file mode 100755 index 0000000000000000000000000000000000000000..33e9df73be4d093f69c818067654a25443c41f6f --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_hcs_makefile.template @@ -0,0 +1,7 @@ +include $(LITEOSTOPDIR)/../../drivers/adapter/khdf/liteos/lite.mk + +MODULE_NAME := hdf_config + +LOCAL_PLATFORM_HCS_SRC := hdf.hcs + +include $(HDF_DRIVER) diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_module_kconfig.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_module_kconfig.template new file mode 100755 index 0000000000000000000000000000000000000000..3a5127a057271e0a061a8c378b4afb5a15eb70c3 --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_module_kconfig.template @@ -0,0 +1,6 @@ +config DRIVERS_HDF_${module_upper_case} + bool "Enable HDF ${module_lower_case} module" + default n + depends on DRIVERS_HDF + help + Answer Y to enable HDF ${module_lower_case} module. diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_module_mk.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_module_mk.template new file mode 100755 index 0000000000000000000000000000000000000000..a2c9859343779f94df777dbb68a8d43cbfc68f78 --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_module_mk.template @@ -0,0 +1,4 @@ +include $(LITEOSTOPDIR)/../../drivers/adapter/khdf/liteos/lite.mk + +MODULE_NAME := hdf${module_lower_case} +include $(HDF_DRIVER) diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_module_mk_driver.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_module_mk_driver.template new file mode 100755 index 0000000000000000000000000000000000000000..6502fecbd37b6bc418803dd4f20d42552830020a --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_module_mk_driver.template @@ -0,0 +1,5 @@ +ifeq ($(LOSCFG_DRIVERS_HDF_${driver_upper_case}), y) + LOCAL_INCLUDE += ./${driver_lower_case}/include + LOCAL_INCLUDE += ./${driver_lower_case}/src + LOCAL_SRCS += $(wildcard ./${driver_lower_case}/src/*.c) +endif \ No newline at end of file diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_vendor_kconfig.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_vendor_kconfig.template new file mode 100755 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_vendor_kconfig.template @@ -0,0 +1 @@ + diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_vendor_mk.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_vendor_mk.template new file mode 100755 index 0000000000000000000000000000000000000000..5c51b1ec423facfacf47c7a310701b976deff98d --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_vendor_mk.template @@ -0,0 +1,2 @@ +LITEOS_BASELIB += -lhdf_config +LIB_SUBDIRS += $(LITEOSTOPDIR)/../../${board_parent_path}/$(LITEOS_PLATFORM)/config diff --git a/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_vendor_mk_module.template b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_vendor_mk_module.template new file mode 100755 index 0000000000000000000000000000000000000000..14e31ffdd935b9d46c93d1b0e3478e8d76b2d0a7 --- /dev/null +++ b/tools/hdf_dev_eco_tool/resources/templates/lite/hdf_vendor_mk_module.template @@ -0,0 +1,4 @@ +ifeq ($(LOSCFG_DRIVERS_HDF_${module_upper_case}), y) + LITEOS_BASELIB += -lhdf_${module_lower_case}_driver + LIB_SUBDIRS += $(LITEOS_DRIVERS_HDF)/model/${module_lower_case} +endif \ No newline at end of file diff --git a/tools/hdi-gen/BUILD.gn b/tools/hdi-gen/BUILD.gn new file mode 100755 index 0000000000000000000000000000000000000000..bc63e124e9565a5b7f15b4d7b69fa32086a2fe3c --- /dev/null +++ b/tools/hdi-gen/BUILD.gn @@ -0,0 +1,22 @@ +# Copyright (c) 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. + +action("build_hdi_gen") { + script = "/usr/bin/env" + if (defined(ohos_lite)) { + script = "//build/lite/run_shell_cmd.py" + } + + outputs = [ "$target_out_dir/hdi-gen" ] + + args = [ + "make", + "-j8", + "-C", + rebase_path("."), + "TARGET_DIR=" + rebase_path(target_out_dir), + ] +} diff --git a/tools/hdi-gen/Makefile b/tools/hdi-gen/Makefile index 223697901399ba4fddc244a19d4c17429fecec72..033c257575dc88130660a9b5d366f76cff6dba2c 100755 --- a/tools/hdi-gen/Makefile +++ b/tools/hdi-gen/Makefile @@ -1,46 +1,35 @@ -TARGET = hdi-gen - -PWD:=$(shell pwd) -export BUILD_DIR = $(PWD)/build -export BOUNDS_CHECK_LIB := $(abspath ../../../../third_party/bounds_checking_function) -export INCLUDES = -I$(PWD) -I$(BOUNDS_CHECK_LIB)/include -export CXXFLAGS = -std=c++14 -O2 +# Copyright (c) 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. + +ifeq ($(findstring ;, $(PATH)), ;) + export PWD:=$(subst /,\, $(abspath $(dir $(realpath $(lastword $(MAKEFILE_LIST)))))) + export TARGET_DIR := $(PWD) + export BUILD_DIR:=$(TARGET_DIR)\build + export TARGET:=$(TARGET_DIR)\hdi-gen.exe +else + export PWD := $(abspath $(dir $(realpath $(lastword $(MAKEFILE_LIST))))) + export TARGET_DIR := $(PWD) + export BUILD_DIR = $(TARGET_DIR)/build + export TARGET:=$(TARGET_DIR)/hdi-gen +endif + +export CXXFLAGS = -std=c++14 -O2 -w export Q := @ export MAKEFLAGS += --no-print-directory -BOUNDS_CHECK_SOURCE := $(wildcard $(BOUNDS_CHECK_LIB)/src/*.c) -BOUNDS_CHECK_BUILD := $(BUILD_DIR)/bounds_checking_function -BOUNDS_CHECK_OBJS := $(addprefix $(BOUNDS_CHECK_BUILD)/, $(patsubst %.c, %.o, $(notdir $(BOUNDS_CHECK_SOURCE)))) -BOUNDS_CHECK_TARGET := $(BOUNDS_CHECK_BUILD)/bounds_checking_function.a - -SOURCE := $(wildcard *.cpp) -OBJS := $(addprefix $(BUILD_DIR)/, $(patsubst %.cpp, %.o, $(SOURCE))) - -SUBDIRS = util ast parser codegen -LIBS = $(BUILD_DIR)/codegen/codegen.a $(BUILD_DIR)/parser/parser.a $(BUILD_DIR)/ast/ast.a $(BUILD_DIR)/util/util.a - -all:$(TARGET) - -$(TARGET): $(OBJS) | $(BOUNDS_CHECK_TARGET) - $(Q) for subdir in $(SUBDIRS); do \ - $(MAKE) -C $$subdir || exit 1; \ - done - $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) $^ -o $@ $(LIBS) $(BOUNDS_CHECK_TARGET) - $(Q) echo $(TARGET):build successful. - -$(OBJS):$(SOURCE) - $(Q) mkdir -p $(BUILD_DIR) - $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ - -$(BOUNDS_CHECK_TARGET):$(BOUNDS_CHECK_OBJS) - $(Q) echo $(BOUNDS_CHECK_TARGET) - $(Q) ar -rc $@ $^ +MAKE_FILE_NAME = MakefileLinux +ifeq ($(findstring ;, $(PATH)), ;) + MAKE_FILE_NAME := MakefileWin +endif -$(BOUNDS_CHECK_BUILD)/%.o : $(BOUNDS_CHECK_LIB)/src/%.c - $(Q) mkdir -p $(BOUNDS_CHECK_BUILD) - $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ +all: + $(Q) echo start build $(TARGET) ... + $(Q) $(MAKE) -f $(MAKE_FILE_NAME) clean: - $(Q) rm -rf $(BUILD_DIR) $(TARGET) + $(Q) $(MAKE) -f $(MAKE_FILE_NAME) clean -.PHONY:all clean \ No newline at end of file +.PHONY: clean \ No newline at end of file diff --git a/tools/hdi-gen/MakefileLinux b/tools/hdi-gen/MakefileLinux new file mode 100755 index 0000000000000000000000000000000000000000..fe4bccf5a6b91d011c2691eaae46fe5a367a395b --- /dev/null +++ b/tools/hdi-gen/MakefileLinux @@ -0,0 +1,70 @@ +# Copyright (c) 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. + +BOUNDS_CHECK_DIR := $(abspath ../../../../third_party/bounds_checking_function) +INCLUDES = -I$(PWD) -I$(BOUNDS_CHECK_DIR)/include + +CODEGEN_SOURCE_DIR := $(PWD)/codegen +CODEGEN_SOURCE := $(wildcard $(CODEGEN_SOURCE_DIR)/*.cpp) +CODEGEN_OBJ_DIR := $(BUILD_DIR)/codegen +CODEGEN_OBJS := $(addprefix $(CODEGEN_OBJ_DIR)/, $(patsubst %.cpp, %.o, $(notdir $(CODEGEN_SOURCE)))) + +PARSER_SOURCE_DIR := $(PWD)/parser +PARSER_SOURCE := $(wildcard $(PARSER_SOURCE_DIR)/*.cpp) +PARSER_OBJS_DIR := $(BUILD_DIR)/parser +PARSER_OBJS := $(addprefix $(PARSER_OBJS_DIR)/, $(patsubst %.cpp, %.o, $(notdir $(PARSER_SOURCE)))) + +AST_SOURCE_DIR := $(PWD)/ast +AST_SOURCE := $(wildcard $(AST_SOURCE_DIR)/*.cpp) +AST_OBJS_DIR := $(BUILD_DIR)/ast +AST_OBJS := $(addprefix $(AST_OBJS_DIR)/, $(patsubst %.cpp, %.o, $(notdir $(AST_SOURCE)))) + +UTIL_SOURCE_DIR := $(PWD)/util +UTIL_SOURCE := $(wildcard $(UTIL_SOURCE_DIR)/*.cpp) +UTIL_OBJS_DIR := $(BUILD_DIR)/util +UTIL_OBJS := $(addprefix $(UTIL_OBJS_DIR)/, $(patsubst %.cpp, %.o, $(notdir $(UTIL_SOURCE)))) + +BOUNDS_CHECK_SOURCE_DIR := $(abspath ../../../../third_party/bounds_checking_function/src) +BOUNDS_CHECK_SOURCE := $(wildcard $(BOUNDS_CHECK_SOURCE_DIR)/*.c) +BOUNDS_CHECK_OBJS_DIR := $(BUILD_DIR)/bounds_checking_function +BOUNDS_CHECK_OBJS := $(addprefix $(BOUNDS_CHECK_OBJS_DIR)/, $(patsubst %.c, %.o, $(notdir $(BOUNDS_CHECK_SOURCE)))) + +MAIN_SOURCE := $(wildcard *.cpp) +MAIN_OBJS := $(addprefix $(BUILD_DIR)/, $(patsubst %.cpp, %.o, $(MAIN_SOURCE))) + +all:$(TARGET) +$(TARGET) : $(BOUNDS_CHECK_OBJS) $(UTIL_OBJS) $(AST_OBJS) $(PARSER_OBJS) $(CODEGEN_OBJS) $(MAIN_OBJS) + $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) $^ -o $@ + $(Q) echo $(TARGET):build successful. + +$(BUILD_DIR)/%.o : %.cpp + $(Q) mkdir -p $(BUILD_DIR) + $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ + +$(CODEGEN_OBJ_DIR)/%.o : $(CODEGEN_SOURCE_DIR)/%.cpp + $(Q) mkdir -p $(CODEGEN_OBJ_DIR) + $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ + +$(PARSER_OBJS_DIR)/%.o : $(PARSER_SOURCE_DIR)/%.cpp + $(Q) mkdir -p $(PARSER_OBJS_DIR) + $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ + +$(AST_OBJS_DIR)/%.o : $(AST_SOURCE_DIR)/%.cpp + $(Q) mkdir -p $(AST_OBJS_DIR) + $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ + +$(UTIL_OBJS_DIR)/%.o : $(UTIL_SOURCE_DIR)/%.cpp + $(Q) mkdir -p $(UTIL_OBJS_DIR) + $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ + +$(BOUNDS_CHECK_OBJS_DIR)/%.o : $(BOUNDS_CHECK_SOURCE_DIR)/%.c + $(Q) mkdir -p $(BOUNDS_CHECK_OBJS_DIR) + $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ + +clean: + $(Q) rm -rf $(TARGET) $(BUILD_DIR) + +.PHONY:all clean \ No newline at end of file diff --git a/tools/hdi-gen/MakefileWin b/tools/hdi-gen/MakefileWin new file mode 100755 index 0000000000000000000000000000000000000000..c9ef65b68ffb252585a8afe262050b02c04333d6 --- /dev/null +++ b/tools/hdi-gen/MakefileWin @@ -0,0 +1,71 @@ +# Copyright (c) 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. + +BOUNDS_CHECK_DIR:=$(subst /,\, $(abspath ..\..\..\..\third_party\bounds_checking_function)) +INCLUDES:=-I $(PWD) -I $(BOUNDS_CHECK_DIR)\include + +CODEGEN_SOURCE_DIR:=$(PWD)\codegen +CODEGEN_SOURCE:=$(wildcard $(CODEGEN_SOURCE_DIR)/*.cpp) +CODEGEN_OBJ_DIR:=$(BUILD_DIR)\codegen +CODEGEN_OBJS:=$(addprefix $(CODEGEN_OBJ_DIR)\, $(patsubst %.cpp, %.o, $(notdir $(CODEGEN_SOURCE)))) + +PARSER_SOURCE_DIR:=$(PWD)\parser +PARSER_SOURCE:=$(wildcard $(PARSER_SOURCE_DIR)/*.cpp) +PARSER_OBJS_DIR:=$(BUILD_DIR)\parser +PARSER_OBJS:=$(addprefix $(PARSER_OBJS_DIR)\, $(patsubst %.cpp, %.o, $(notdir $(PARSER_SOURCE)))) + +AST_SOURCE_DIR:=$(PWD)\ast +AST_SOURCE:=$(wildcard $(AST_SOURCE_DIR)/*.cpp) +AST_OBJS_DIR:=$(BUILD_DIR)\ast +AST_OBJS:=$(addprefix $(AST_OBJS_DIR)\, $(patsubst %.cpp, %.o, $(notdir $(AST_SOURCE)))) + +UTIL_SOURCE_DIR:=$(PWD)\util +UTIL_SOURCE:=$(wildcard $(UTIL_SOURCE_DIR)/*.cpp) +UTIL_OBJS_DIR:=$(BUILD_DIR)\util +UTIL_OBJS:=$(addprefix $(UTIL_OBJS_DIR)\, $(patsubst %.cpp, %.o, $(notdir $(UTIL_SOURCE)))) + +BOUNDS_CHECK_SOURCE_DIR:=$(subst /,\, $(abspath ..\..\..\..\third_party\bounds_checking_function\src)) +BOUNDS_CHECK_SOURCE:=$(wildcard $(BOUNDS_CHECK_SOURCE_DIR)/*.c) +BOUNDS_CHECK_OBJS_DIR:=$(BUILD_DIR)\bounds_checking_function +BOUNDS_CHECK_OBJS:=$(addprefix $(BOUNDS_CHECK_OBJS_DIR)\, $(patsubst %.c, %.o, $(notdir $(BOUNDS_CHECK_SOURCE)))) + +MAIN_SOURCE:=$(wildcard *.cpp) +MAIN_OBJS:=$(addprefix $(BUILD_DIR)\, $(patsubst %.cpp, %.o, $(MAIN_SOURCE))) + +all : $(TARGET) +$(TARGET) : $(BOUNDS_CHECK_OBJS) $(UTIL_OBJS) $(AST_OBJS) $(PARSER_OBJS) $(CODEGEN_OBJS) $(MAIN_OBJS) + $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) $^ -o $@ + $(Q) echo $(TARGET):build successful. + +$(BUILD_DIR)\\%.o : %.cpp + $(Q) if not exist $(BUILD_DIR) (mkdir $(BUILD_DIR)) + $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ + +$(CODEGEN_OBJ_DIR)\\%.o : $(CODEGEN_SOURCE_DIR)\\%.cpp + $(Q) if not exist $(CODEGEN_OBJ_DIR) (mkdir $(CODEGEN_OBJ_DIR)) + $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ + +$(PARSER_OBJS_DIR)\\%.o : $(PARSER_SOURCE_DIR)\\%.cpp + $(Q) if not exist $(PARSER_OBJS_DIR) (mkdir $(PARSER_OBJS_DIR)) + $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ + +$(AST_OBJS_DIR)\\%.o : $(AST_SOURCE_DIR)\\%.cpp + $(Q) if not exist $(AST_OBJS_DIR) (mkdir $(AST_OBJS_DIR)) + $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ + +$(UTIL_OBJS_DIR)\\%.o : $(UTIL_SOURCE_DIR)\\%.cpp + $(Q) if not exist $(UTIL_OBJS_DIR) (mkdir $(UTIL_OBJS_DIR)) + $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ + +$(BOUNDS_CHECK_OBJS_DIR)\\%.o : $(BOUNDS_CHECK_SOURCE_DIR)\\%.c + $(Q) if not exist $(BOUNDS_CHECK_OBJS_DIR) (mkdir $(BOUNDS_CHECK_OBJS_DIR)) + $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ + +clean: + $(Q) if exist $(TARGET) (del $(TARGET)) + $(Q) if exist $(BUILD_DIR) (rd /s /q $(BUILD_DIR)) + +.PHONY:all clean \ No newline at end of file diff --git a/tools/hdi-gen/ast/Makefile b/tools/hdi-gen/ast/Makefile deleted file mode 100755 index 04f71251b5509d4d7c69d9a72589af26c29159cc..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/ast/Makefile +++ /dev/null @@ -1,12 +0,0 @@ -OBJS_DIR:=$(BUILD_DIR)/ast -TARGET = $(OBJS_DIR)/ast.a -SOURCE:=$(wildcard *.cpp) -OBJS:=$(patsubst %.cpp, $(OBJS_DIR)/%.o, $(SOURCE)) - -$(TARGET):$(OBJS) - $(Q) echo $(TARGET) - $(Q) ar -rc $@ $^ - -$(OBJS_DIR)/%.o:%.cpp - $(Q) mkdir -p $(dir $@) - $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast.h b/tools/hdi-gen/ast/ast.h index 5804b77e832bd500cc144c29f3f92edbe09369d4..d3a42fe06e2156e6824c38ee36fda4440fa10223 100755 --- a/tools/hdi-gen/ast/ast.h +++ b/tools/hdi-gen/ast/ast.h @@ -171,4 +171,4 @@ private: } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_AST_H +#endif // OHOS_HDI_AST_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_array_type.cpp b/tools/hdi-gen/ast/ast_array_type.cpp index 62e239d3913315d1c1016f19e0e322b68d85cd32..a2a1ec630f6ba459d41c93a04d4377f3231e34cd 100755 --- a/tools/hdi-gen/ast/ast_array_type.cpp +++ b/tools/hdi-gen/ast/ast_array_type.cpp @@ -7,6 +7,7 @@ */ #include "ast/ast_array_type.h" +#include "util/options.h" namespace OHOS { namespace HDI { @@ -82,57 +83,33 @@ String ASTArrayType::EmitJavaType(TypeMode mode, bool isInnerType) const return String::Format("%s[]", elementType_->EmitJavaType(TypeMode::NO_MODE, false).string()); } -void ASTArrayType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTArrayType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { String lenName = String::Format("%sLen", name.string()); sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint32(%s, %s)) {\n", parcelName.string(), lenName.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); - sb.Append(prefix).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); - String elementName; - String elementReadName; - - if (elementType_->GetTypeKind() == TypeKind::TYPE_STRUCT - || elementType_->GetTypeKind() == TypeKind::TYPE_UNION) { - elementName = String::Format("%s[i]", name.string()); - elementReadName = "&" + elementName; + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix).AppendFormat("for (i = 0; i < %s; i++) {\n", lenName.string()); } else { - elementName = String::Format("%s[i]", name.string()); - elementReadName = elementName; + sb.Append(prefix).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); } - elementType_->EmitCProxyWriteVar(parcelName, elementReadName, gotoLabel, sb, prefix + TAB); - sb.Append(prefix).Append("}\n"); -} - -void ASTArrayType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint32(%s, %sLen)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); - sb.Append(prefix).Append("}\n"); - sb.Append("\n"); - sb.Append(prefix).AppendFormat("for (uint32_t i = 0; i < %sLen; i++) {\n", name.string(), name.string()); - - String element; + String elementName = ""; if (elementType_->GetTypeKind() == TypeKind::TYPE_STRUCT || elementType_->GetTypeKind() == TypeKind::TYPE_UNION) { - element = String::Format("&%s[i]", name.string()); + elementName = String::Format("&%s[i]", name.string()); } else { - element = String::Format("%s[i]", name.string()); + elementName = String::Format("%s[i]", name.string()); } - elementType_->EmitCStubWriteVar(parcelName, element, sb, prefix + TAB); + elementType_->EmitCWriteVar(parcelName, elementName, gotoLabel, sb, prefix + g_tab); sb.Append(prefix).Append("}\n"); } @@ -142,51 +119,39 @@ void ASTArrayType::EmitCProxyReadVar(const String& parcelName, const String& nam String lenName = String::Format("%sLen", name.string()); sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint32(%s, %s)) {\n", parcelName.string(), lenName.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s size failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix).Append("}\n\n"); - if (elementType_->GetTypeKind() == TypeKind::TYPE_STRING) { - sb.Append(prefix).AppendFormat("*%s = (%s*)OsalMemAlloc(sizeof(%s) * (*%s));\n", - name.string(), elementType_->EmitCType().string(), elementType_->EmitCType().string(), - lenName.string()); - sb.Append(prefix).AppendFormat("if (*%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat("ec = HDF_ERR_MALLOC_FAIL;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).AppendFormat("}\n"); + EmitCMallocVar(name, lenName, true, gotoLabel, sb, prefix); + sb.Append("\n"); + + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix).AppendFormat("for (i = 0; i < *%s; i++) {\n", lenName.string()); } else { - sb.Append(prefix).AppendFormat("*%s = (%s*)OsalMemCalloc(sizeof(%s) * (*%s));\n", - name.string(), elementType_->EmitCType().string(), elementType_->EmitCType().string(), - lenName.string()); - sb.Append(prefix).AppendFormat("if (*%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat("ec = HDF_ERR_MALLOC_FAIL;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).AppendFormat("}\n"); + sb.Append(prefix).AppendFormat("for (uint32_t i = 0; i < *%s; i++) {\n", lenName.string()); } - sb.Append(prefix).AppendFormat("for (uint32_t i = 0; i < *%s; i++) {\n", lenName.string()); + if (elementType_->GetTypeKind() == TypeKind::TYPE_STRING) { - String cpName = String::Format("%sCp", name.string()); - elementType_->EmitCProxyReadVar(parcelName, cpName, true, gotoLabel, sb, prefix + TAB); - sb.Append(prefix).Append(TAB).AppendFormat("(*%s)[i] = strdup(%sCp);\n", - name.string(), name.string()); + EmitCProxyReadStrElement(parcelName, name, gotoLabel, sb, prefix); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_STRUCT) { String element = String::Format("&(*%s)[i]", name.string()); - elementType_->EmitCProxyReadVar(parcelName, element, true, gotoLabel, sb, prefix + TAB); + elementType_->EmitCProxyReadVar(parcelName, element, true, gotoLabel, sb, prefix + g_tab); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_UNION) { String element = String::Format("&(*%s)[i]", name.string()); String elementCp = String::Format("%sElementCp", name.string()); - elementType_->EmitCProxyReadVar(parcelName, elementCp, true, gotoLabel, sb, prefix + TAB); - sb.Append(prefix + TAB).AppendFormat("(void)memcpy_s(%s, sizeof(%s), %s, sizeof(%s));\n", + elementType_->EmitCProxyReadVar(parcelName, elementCp, true, gotoLabel, sb, prefix + g_tab); + sb.Append(prefix + g_tab).AppendFormat("(void)memcpy_s(%s, sizeof(%s), %s, sizeof(%s));\n", element.string(), elementType_->EmitCType().string(), elementCp.string(), elementType_->EmitCType().string()); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_FILEDESCRIPTOR) { String element = String::Format("(*%s)[i]", name.string()); - elementType_->EmitCProxyReadVar(parcelName, element, true, gotoLabel, sb, prefix + TAB); + elementType_->EmitCProxyReadVar(parcelName, element, true, gotoLabel, sb, prefix + g_tab); } else { String element = String::Format("&(*%s)[i]", name.string()); - elementType_->EmitCProxyReadVar(parcelName, element, true, gotoLabel, sb, prefix + TAB); + elementType_->EmitCProxyReadVar(parcelName, element, true, gotoLabel, sb, prefix + g_tab); } sb.Append(prefix).Append("}\n"); } @@ -197,54 +162,41 @@ void ASTArrayType::EmitCStubReadVar(const String& parcelName, const String& name String lenName = String::Format("%sLen", name.string()); sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint32(%s, &%s)) {\n", parcelName.string(), lenName.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s size failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); - sb.Append(prefix).Append("}\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); + sb.Append(prefix).Append("}\n\n"); sb.Append(prefix).AppendFormat("if (%s > 0) {\n", lenName.string()); - if (elementType_->GetTypeKind() == TypeKind::TYPE_STRING) { - sb.Append(prefix + TAB).AppendFormat("%s = (%s*)OsalMemAlloc(sizeof(%s) * (%s));\n", name.string(), - elementType_->EmitCType().string(), elementType_->EmitCType().string(), lenName.string()); - sb.Append(prefix + TAB).AppendFormat("if (%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB + TAB).AppendFormat("ec = HDF_ERR_MALLOC_FAIL;\n"); - sb.Append(prefix + TAB + TAB).AppendFormat("goto errors;\n"); - sb.Append(prefix + TAB).AppendFormat("}\n"); + EmitCMallocVar(name, lenName, false, "errors", sb, prefix + g_tab); + sb.Append("\n"); + + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix + g_tab).AppendFormat("for (i = 0; i < %s; i++) {\n", lenName.string()); } else { - sb.Append(prefix + TAB).AppendFormat("%s = (%s*)OsalMemCalloc(sizeof(%s) * (%s));\n", - name.string(), elementType_->EmitCType().string(), elementType_->EmitCType().string(), - lenName.string()); - sb.Append(prefix + TAB).AppendFormat("if (%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB + TAB).AppendFormat("ec = HDF_ERR_MALLOC_FAIL;\n"); - sb.Append(prefix + TAB + TAB).AppendFormat("goto errors;\n"); - sb.Append(prefix + TAB).AppendFormat("}\n"); + sb.Append(prefix + g_tab).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); } - - sb.Append(prefix + TAB).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); - if (elementType_->GetTypeKind() == TypeKind::TYPE_STRING) { - String element = String::Format("%sCp", name.string()); - elementType_->EmitCStubReadVar(parcelName, element, sb, prefix + TAB + TAB); - sb.Append(prefix + TAB + TAB).AppendFormat("%s[i] = strdup(%sCp);\n", name.string(), name.string()); + EmitCStubReadStrElement(parcelName, name, sb, prefix); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_STRUCT) { String element = String::Format("&%s[i]", name.string()); - elementType_->EmitCStubReadVar(parcelName, element, sb, prefix + TAB + TAB); + elementType_->EmitCStubReadVar(parcelName, element, sb, prefix + g_tab + g_tab); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_UNION) { String element = String::Format("%s[i]", name.string()); String elementCp = String::Format("%sElementCp", name.string()); - elementType_->EmitCStubReadVar(parcelName, elementCp, sb, prefix + TAB + TAB); - sb.Append(prefix + TAB + TAB).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", + elementType_->EmitCStubReadVar(parcelName, elementCp, sb, prefix + g_tab + g_tab); + sb.Append(prefix + g_tab + g_tab).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", element.string(), elementType_->EmitCType().string(), elementCp.string(), elementType_->EmitCType().string()); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_FILEDESCRIPTOR) { String element = String::Format("%s[i]", name.string()); - elementType_->EmitCStubReadVar(parcelName, element, sb, prefix + TAB + TAB); + elementType_->EmitCStubReadVar(parcelName, element, sb, prefix + g_tab + g_tab); } else { String element = String::Format("&%s[i]", name.string()); - elementType_->EmitCStubReadVar(parcelName, element, sb, prefix + TAB + TAB); + elementType_->EmitCStubReadVar(parcelName, element, sb, prefix + g_tab + g_tab); } - sb.Append(prefix + TAB).Append("}\n"); + sb.Append(prefix + g_tab).Append("}\n"); sb.Append(prefix).Append("}\n"); } @@ -252,14 +204,14 @@ void ASTArrayType::EmitCppWriteVar(const String& parcelName, const String& name, const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteUint32(%s.size())) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s.size() failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); String elementName = String::Format("it%d", innerLevel++); sb.Append(prefix).AppendFormat("for (auto %s : %s) {\n", elementName.string(), name.string()); - elementType_->EmitCppWriteVar(parcelName, elementName, sb, prefix + TAB, innerLevel); + elementType_->EmitCppWriteVar(parcelName, elementName, sb, prefix + g_tab, innerLevel); sb.Append(prefix).Append("}\n"); } @@ -274,22 +226,27 @@ void ASTArrayType::EmitCppReadVar(const String& parcelName, const String& name, innerLevel, innerLevel, name.string(), innerLevel); String valueName = String::Format("value%d", innerLevel++); - elementType_->EmitCppReadVar(parcelName, valueName, sb, prefix + TAB, true, innerLevel); - sb.Append(prefix + TAB).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); + elementType_->EmitCppReadVar(parcelName, valueName, sb, prefix + g_tab, true, innerLevel); + sb.Append(prefix + g_tab).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); sb.Append(prefix).Append("}\n"); } void ASTArrayType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint32(data, %sLen)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %sLen failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); - sb.Append(prefix).AppendFormat("for (uint32_t i = 0; i < %sLen; i++) {\n", name.string()); + + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix).AppendFormat("for (i = 0; i < %sLen; i++) {\n", name.string()); + } else { + sb.Append(prefix).AppendFormat("for (uint32_t i = 0; i < %sLen; i++) {\n", name.string()); + } String elementName = String::Format("(%s)[i]", name.string()); - elementType_->EmitCMarshalling(elementName, sb, prefix + TAB); + elementType_->EmitCMarshalling(elementName, sb, prefix + g_tab); sb.Append(prefix).Append("}\n"); } @@ -298,56 +255,83 @@ void ASTArrayType::EmitCUnMarshalling(const String& name, StringBuilder& sb, con { String lenName = String::Format("%sLen", name.string()); sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint32(data, &%s)) {\n", lenName.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", lenName.string()); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); sb.Append(prefix).AppendFormat("if (%s > 0) {\n", lenName.string()); - String newPrefix = prefix + TAB; + String newPrefix = prefix + g_tab; sb.Append(newPrefix).AppendFormat("%s = (%s*)OsalMemCalloc(sizeof(%s) * %s);\n", name.string(), elementType_->EmitCType().string(), elementType_->EmitCType().string(), lenName.string()); sb.Append(newPrefix).AppendFormat("if (%s == NULL) {\n", name.string()); - sb.Append(newPrefix + TAB).AppendFormat("goto errors;\n"); + sb.Append(newPrefix + g_tab).AppendFormat("goto errors;\n"); sb.Append(newPrefix).Append("}\n"); freeObjStatements.push_back(String::Format("OsalMemFree(%s);\n", name.string())); - sb.Append(newPrefix).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); + + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(newPrefix).AppendFormat("for (i = 0; i < %s; i++) {\n", lenName.string()); + } else { + sb.Append(newPrefix).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); + } + if (elementType_->GetTypeKind() == TypeKind::TYPE_STRING) { - String element = String::Format("%sElement", name.string()); - elementType_->EmitCUnMarshalling(element, sb, newPrefix + TAB, freeObjStatements); - sb.Append(newPrefix).Append(TAB).AppendFormat("%s[i] = strdup(%s);\n", - name.string(), element.string()); + EmitCStringElementUnMarshalling(name, sb, newPrefix, freeObjStatements); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_STRUCT) { String element = String::Format("&%s[i]", name.string()); - elementType_->EmitCUnMarshalling(element, sb, newPrefix + TAB, freeObjStatements); + elementType_->EmitCUnMarshalling(element, sb, newPrefix + g_tab, freeObjStatements); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_UNION) { String element = String::Format("%s[i]", name.string()); String elementCp = String::Format("%sElementCp", name.string()); - elementType_->EmitCUnMarshalling(elementCp, sb, newPrefix + TAB, freeObjStatements); - sb.Append(newPrefix + TAB).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", + elementType_->EmitCUnMarshalling(elementCp, sb, newPrefix + g_tab, freeObjStatements); + sb.Append(newPrefix + g_tab).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", element.string(), elementType_->EmitCType().string(), elementCp.string(), elementType_->EmitCType().string()); } else { String element = String::Format("%s[i]", name.string()); - elementType_->EmitCUnMarshalling(element, sb, newPrefix + TAB, freeObjStatements); + elementType_->EmitCUnMarshalling(element, sb, newPrefix + g_tab, freeObjStatements); } sb.Append(newPrefix).Append("}\n"); sb.Append(prefix).Append("}\n"); freeObjStatements.pop_back(); } +void ASTArrayType::EmitCStringElementUnMarshalling(const String& name, StringBuilder& sb, const String& newPrefix, + std::vector& freeObjStatements) const +{ + String element = String::Format("%sElement", name.string()); + elementType_->EmitCUnMarshalling(element, sb, newPrefix + g_tab, freeObjStatements); + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(newPrefix).AppendFormat("%s[i] = (char*)OsalMemCalloc(strlen(%s) + 1);\n", + name.string(), element.string()); + sb.Append(newPrefix).AppendFormat("if (%s[i] == NULL) {\n", name.string()); + sb.Append(newPrefix + g_tab).AppendFormat("goto errors;\n"); + sb.Append(newPrefix).Append("}\n\n"); + + sb.Append(newPrefix).AppendFormat("if (strcpy_s((%s)[i], (strlen(%s) + 1), %s) != HDF_SUCCESS) {\n", + name.string(), element.string(), element.string()); + sb.Append(newPrefix + g_tab).AppendFormat("HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", + element.string()); + sb.Append(newPrefix + g_tab).Append("goto errors;\n"); + sb.Append(newPrefix).Append("}\n"); + } else { + sb.Append(newPrefix).Append(g_tab).AppendFormat("%s[i] = strdup(%s);\n", + name.string(), element.string()); + } +} + void ASTArrayType::EmitCppMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteUint32(%s.size())) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s.size failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); String elementName = String::Format("it%d", innerLevel++); sb.Append(prefix).AppendFormat("for (auto %s : %s) {\n", elementName.string(), name.string()); - elementType_->EmitCppMarshalling(parcelName, elementName, sb, prefix + TAB, innerLevel); + elementType_->EmitCppMarshalling(parcelName, elementName, sb, prefix + g_tab, innerLevel); sb.Append(prefix).Append("}\n"); } @@ -366,24 +350,255 @@ void ASTArrayType::EmitCppUnMarshalling(const String& parcelName, const String& String valueName = String::Format("value%d", innerLevel++); if (elementType_->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append(prefix + TAB).AppendFormat("%s %s;\n", + sb.Append(prefix + g_tab).AppendFormat("%s %s;\n", elementType_->EmitCppType().string(), valueName.string()); - elementType_->EmitCppUnMarshalling(parcelName, valueName, sb, prefix + TAB, true, innerLevel); - sb.Append(prefix + TAB).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); + elementType_->EmitCppUnMarshalling(parcelName, valueName, sb, prefix + g_tab, true, innerLevel); + sb.Append(prefix + g_tab).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_UNION) { - sb.Append(prefix + TAB).AppendFormat("%s %s;\n", + sb.Append(prefix + g_tab).AppendFormat("%s %s;\n", elementType_->EmitCppType().string(), valueName.string()); String cpName = String::Format("%sCp", valueName.string()); - elementType_->EmitCppUnMarshalling(parcelName, cpName, sb, prefix + TAB, true, innerLevel); - sb.Append(prefix + TAB).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", + elementType_->EmitCppUnMarshalling(parcelName, cpName, sb, prefix + g_tab, true, innerLevel); + sb.Append(prefix + g_tab).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", valueName.string(), elementType_->EmitCppType().string(), cpName.string(), elementType_->EmitCppType().string()); - sb.Append(prefix + TAB).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); + sb.Append(prefix + g_tab).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); } else { - elementType_->EmitCppUnMarshalling(parcelName, valueName, sb, prefix + TAB, true, innerLevel); - sb.Append(prefix + TAB).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); + elementType_->EmitCppUnMarshalling(parcelName, valueName, sb, prefix + g_tab, true, innerLevel); + sb.Append(prefix + g_tab).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); } sb.Append(prefix).Append("}\n"); } + +void ASTArrayType::EmitMemoryRecycle(const String& name, bool isClient, bool ownership, StringBuilder& sb, + const String& prefix) const +{ + String varName = isClient ? String::Format("*%s", name.string()) : name; + String lenName = isClient ? String::Format("*%sLen", name.string()) : String::Format("%sLen", name.string()); + + sb.Append(prefix).AppendFormat("if (%s > 0 && %s != NULL) {\n", lenName.string(), varName.string()); + if (elementType_->GetTypeKind() == TypeKind::TYPE_STRING || elementType_->GetTypeKind() == TypeKind::TYPE_STRUCT) { + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix + g_tab).AppendFormat("for (i = 0; i < %s; i++) {\n", lenName.string()); + } else { + sb.Append(prefix + g_tab).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); + } + + String elementName = isClient ? String::Format("(%s)[i]", varName.string()) : + String::Format("%s[i]", varName.string()); + elementType_->EmitMemoryRecycle(elementName, false, false, sb, prefix + g_tab + g_tab); + sb.Append(prefix + g_tab).Append("}\n"); + } + + sb.Append(prefix + g_tab).AppendFormat("OsalMemFree(%s);\n", varName.string()); + if (isClient) { + sb.Append(prefix + g_tab).AppendFormat("%s = NULL;\n", varName.string()); + } + + sb.Append(prefix).Append("}\n"); +} + +void ASTArrayType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("if (%s == null) {\n", name.string()); + sb.Append(prefix).AppendFormat(" %s.writeInt(-1);\n", parcelName.string()); + sb.Append(prefix).Append("} else { \n"); + EmitJavaWriteArrayVar(parcelName, name, sb, prefix + g_tab); + sb.Append(prefix).Append("}\n"); +} + +void ASTArrayType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + switch (elementType_->GetTypeKind()) { + case TypeKind::TYPE_BOOLEAN: + sb.Append(prefix).AppendFormat("%s.readBooleanArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_BYTE: + sb.Append(prefix).AppendFormat("%s.readByteArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_SHORT: + sb.Append(prefix).AppendFormat("%s.readShortArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_INT: + case TypeKind::TYPE_FILEDESCRIPTOR: + sb.Append(prefix).AppendFormat("%s.readIntArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_LONG: + sb.Append(prefix).AppendFormat("%s.readLongArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_FLOAT: + sb.Append(prefix).AppendFormat("%s.readFloatArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_DOUBLE: + sb.Append(prefix).AppendFormat("%s.readDoubleArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_STRING: + sb.Append(prefix).AppendFormat("%s.readStringArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_SEQUENCEABLE: + sb.Append(prefix).AppendFormat("%s.readSequenceableArray(%s);\n", parcelName.string(), name.string()); + break; + default: + break; + } +} + +void ASTArrayType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + switch (elementType_->GetTypeKind()) { + case TypeKind::TYPE_BOOLEAN: + sb.Append(prefix).AppendFormat("%s[] %s = %s.readBooleanArray();\n", + elementType_->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); + break; + case TypeKind::TYPE_BYTE: + sb.Append(prefix).AppendFormat("%s[] %s = %s.readByteArray();\n", + elementType_->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); + break; + case TypeKind::TYPE_SHORT: + sb.Append(prefix).AppendFormat("%s[] %s = %s.readShortArray();\n", + elementType_->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); + break; + case TypeKind::TYPE_INT: + case TypeKind::TYPE_FILEDESCRIPTOR: + sb.Append(prefix).AppendFormat("%s[] %s = %s.readIntArray();\n", + elementType_->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); + break; + case TypeKind::TYPE_LONG: + sb.Append(prefix).AppendFormat("%s[] %s = %s.readLongArray();\n", + elementType_->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); + break; + case TypeKind::TYPE_FLOAT: + sb.Append(prefix).AppendFormat("%s[] %s = %s.readFloatArray();\n", + elementType_->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); + break; + case TypeKind::TYPE_DOUBLE: + sb.Append(prefix).AppendFormat("%s[] %s = %s.readDoubleArray();\n", + elementType_->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); + break; + case TypeKind::TYPE_STRING: + sb.Append(prefix).AppendFormat("%s[] %s = %s.readStringArray();\n", + elementType_->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); + break; + case TypeKind::TYPE_SEQUENCEABLE: + sb.Append(prefix).AppendFormat("int size = %s.readInt();\n", parcelName.string()); + sb.Append(prefix).AppendFormat("%s %s = new %s[size];\n", + elementType_->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), + elementType_->EmitJavaType(TypeMode::NO_MODE).string()); + sb.Append(prefix).AppendFormat("for (int i = 0; i < size; ++i) {\n"); + elementType_->EmitJavaReadInnerVar(parcelName, "value", true, sb, prefix + g_tab); + sb.Append(prefix + g_tab).AppendFormat("%s[i] = value;\n", name.string()); + sb.Append(prefix).Append("}\n"); + break; + default: + break; + } +} + +void ASTArrayType::EmitJavaWriteArrayVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + switch (elementType_->GetTypeKind()) { + case TypeKind::TYPE_BOOLEAN: + sb.Append(prefix).AppendFormat("%s.writeBooleanArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_BYTE: + sb.Append(prefix).AppendFormat("%s.writeByteArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_SHORT: + sb.Append(prefix).AppendFormat("%s.writeShortArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_INT: + case TypeKind::TYPE_FILEDESCRIPTOR: + sb.Append(prefix).AppendFormat("%s.writeIntArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_LONG: + sb.Append(prefix).AppendFormat("%s.writeLongArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_FLOAT: + sb.Append(prefix).AppendFormat("%s.writeFloatArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_DOUBLE: + sb.Append(prefix).AppendFormat("%s.writeDoubleArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_STRING: + sb.Append(prefix).AppendFormat("%s.writeStringArray(%s);\n", parcelName.string(), name.string()); + break; + case TypeKind::TYPE_SEQUENCEABLE: + sb.Append(prefix).AppendFormat("%s.writeSequenceableArray(%s);\n", parcelName.string(), name.string()); + break; + default: + break; + } +} + +void ASTArrayType::EmitCMallocVar(const String& name, const String& lenName, bool isClient, const String& gotoLabel, + StringBuilder& sb, const String& prefix) const +{ + String varName = isClient ? String::Format("*%s", name.string()) : name; + String lenVarName = isClient ? String::Format("*%s", lenName.string()) : lenName; + + sb.Append(prefix).AppendFormat("%s = (%s*)OsalMemCalloc(sizeof(%s) * (%s));\n", varName.string(), + elementType_->EmitCType().string(), elementType_->EmitCType().string(), lenVarName.string()); + sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", varName.string()); + sb.Append(prefix + g_tab).AppendFormat("ec = HDF_ERR_MALLOC_FAIL;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix).AppendFormat("}\n"); +} + +void ASTArrayType::EmitCProxyReadStrElement(const String& parcelName, const String& name, const String& gotoLabel, + StringBuilder& sb, const String& prefix) const +{ + String cpName = String::Format("%sCp", name.string()); + elementType_->EmitCProxyReadVar(parcelName, cpName, true, gotoLabel, sb, prefix + g_tab); + sb.Append("\n"); + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix + g_tab).AppendFormat("(*%s)[i] = (char*)OsalMemCalloc(strlen(%s) + 1);\n", + name.string(), cpName.string()); + sb.Append(prefix + g_tab).AppendFormat("if ((*%s)[i] == NULL) {\n", name.string()); + sb.Append(prefix + g_tab + g_tab).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); + sb.Append(prefix + g_tab + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("}\n\n"); + sb.Append(prefix + g_tab).AppendFormat("if (strcpy_s((*%s)[i], (strlen(%s) + 1), %s) != HDF_SUCCESS) {\n", + name.string(), cpName.string(), cpName.string()); + sb.Append(prefix + g_tab + g_tab).AppendFormat("HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", + cpName.string()); + sb.Append(prefix + g_tab + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("}\n"); + } else { + sb.Append(prefix + g_tab).AppendFormat("(*%s)[i] = strdup(%sCp);\n", + name.string(), name.string()); + } +} + +void ASTArrayType::EmitCStubReadStrElement(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + String element = String::Format("%sCp", name.string()); + String newPrefix = prefix + g_tab + g_tab; + elementType_->EmitCStubReadVar(parcelName, element, sb, newPrefix); + sb.Append("\n"); + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(newPrefix).AppendFormat("%s[i] = (char*)OsalMemCalloc(strlen(%s) + 1);\n", + name.string(), element.string()); + sb.Append(newPrefix).AppendFormat("if (%s[i] == NULL) {\n", name.string()); + sb.Append(newPrefix + g_tab).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); + sb.Append(newPrefix + g_tab).AppendFormat("goto errors;\n"); + sb.Append(newPrefix).Append("}\n\n"); + + sb.Append(newPrefix).AppendFormat("if (strcpy_s((%s)[i], (strlen(%s) + 1), %s) != HDF_SUCCESS) {\n", + name.string(), element.string(), element.string()); + sb.Append(newPrefix + g_tab).AppendFormat("HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", + element.string()); + sb.Append(newPrefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(newPrefix + g_tab).Append("goto errors;\n"); + sb.Append(newPrefix).Append("}\n"); + } else { + sb.Append(newPrefix).AppendFormat("%s[i] = strdup(%sCp);\n", name.string(), name.string()); + } +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_array_type.h b/tools/hdi-gen/ast/ast_array_type.h index bd1c50f1d233ee2da1163ed596ca205fa5acd12d..7cc0ffe8136f7b8ae4a51b5db0376d05f5d2d782 100755 --- a/tools/hdi-gen/ast/ast_array_type.h +++ b/tools/hdi-gen/ast/ast_array_type.h @@ -37,12 +37,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -65,7 +62,34 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitMemoryRecycle(const String& name, bool isClient, bool ownership, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, StringBuilder& sb, + const String& prefix) const override; private: + void EmitJavaWriteArrayVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const; + + void EmitCMallocVar(const String& name, const String& lenName, bool isClient, const String& gotoLabel, + StringBuilder& sb, const String& prefix) const; + + void EmitCProxyReadStrElement(const String& parcelName, const String& name, const String& gotoLabel, + StringBuilder& sb, const String& prefix) const; + + void EmitCStubReadStrElement(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const; + + void EmitCStringElementUnMarshalling(const String& name, StringBuilder& sb, const String& newPrefix, + std::vector& freeObjStatements) const; + AutoPtr elementType_; }; } // namespace HDI diff --git a/tools/hdi-gen/ast/ast_boolean_type.cpp b/tools/hdi-gen/ast/ast_boolean_type.cpp index 924944852e216e8fd1789be6286791badbae7a48..956854bb72c517d446e673120012f1f9884ee3ce 100755 --- a/tools/hdi-gen/ast/ast_boolean_type.cpp +++ b/tools/hdi-gen/ast/ast_boolean_type.cpp @@ -62,27 +62,15 @@ String ASTBooleanType::EmitJavaType(TypeMode mode, bool isInnerType) const return isInnerType ? "Boolean" : "boolean"; } -void ASTBooleanType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTBooleanType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt8(%s, %s ? 1 : 0)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTBooleanType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt8(%s, %s ? 1 : 0)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -91,10 +79,10 @@ void ASTBooleanType::EmitCProxyReadVar(const String& parcelName, const String& n { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt8(%s, (int8_t *)%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -103,10 +91,10 @@ void ASTBooleanType::EmitCStubReadVar(const String& parcelName, const String& na { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt8(%s, (int8_t *)%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -114,9 +102,9 @@ void ASTBooleanType::EmitCppWriteVar(const String& parcelName, const String& nam const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteBool(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -135,9 +123,9 @@ void ASTBooleanType::EmitCppReadVar(const String& parcelName, const String& name void ASTBooleanType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt8(data, %s ? 1 : 0)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -145,10 +133,10 @@ void ASTBooleanType::EmitCUnMarshalling(const String& name, StringBuilder& sb, c std::vector& freeObjStatements) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt8(data, (int8_t *)&%s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - EmitFreeStatements(freeObjStatements, sb, prefix + TAB); - sb.Append(prefix + TAB).Append("goto errors;\n"); + EmitFreeStatements(freeObjStatements, sb, prefix + g_tab); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -156,9 +144,9 @@ void ASTBooleanType::EmitCppMarshalling(const String& parcelName, const String& const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteBool(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -173,5 +161,24 @@ void ASTBooleanType::EmitCppUnMarshalling(const String& parcelName, const String name.string(), parcelName.string()); } } + +void ASTBooleanType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s.writeBoolean(%s);\n", parcelName.string(), name.string()); +} + +void ASTBooleanType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s = %s.readBoolean();\n", name.string(), parcelName.string()); +} + +void ASTBooleanType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s %s = %s.readBoolean();\n", + EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_boolean_type.h b/tools/hdi-gen/ast/ast_boolean_type.h index 1b42378fba486c3f29f4e741778b9405c6fb07e2..ebc908022eb7796302af21ad05aa3e0f0164bb46 100755 --- a/tools/hdi-gen/ast/ast_boolean_type.h +++ b/tools/hdi-gen/ast/ast_boolean_type.h @@ -27,12 +27,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -55,8 +52,17 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, StringBuilder& sb, + const String& prefix) const override; }; } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTBOOLEANTYPE_H +#endif // OHOS_HDI_ASTBOOLEANTYPE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_byte_type.cpp b/tools/hdi-gen/ast/ast_byte_type.cpp index a5e59a65aa028928745454e80d27914de2ec17f5..fb114c3bca799da8e96733c0de40bc563a5ceedd 100755 --- a/tools/hdi-gen/ast/ast_byte_type.cpp +++ b/tools/hdi-gen/ast/ast_byte_type.cpp @@ -62,27 +62,15 @@ String ASTByteType::EmitJavaType(TypeMode mode, bool isInnerType) const return isInnerType ? "Byte" : "byte"; } -void ASTByteType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTByteType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt8(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTByteType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt8(%s, %s)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -90,10 +78,10 @@ void ASTByteType::EmitCProxyReadVar(const String& parcelName, const String& name const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt8(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -101,10 +89,10 @@ void ASTByteType::EmitCStubReadVar(const String& parcelName, const String& name, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt8(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -112,9 +100,9 @@ void ASTByteType::EmitCppWriteVar(const String& parcelName, const String& name, const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteInt8(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -133,9 +121,9 @@ void ASTByteType::EmitCppReadVar(const String& parcelName, const String& name, S void ASTByteType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt8(data, %s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -143,10 +131,10 @@ void ASTByteType::EmitCUnMarshalling(const String& name, StringBuilder& sb, cons std::vector& freeObjStatements) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt8(data, &%s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - EmitFreeStatements(freeObjStatements, sb, prefix + TAB); - sb.Append(prefix + TAB).Append("goto errors;\n"); + EmitFreeStatements(freeObjStatements, sb, prefix + g_tab); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -154,9 +142,9 @@ void ASTByteType::EmitCppMarshalling(const String& parcelName, const String& nam const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteInt8(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -170,5 +158,24 @@ void ASTByteType::EmitCppUnMarshalling(const String& parcelName, const String& n sb.Append(prefix).AppendFormat("%s = %s.ReadInt8();\n", name.string(), parcelName.string()); } } + +void ASTByteType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s.writeByte(%s);\n", parcelName.string(), name.string()); +} + +void ASTByteType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s = %s.readByte();\n", name.string(), parcelName.string()); +} + +void ASTByteType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s %s = %s.readByte();\n", + EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_byte_type.h b/tools/hdi-gen/ast/ast_byte_type.h index 7b93a6b46c0c8aeaaa51de913a9557521ecce521..d5b2cda3e25d0537d53e5e9ee0c7915dabf2a0c5 100755 --- a/tools/hdi-gen/ast/ast_byte_type.h +++ b/tools/hdi-gen/ast/ast_byte_type.h @@ -27,12 +27,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -55,8 +52,17 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, StringBuilder& sb, + const String& prefix) const override; }; } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTBYTETYPE_H +#endif // OHOS_HDI_ASTBYTETYPE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_double_type.cpp b/tools/hdi-gen/ast/ast_double_type.cpp index 2812b655a2993856d9615579a068ac1438ca951e..bf6820a4f17e841575dcee328ad80d70db30a47a 100755 --- a/tools/hdi-gen/ast/ast_double_type.cpp +++ b/tools/hdi-gen/ast/ast_double_type.cpp @@ -62,27 +62,15 @@ String ASTDoubleType::EmitJavaType(TypeMode mode, bool isInnerType) const return isInnerType ? "Double" : "double"; } -void ASTDoubleType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTDoubleType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteDouble(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTDoubleType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteDouble(%s, %s)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -90,10 +78,10 @@ void ASTDoubleType::EmitCProxyReadVar(const String& parcelName, const String& na const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadDouble(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -101,10 +89,10 @@ void ASTDoubleType::EmitCStubReadVar(const String& parcelName, const String& nam const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadDouble(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -112,9 +100,9 @@ void ASTDoubleType::EmitCppWriteVar(const String& parcelName, const String& name const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteDouble(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -132,9 +120,9 @@ void ASTDoubleType::EmitCppReadVar(const String& parcelName, const String& name, void ASTDoubleType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteDouble(data, %s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -142,10 +130,10 @@ void ASTDoubleType::EmitCUnMarshalling(const String& name, StringBuilder& sb, co std::vector& freeObjStatements) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadDouble(data, &%s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - EmitFreeStatements(freeObjStatements, sb, prefix + TAB); - sb.Append(prefix + TAB).Append("goto errors;\n"); + EmitFreeStatements(freeObjStatements, sb, prefix + g_tab); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -153,9 +141,9 @@ void ASTDoubleType::EmitCppMarshalling(const String& parcelName, const String& n const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteDouble(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -169,5 +157,24 @@ void ASTDoubleType::EmitCppUnMarshalling(const String& parcelName, const String& sb.Append(prefix).AppendFormat("%s = %s.ReadDouble();\n", name.string(), parcelName.string()); } } + +void ASTDoubleType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s.writeDouble(%s);\n", parcelName.string(), name.string()); +} + +void ASTDoubleType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s = %s.readDouble();\n", name.string(), parcelName.string()); +} + +void ASTDoubleType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s %s = %s.readDouble();\n", + EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_double_type.h b/tools/hdi-gen/ast/ast_double_type.h index 266082c17ee568dee7c1ef6f1df29337f48b5231..545482d8d2d1d8b98160dd02d1a687708caf47f3 100755 --- a/tools/hdi-gen/ast/ast_double_type.h +++ b/tools/hdi-gen/ast/ast_double_type.h @@ -27,12 +27,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - virtual void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -55,6 +52,15 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, StringBuilder& sb, + const String& prefix) const override; }; } // namespace HDI } // namespace OHOS diff --git a/tools/hdi-gen/ast/ast_enum_type.cpp b/tools/hdi-gen/ast/ast_enum_type.cpp index 8294370781520d5ddda273dac06b9dfb998acdcb..bca78d25585240b2dc1a85484fd283c1de2563d9 100755 --- a/tools/hdi-gen/ast/ast_enum_type.cpp +++ b/tools/hdi-gen/ast/ast_enum_type.cpp @@ -161,27 +161,15 @@ String ASTEnumType::EmitJavaTypeDecl() const return sb.ToString(); } -void ASTEnumType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTEnumType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint32(%s, (uint32_t)%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTEnumType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint32(%s, (uint32_t)%s)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -190,10 +178,10 @@ void ASTEnumType::EmitCProxyReadVar(const String& parcelName, const String& name { sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint32(%s, (uint32_t*)%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -202,10 +190,10 @@ void ASTEnumType::EmitCStubReadVar(const String& parcelName, const String& name, { sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint32(%s, (uint32_t*)%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -214,9 +202,9 @@ void ASTEnumType::EmitCppWriteVar(const String& parcelName, const String& name, { sb.Append(prefix).AppendFormat("if (!%s.WriteUint32((uint32_t)%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -235,9 +223,9 @@ void ASTEnumType::EmitCppReadVar(const String& parcelName, const String& name, S void ASTEnumType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt32(data, (int32_t)%s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -245,9 +233,9 @@ void ASTEnumType::EmitCUnMarshalling(const String& name, StringBuilder& sb, cons std::vector& freeObjStatements) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt32(data, (int32_t*)&%s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -256,9 +244,9 @@ void ASTEnumType::EmitCppMarshalling(const String& parcelName, const String& nam { sb.Append(prefix).AppendFormat("if (!%s.WriteUint32((uint32_t)%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } diff --git a/tools/hdi-gen/ast/ast_enum_type.h b/tools/hdi-gen/ast/ast_enum_type.h index 9d1c3dd7581c12b0e2f695cde93dea4e8c841f7e..6f5ebc6dab4af3a3fe17ecb31881dc52a9a18d4f 100755 --- a/tools/hdi-gen/ast/ast_enum_type.h +++ b/tools/hdi-gen/ast/ast_enum_type.h @@ -146,12 +146,9 @@ public: String EmitJavaTypeDecl() const; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; diff --git a/tools/hdi-gen/ast/ast_fd_type.cpp b/tools/hdi-gen/ast/ast_fd_type.cpp index 7e36c9d110aaa3337d23743db01aea3980b7f448..deb7b3e58c942cd74aafbee4b4af4f65c01b45ca 100755 --- a/tools/hdi-gen/ast/ast_fd_type.cpp +++ b/tools/hdi-gen/ast/ast_fd_type.cpp @@ -62,27 +62,15 @@ String ASTFdType::EmitJavaType(TypeMode mode, bool isInnerType) const return isInnerType ? "Integer" : "int"; } -void ASTFdType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTFdType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteFileDescriptor(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTFdType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteFileDescriptor(%s, %s)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -98,10 +86,10 @@ void ASTFdType::EmitCProxyReadVar(const String& parcelName, const String& name, name.string(), parcelName.string()); sb.Append(prefix).AppendFormat("if (*%s < 0) {\n", name.string()); } - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -111,10 +99,10 @@ void ASTFdType::EmitCStubReadVar(const String& parcelName, const String& name, S sb.Append(prefix).AppendFormat("%s = HdfSbufReadFileDescriptor(%s);\n", name.string(), parcelName.string()); sb.Append(prefix).AppendFormat("if (%s < 0) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -122,9 +110,9 @@ void ASTFdType::EmitCppWriteVar(const String& parcelName, const String& name, St const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteFileDescriptor(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -142,9 +130,9 @@ void ASTFdType::EmitCppReadVar(const String& parcelName, const String& name, Str void ASTFdType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteFileDescriptor(data, %s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -153,9 +141,9 @@ void ASTFdType::EmitCUnMarshalling(const String& name, StringBuilder& sb, const { sb.Append(prefix).AppendFormat("%s = HdfSbufReadFileDescriptor(data);\n", name.string()); sb.Append(prefix).AppendFormat("if (%s < 0) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -163,9 +151,9 @@ void ASTFdType::EmitCppMarshalling(const String& parcelName, const String& name, const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteFileDescriptor(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -179,5 +167,24 @@ void ASTFdType::EmitCppUnMarshalling(const String& parcelName, const String& nam sb.Append(prefix).AppendFormat("%s = %s.ReadFileDescriptor();\n", name.string(), parcelName.string()); } } + +void ASTFdType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s.writeInt(%s);\n", parcelName.string(), name.string()); +} + +void ASTFdType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s = %s.readInt();\n", name.string(), parcelName.string()); +} + +void ASTFdType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s %s = %s.readInt();\n", + EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_fd_type.h b/tools/hdi-gen/ast/ast_fd_type.h index c73d8911a8a5a39376bbc545629e4f55fa3a4d0b..ca6eed6488c54a54aeeeea33fe68c7a51f716d7d 100755 --- a/tools/hdi-gen/ast/ast_fd_type.h +++ b/tools/hdi-gen/ast/ast_fd_type.h @@ -27,12 +27,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -55,8 +52,17 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, StringBuilder& sb, + const String& prefix) const override; }; } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_FDTYPE_H +#endif // OHOS_HDI_FDTYPE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_float_type.cpp b/tools/hdi-gen/ast/ast_float_type.cpp index 701c794a9d29bbba9d83569e93d88e58ae1dbd39..b4dd45442d90c36b38ddd874d6467b0d18ed0fcd 100755 --- a/tools/hdi-gen/ast/ast_float_type.cpp +++ b/tools/hdi-gen/ast/ast_float_type.cpp @@ -62,27 +62,15 @@ String ASTFloatType::EmitJavaType(TypeMode mode, bool isInnerType) const return isInnerType ? "Float" : "float"; } -void ASTFloatType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTFloatType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteFloat(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTFloatType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteFloat(%s, %s)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -90,10 +78,10 @@ void ASTFloatType::EmitCProxyReadVar(const String& parcelName, const String& nam const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadFloat(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -101,10 +89,10 @@ void ASTFloatType::EmitCStubReadVar(const String& parcelName, const String& name const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadFloat(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -112,9 +100,9 @@ void ASTFloatType::EmitCppWriteVar(const String& parcelName, const String& name, const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteFloat(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -132,9 +120,9 @@ void ASTFloatType::EmitCppReadVar(const String& parcelName, const String& name, void ASTFloatType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteFloat(data, %s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -142,10 +130,10 @@ void ASTFloatType::EmitCUnMarshalling(const String& name, StringBuilder& sb, con std::vector& freeObjStatements) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadFloat(data, &%s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - EmitFreeStatements(freeObjStatements, sb, prefix + TAB); - sb.Append(prefix + TAB).Append("goto errors;\n"); + EmitFreeStatements(freeObjStatements, sb, prefix + g_tab); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -153,9 +141,9 @@ void ASTFloatType::EmitCppMarshalling(const String& parcelName, const String& na const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteFloat(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -169,5 +157,24 @@ void ASTFloatType::EmitCppUnMarshalling(const String& parcelName, const String& sb.Append(prefix).AppendFormat("%s = %s.ReadFloat();\n", name.string(), parcelName.string()); } } + +void ASTFloatType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s.writeFloat(%s);\n", parcelName.string(), name.string()); +} + +void ASTFloatType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s = %s.readFloat();\n", name.string(), parcelName.string()); +} + +void ASTFloatType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s %s = %s.readFloat();\n", + EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_float_type.h b/tools/hdi-gen/ast/ast_float_type.h index f48e5a92ebc61d65d099b9d2f74890962814c769..cb0b07f5735b52a02d996bedcd74f2d58c7fd4da 100755 --- a/tools/hdi-gen/ast/ast_float_type.h +++ b/tools/hdi-gen/ast/ast_float_type.h @@ -27,12 +27,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -55,8 +52,17 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, StringBuilder& sb, + const String& prefix) const override; }; } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTFLOATTYPE_H +#endif // OHOS_HDI_ASTFLOATTYPE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_integer_type.cpp b/tools/hdi-gen/ast/ast_integer_type.cpp index 6bf7e14a5b2820bffd73b3f238384234f825a0a6..62d1975133242b096504e5c13f9b42b25139601c 100755 --- a/tools/hdi-gen/ast/ast_integer_type.cpp +++ b/tools/hdi-gen/ast/ast_integer_type.cpp @@ -62,27 +62,15 @@ String ASTIntegerType::EmitJavaType(TypeMode mode, bool isInnerType) const return isInnerType ? "Integer" : "int"; } -void ASTIntegerType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTIntegerType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt32(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTIntegerType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt32(%s, %s)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -90,10 +78,10 @@ void ASTIntegerType::EmitCProxyReadVar(const String& parcelName, const String& n const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt32(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -101,10 +89,10 @@ void ASTIntegerType::EmitCStubReadVar(const String& parcelName, const String& na const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt32(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -112,9 +100,9 @@ void ASTIntegerType::EmitCppWriteVar(const String& parcelName, const String& nam const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteInt32(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -132,9 +120,9 @@ void ASTIntegerType::EmitCppReadVar(const String& parcelName, const String& name void ASTIntegerType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt32(data, %s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -142,10 +130,10 @@ void ASTIntegerType::EmitCUnMarshalling(const String& name, StringBuilder& sb, c std::vector& freeObjStatements) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt32(data, &%s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - EmitFreeStatements(freeObjStatements, sb, prefix + TAB); - sb.Append(prefix + TAB).Append("goto errors;\n"); + EmitFreeStatements(freeObjStatements, sb, prefix + g_tab); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -153,9 +141,9 @@ void ASTIntegerType::EmitCppMarshalling(const String& parcelName, const String& const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteInt32(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -169,5 +157,24 @@ void ASTIntegerType::EmitCppUnMarshalling(const String& parcelName, const String sb.Append(prefix).AppendFormat("%s = %s.ReadInt32();\n", name.string(), parcelName.string()); } } + +void ASTIntegerType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s.writeInt(%s);\n", parcelName.string(), name.string()); +} + +void ASTIntegerType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s = %s.readInt();\n", name.string(), parcelName.string()); +} + +void ASTIntegerType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s %s = %s.readInt();\n", + EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_integer_type.h b/tools/hdi-gen/ast/ast_integer_type.h index fb7724a0d234a7e1f81d4dbc3680e401b2dc55a3..5ed7723bfca0468ddd9919d3419630ea66b3ac37 100755 --- a/tools/hdi-gen/ast/ast_integer_type.h +++ b/tools/hdi-gen/ast/ast_integer_type.h @@ -27,12 +27,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -55,8 +52,17 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, StringBuilder& sb, + const String& prefix) const override; }; } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTINTEGERTYPE_H +#endif // OHOS_HDI_ASTINTEGERTYPE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_interface_type.cpp b/tools/hdi-gen/ast/ast_interface_type.cpp index 1a7c64f6ebe0cf3e14684fbfc397ca57bd83d154..85b023ed9a6615fdb7a750129843c8e31d6780a1 100755 --- a/tools/hdi-gen/ast/ast_interface_type.cpp +++ b/tools/hdi-gen/ast/ast_interface_type.cpp @@ -129,14 +129,15 @@ String ASTInterfaceType::EmitJavaType(TypeMode mode, bool isInnerType) const return name_; } -void ASTInterfaceType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTInterfaceType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { - sb.Append(prefix).AppendFormat("if (HdfSBufWriteRemoteService(data, %s->remote) != 0) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix).AppendFormat("if (HdfSBufWriteRemoteService(%s, %s->remote) != 0) {\n", + parcelName.string(), name.string()); + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -146,15 +147,15 @@ void ASTInterfaceType::EmitCStubReadVar(const String& parcelName, const String& String remoteName = String::Format("%sRemote", name.string()); String miName = name_.StartsWith("I") ? name_.Substring(1) : name_; - sb.Append(prefix).AppendFormat("struct HdfRemoteService *%s = HdfSBufReadRemoteService(data);\n", - remoteName.string()); + sb.Append(prefix).AppendFormat("struct HdfRemoteService *%s = HdfSBufReadRemoteService(%s);\n", + remoteName.string(), parcelName.string()); sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", remoteName.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", remoteName.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); - sb.Append(prefix).AppendFormat("%s = %sProxyObtain(%s);\n", + sb.Append(prefix).AppendFormat("%s = %sGet(%s);\n", name.string(), miName.string(), remoteName.string()); } @@ -163,9 +164,9 @@ void ASTInterfaceType::EmitCppWriteVar(const String& parcelName, const String& n { sb.Append(prefix).AppendFormat("if (!%s.WriteRemoteObject(%s->AsObject())) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -180,5 +181,28 @@ void ASTInterfaceType::EmitCppReadVar(const String& parcelName, const String& na name.string(), name_.string(), parcelName.string()); } } + +void ASTInterfaceType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s.writeRemoteObject(%s.asObject());\n", parcelName.string(), + name.string()); +} + +void ASTInterfaceType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + String stubName = name_.StartsWith("I") ? (name_.Substring(1) + "Stub") : (name_ + "Stub"); + sb.Append(prefix).AppendFormat("%s = %s.asInterface(%s.readRemoteObject());\n", + name.string(), stubName.string(), parcelName.string()); +} + +void ASTInterfaceType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + String stubName = name_.StartsWith("I") ? (name_.Substring(1) + "Stub") : (name_ + "Stub"); + sb.Append(prefix).AppendFormat("%s %s = %s.asInterface(%s.readRemoteObject());\n", + EmitJavaType(TypeMode::NO_MODE).string(), name.string(), stubName.string(), parcelName.string()); +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_interface_type.h b/tools/hdi-gen/ast/ast_interface_type.h index 9c38d69a636a5902a7862a50aa23818c2f1faaaa..7d3f11545a37da4037c1b9bbcee7e3d2f1edbe3d 100755 --- a/tools/hdi-gen/ast/ast_interface_type.h +++ b/tools/hdi-gen/ast/ast_interface_type.h @@ -95,7 +95,7 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; void EmitCStubReadVar(const String& parcelName, const String& name, StringBuilder& sb, @@ -106,6 +106,15 @@ public: void EmitCppReadVar(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool initVariable, unsigned int innerLevel = 0) const override; + + void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, StringBuilder& sb, + const String& prefix) const override; private: String license_; bool isOneWay_ = false; @@ -117,4 +126,4 @@ private: } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTINTERFACETYPE_H +#endif // OHOS_HDI_ASTINTERFACETYPE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_list_type.cpp b/tools/hdi-gen/ast/ast_list_type.cpp index 8b62d1509d460eb08979fac7889fe733bfb82cbf..e8ce1aeb9028ef6932b55a3e3f84e732813feb2d 100755 --- a/tools/hdi-gen/ast/ast_list_type.cpp +++ b/tools/hdi-gen/ast/ast_list_type.cpp @@ -7,6 +7,7 @@ */ #include "ast/ast_list_type.h" +#include "util/options.h" namespace OHOS { namespace HDI { @@ -82,110 +83,75 @@ String ASTListType::EmitJavaType(TypeMode mode, bool isInnerType) const return String::Format("List<%s>", elementType_->EmitJavaType(mode, true).string()); } -void ASTListType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTListType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { String lenName = String::Format("%sLen", name.string()); sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint32(%s, %s)) {\n", parcelName.string(), lenName.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); - sb.Append(prefix).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); - String elementName; - String elementReadName; - - if (elementType_->GetTypeKind() == TypeKind::TYPE_STRUCT - || elementType_->GetTypeKind() == TypeKind::TYPE_UNION) { - elementName = String::Format("%s[i]", name.string()); - elementReadName = "&" + elementName; + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix).AppendFormat("for (i = 0; i < %s; i++) {\n", lenName.string()); } else { - elementName = String::Format("%s[i]", name.string()); - elementReadName = elementName; + sb.Append(prefix).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); } - elementType_->EmitCProxyWriteVar(parcelName, elementReadName, gotoLabel, sb, prefix + TAB); - sb.Append(prefix).Append("}\n"); -} - -void ASTListType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint32(%s, %sLen)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); - sb.Append(prefix).Append("}\n"); - sb.Append("\n"); - sb.Append(prefix).AppendFormat("for (uint32_t i = 0; i < %sLen; i++) {\n", name.string(), name.string()); - - String element; + String elementName = ""; if (elementType_->GetTypeKind() == TypeKind::TYPE_STRUCT || elementType_->GetTypeKind() == TypeKind::TYPE_UNION) { - element = String::Format("&%s[i]", name.string()); + elementName = String::Format("&%s[i]", name.string()); } else { - element = String::Format("%s[i]", name.string()); + elementName = String::Format("%s[i]", name.string()); } - elementType_->EmitCStubWriteVar(parcelName, element, sb, prefix + TAB); + + elementType_->EmitCWriteVar(parcelName, elementName, gotoLabel, sb, prefix + g_tab); sb.Append(prefix).Append("}\n"); } void ASTListType::EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { -String lenName = String::Format("%sLen", name.string()); + String lenName = String::Format("%sLen", name.string()); sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint32(%s, %s)) {\n", parcelName.string(), lenName.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s size failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix).Append("}\n\n"); - if (elementType_->GetTypeKind() == TypeKind::TYPE_STRING) { - sb.Append(prefix).AppendFormat("*%s = (%s*)OsalMemAlloc(sizeof(%s) * (*%s));\n", - name.string(), elementType_->EmitCType().string(), elementType_->EmitCType().string(), - lenName.string()); - sb.Append(prefix).AppendFormat("if (*%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat("ec = HDF_ERR_MALLOC_FAIL;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).AppendFormat("}\n"); + EmitCMallocVar(name, lenName, true, gotoLabel, sb, prefix); + sb.Append("\n"); + + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix).AppendFormat("for (i = 0; i < *%s; i++) {\n", lenName.string()); } else { - sb.Append(prefix).AppendFormat("*%s = (%s*)OsalMemCalloc(sizeof(%s) * (*%s));\n", - name.string(), elementType_->EmitCType().string(), elementType_->EmitCType().string(), - lenName.string()); - sb.Append(prefix).AppendFormat("if (*%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat("ec = HDF_ERR_MALLOC_FAIL;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).AppendFormat("}\n"); + sb.Append(prefix).AppendFormat("for (uint32_t i = 0; i < *%s; i++) {\n", lenName.string()); } - sb.Append(prefix).AppendFormat("for (uint32_t i = 0; i < *%s; i++) {\n", lenName.string()); + if (elementType_->GetTypeKind() == TypeKind::TYPE_STRING) { - String cpName = String::Format("%sCp", name.string()); - elementType_->EmitCProxyReadVar(parcelName, cpName, true, gotoLabel, sb, prefix + TAB); - sb.Append(prefix).Append(TAB).AppendFormat("(*%s)[i] = strdup(%sCp);\n", - name.string(), name.string()); + EmitCProxyReadStrElement(parcelName, name, gotoLabel, sb, prefix); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_STRUCT) { String element = String::Format("&(*%s)[i]", name.string()); - elementType_->EmitCProxyReadVar(parcelName, element, true, gotoLabel, sb, prefix + TAB); + elementType_->EmitCProxyReadVar(parcelName, element, true, gotoLabel, sb, prefix + g_tab); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_UNION) { String element = String::Format("&(*%s)[i]", name.string()); String elementCp = String::Format("%sElementCp", name.string()); - elementType_->EmitCProxyReadVar(parcelName, elementCp, true, gotoLabel, sb, prefix + TAB); - sb.Append(prefix + TAB).AppendFormat("(void)memcpy_s(%s, sizeof(%s), %s, sizeof(%s));\n", + elementType_->EmitCProxyReadVar(parcelName, elementCp, true, gotoLabel, sb, prefix + g_tab); + sb.Append(prefix + g_tab).AppendFormat("(void)memcpy_s(%s, sizeof(%s), %s, sizeof(%s));\n", element.string(), elementType_->EmitCType().string(), elementCp.string(), elementType_->EmitCType().string()); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_FILEDESCRIPTOR) { String element = String::Format("(*%s)[i]", name.string()); - elementType_->EmitCProxyReadVar(parcelName, element, true, gotoLabel, sb, prefix + TAB); + elementType_->EmitCProxyReadVar(parcelName, element, true, gotoLabel, sb, prefix + g_tab); } else { String element = String::Format("&(*%s)[i]", name.string()); - elementType_->EmitCProxyReadVar(parcelName, element, true, gotoLabel, sb, prefix + TAB); + elementType_->EmitCProxyReadVar(parcelName, element, true, gotoLabel, sb, prefix + g_tab); } sb.Append(prefix).Append("}\n"); } @@ -194,56 +160,45 @@ void ASTListType::EmitCStubReadVar(const String& parcelName, const String& name, const String& prefix) const { String lenName = String::Format("%sLen", name.string()); + sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint32(%s, &%s)) {\n", parcelName.string(), lenName.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s size failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); - sb.Append(prefix).Append("}\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); + sb.Append(prefix).Append("}\n\n"); sb.Append(prefix).AppendFormat("if (%s > 0) {\n", lenName.string()); - if (elementType_->GetTypeKind() == TypeKind::TYPE_STRING) { - sb.Append(prefix + TAB).AppendFormat("%s = (%s*)OsalMemAlloc(sizeof(%s) * (%s));\n", name.string(), - elementType_->EmitCType().string(), elementType_->EmitCType().string(), lenName.string()); - sb.Append(prefix + TAB).AppendFormat("if (%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB + TAB).AppendFormat("ec = HDF_ERR_MALLOC_FAIL;\n"); - sb.Append(prefix + TAB + TAB).AppendFormat("goto errors;\n"); - sb.Append(prefix + TAB).AppendFormat("}\n"); + EmitCMallocVar(name, lenName, false, "errors", sb, prefix + g_tab); + sb.Append("\n"); + + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix + g_tab).AppendFormat("for (i = 0; i < %s; i++) {\n", lenName.string()); } else { - sb.Append(prefix + TAB).AppendFormat("%s = (%s*)OsalMemCalloc(sizeof(%s) * (%s));\n", - name.string(), elementType_->EmitCType().string(), elementType_->EmitCType().string(), - lenName.string()); - sb.Append(prefix + TAB).AppendFormat("if (%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB + TAB).AppendFormat("ec = HDF_ERR_MALLOC_FAIL;\n"); - sb.Append(prefix + TAB + TAB).AppendFormat("goto errors;\n"); - sb.Append(prefix + TAB).AppendFormat("}\n"); + sb.Append(prefix + g_tab).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); } - sb.Append(prefix + TAB).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); - if (elementType_->GetTypeKind() == TypeKind::TYPE_STRING) { - String element = String::Format("%sCp", name.string()); - elementType_->EmitCStubReadVar(parcelName, element, sb, prefix + TAB + TAB); - sb.Append(prefix + TAB + TAB).AppendFormat("%s[i] = strdup(%sCp);\n", name.string(), name.string()); + EmitCStubReadStrElement(parcelName, name, sb, prefix); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_STRUCT) { String element = String::Format("&%s[i]", name.string()); - elementType_->EmitCStubReadVar(parcelName, element, sb, prefix + TAB + TAB); + elementType_->EmitCStubReadVar(parcelName, element, sb, prefix + g_tab + g_tab); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_UNION) { String element = String::Format("%s[i]", name.string()); String elementCp = String::Format("%sElementCp", name.string()); - elementType_->EmitCStubReadVar(parcelName, elementCp, sb, prefix + TAB + TAB); - sb.Append(prefix + TAB + TAB).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", + elementType_->EmitCStubReadVar(parcelName, elementCp, sb, prefix + g_tab + g_tab); + sb.Append(prefix + g_tab + g_tab).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", element.string(), elementType_->EmitCType().string(), elementCp.string(), elementType_->EmitCType().string()); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_FILEDESCRIPTOR) { String element = String::Format("%s[i]", name.string()); - elementType_->EmitCStubReadVar(parcelName, element, sb, prefix + TAB + TAB); + elementType_->EmitCStubReadVar(parcelName, element, sb, prefix + g_tab + g_tab); } else { String element = String::Format("&%s[i]", name.string()); - elementType_->EmitCStubReadVar(parcelName, element, sb, prefix + TAB + TAB); + elementType_->EmitCStubReadVar(parcelName, element, sb, prefix + g_tab + g_tab); } - sb.Append(prefix + TAB).Append("}\n"); + sb.Append(prefix + g_tab).Append("}\n"); sb.Append(prefix).Append("}\n"); } @@ -251,14 +206,14 @@ void ASTListType::EmitCppWriteVar(const String& parcelName, const String& name, const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteUint32(%s.size())) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s.size() failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); String elementName = String::Format("it%d", innerLevel++); sb.Append(prefix).AppendFormat("for (auto %s : %s) {\n", elementName.string(), name.string()); - elementType_->EmitCppWriteVar(parcelName, elementName, sb, prefix + TAB, innerLevel); + elementType_->EmitCppWriteVar(parcelName, elementName, sb, prefix + g_tab, innerLevel); sb.Append(prefix).Append("}\n"); } @@ -273,22 +228,27 @@ void ASTListType::EmitCppReadVar(const String& parcelName, const String& name, S innerLevel, innerLevel, name.string(), innerLevel); String valueName = String::Format("value%d", innerLevel++); - elementType_->EmitCppReadVar(parcelName, valueName, sb, prefix + TAB, true, innerLevel); - sb.Append(prefix + TAB).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); + elementType_->EmitCppReadVar(parcelName, valueName, sb, prefix + g_tab, true, innerLevel); + sb.Append(prefix + g_tab).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); sb.Append(prefix).Append("}\n"); } void ASTListType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint32(data, %sLen)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %sLen failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); - sb.Append(prefix).AppendFormat("for (uint32_t i = 0; i < %sLen; i++) {\n", name.string()); + + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix).AppendFormat("for (i = 0; i < %sLen; i++) {\n", name.string()); + } else { + sb.Append(prefix).AppendFormat("for (uint32_t i = 0; i < %sLen; i++) {\n", name.string()); + } String elementName = String::Format("(%s)[i]", name.string()); - elementType_->EmitCMarshalling(elementName, sb, prefix + TAB); + elementType_->EmitCMarshalling(elementName, sb, prefix + g_tab); sb.Append(prefix).Append("}\n"); } @@ -297,58 +257,84 @@ void ASTListType::EmitCUnMarshalling(const String& name, StringBuilder& sb, cons { String lenName = String::Format("%sLen", name.string()); sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint32(data, &%s)) {\n", lenName.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", lenName.string()); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); sb.Append(prefix).AppendFormat("if (%s > 0) {\n", lenName.string()); - String newPrefix = prefix + TAB; + String newPrefix = prefix + g_tab; sb.Append(newPrefix).AppendFormat("%s = (%s*)OsalMemCalloc(sizeof(%s) * %s);\n", name.string(), elementType_->EmitCType().string(), elementType_->EmitCType().string(), lenName.string()); sb.Append(newPrefix).AppendFormat("if (%s == NULL) {\n", name.string()); - sb.Append(newPrefix + TAB).AppendFormat("goto errors;\n"); + sb.Append(newPrefix + g_tab).AppendFormat("goto errors;\n"); sb.Append(newPrefix).Append("}\n"); freeObjStatements.push_back(String::Format("OsalMemFree(%s);\n", name.string())); - sb.Append(newPrefix).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); + + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(newPrefix).AppendFormat("for (i = 0; i < %s; i++) {\n", lenName.string()); + } else { + sb.Append(newPrefix).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); + } + if (elementType_->GetTypeKind() == TypeKind::TYPE_STRING) { - String element = String::Format("%sElement", name.string()); - elementType_->EmitCUnMarshalling(element, sb, newPrefix + TAB, freeObjStatements); - sb.Append(newPrefix).Append(TAB).AppendFormat("%s[i] = strdup(%s);\n", - name.string(), element.string()); + EmitCStringElementUnMarshalling(name, sb, newPrefix, freeObjStatements); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_STRUCT) { String element = String::Format("&%s[i]", name.string()); - elementType_->EmitCUnMarshalling(element, sb, newPrefix + TAB, freeObjStatements); + elementType_->EmitCUnMarshalling(element, sb, newPrefix + g_tab, freeObjStatements); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_UNION) { String element = String::Format("%s[i]", name.string()); String elementCp = String::Format("%sElementCp", name.string()); - elementType_->EmitCUnMarshalling(elementCp, sb, newPrefix + TAB, freeObjStatements); - sb.Append(newPrefix + TAB).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", + elementType_->EmitCUnMarshalling(elementCp, sb, newPrefix + g_tab, freeObjStatements); + sb.Append(newPrefix + g_tab).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", element.string(), elementType_->EmitCType().string(), elementCp.string(), elementType_->EmitCType().string()); } else { String element = String::Format("%s[i]", name.string()); - elementType_->EmitCUnMarshalling(element, sb, newPrefix + TAB, freeObjStatements); + elementType_->EmitCUnMarshalling(element, sb, newPrefix + g_tab, freeObjStatements); } sb.Append(newPrefix).Append("}\n"); sb.Append(prefix).Append("}\n"); freeObjStatements.pop_back(); } +void ASTListType::EmitCStringElementUnMarshalling(const String& name, StringBuilder& sb, const String& newPrefix, + std::vector& freeObjStatements) const +{ + String element = String::Format("%sElement", name.string()); + elementType_->EmitCUnMarshalling(element, sb, newPrefix + g_tab, freeObjStatements); + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(newPrefix).AppendFormat("%s[i] = (char*)OsalMemCalloc(strlen(%s) + 1);\n", + name.string(), element.string()); + sb.Append(newPrefix).AppendFormat("if (%s[i] == NULL) {\n", name.string()); + sb.Append(newPrefix + g_tab).AppendFormat("goto errors;\n"); + sb.Append(newPrefix).Append("}\n\n"); + sb.Append(newPrefix).AppendFormat("if (strcpy_s((%s)[i], (strlen(%s) + 1), %s) != HDF_SUCCESS) {\n", + name.string(), element.string(), element.string()); + sb.Append(newPrefix + g_tab).AppendFormat("HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", + element.string()); + sb.Append(newPrefix + g_tab).Append("goto errors;\n"); + sb.Append(newPrefix).Append("}\n"); + } else { + sb.Append(newPrefix).Append(g_tab).AppendFormat("%s[i] = strdup(%s);\n", + name.string(), element.string()); + } +} + void ASTListType::EmitCppMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteUint32(%s.size())) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s.size failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); String elementName = String::Format("it%d", innerLevel++); sb.Append(prefix).AppendFormat("for (auto %s : %s) {\n", elementName.string(), name.string()); - elementType_->EmitCppMarshalling(parcelName, elementName, sb, prefix + TAB, innerLevel); + elementType_->EmitCppMarshalling(parcelName, elementName, sb, prefix + g_tab, innerLevel); sb.Append(prefix).Append("}\n"); } @@ -367,24 +353,152 @@ void ASTListType::EmitCppUnMarshalling(const String& parcelName, const String& n String valueName = String::Format("value%d", innerLevel++); if (elementType_->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append(prefix + TAB).AppendFormat("%s %s;\n", + sb.Append(prefix + g_tab).AppendFormat("%s %s;\n", elementType_->EmitCppType().string(), valueName.string()); - elementType_->EmitCppUnMarshalling(parcelName, valueName, sb, prefix + TAB, true, innerLevel); - sb.Append(prefix + TAB).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); + elementType_->EmitCppUnMarshalling(parcelName, valueName, sb, prefix + g_tab, true, innerLevel); + sb.Append(prefix + g_tab).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); } else if (elementType_->GetTypeKind() == TypeKind::TYPE_UNION) { - sb.Append(prefix + TAB).AppendFormat("%s %s;\n", + sb.Append(prefix + g_tab).AppendFormat("%s %s;\n", elementType_->EmitCppType().string(), valueName.string()); String cpName = String::Format("%sCp", valueName.string()); - elementType_->EmitCppUnMarshalling(parcelName, cpName, sb, prefix + TAB, true, innerLevel); - sb.Append(prefix + TAB).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", + elementType_->EmitCppUnMarshalling(parcelName, cpName, sb, prefix + g_tab, true, innerLevel); + sb.Append(prefix + g_tab).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", valueName.string(), elementType_->EmitCppType().string(), cpName.string(), elementType_->EmitCppType().string()); - sb.Append(prefix + TAB).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); + sb.Append(prefix + g_tab).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); } else { - elementType_->EmitCppUnMarshalling(parcelName, valueName, sb, prefix + TAB, true, innerLevel); - sb.Append(prefix + TAB).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); + elementType_->EmitCppUnMarshalling(parcelName, valueName, sb, prefix + g_tab, true, innerLevel); + sb.Append(prefix + g_tab).AppendFormat("%s.push_back(%s);\n", name.string(), valueName.string()); + } + sb.Append(prefix).Append("}\n"); +} + +void ASTListType::EmitMemoryRecycle(const String& name, bool isClient, bool ownership, StringBuilder& sb, + const String& prefix) const +{ + String varName = isClient ? String::Format("*%s", name.string()) : name; + String lenName = isClient ? String::Format("*%sLen", name.string()) : String::Format("%sLen", name.string()); + + sb.Append(prefix).AppendFormat("if (%s > 0 && %s != NULL) {\n", lenName.string(), varName.string()); + if (elementType_->GetTypeKind() == TypeKind::TYPE_STRING || elementType_->GetTypeKind() == TypeKind::TYPE_STRUCT) { + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix + g_tab).AppendFormat("for (i = 0; i < %s; i++) {\n", lenName.string()); + } else { + sb.Append(prefix + g_tab).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); + } + + String elementName = isClient ? String::Format("(%s)[i]", varName.string()) : + String::Format("%s[i]", varName.string()); + elementType_->EmitMemoryRecycle(elementName, false, false, sb, prefix + g_tab + g_tab); + sb.Append(prefix + g_tab).Append("}\n"); + } + + sb.Append(prefix + g_tab).AppendFormat("OsalMemFree(%s);\n", varName.string()); + if (isClient) { + sb.Append(prefix + g_tab).AppendFormat("%s = NULL;\n", varName.string()); } + + sb.Append(prefix).Append("}\n"); +} + +void ASTListType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s.writeInt(%s.size());\n", parcelName.string(), name.string()); + sb.Append(prefix).AppendFormat("for (%s element : %s) {\n", + elementType_->EmitJavaType(TypeMode::NO_MODE).string(), name.string()); + elementType_->EmitJavaWriteVar(parcelName, "element", sb, prefix + g_tab); + sb.Append(prefix).Append("}\n"); +} + +void ASTListType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("int %sSize = %s.readInt();\n", name.string(), parcelName.string()); + sb.Append(prefix).AppendFormat("for (int i = 0; i < %sSize; ++i) {\n", name.string()); + + elementType_->EmitJavaReadInnerVar(parcelName, "value", false, sb, prefix + g_tab); + sb.Append(prefix + g_tab).AppendFormat("%s.add(value);\n", name.string()); + sb.Append(prefix).Append("}\n"); +} + +void ASTListType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s %s = new Array%s();\n", + EmitJavaType(TypeMode::NO_MODE).string(), name.string(), EmitJavaType(TypeMode::NO_MODE).string()); + sb.Append(prefix).AppendFormat("int %sSize = %s.readInt();\n", name.string(), parcelName.string()); + sb.Append(prefix).AppendFormat("for (int i = 0; i < %sSize; ++i) {\n", name.string()); + elementType_->EmitJavaReadInnerVar(parcelName, "value", true, sb, prefix + g_tab); + sb.Append(prefix + g_tab).AppendFormat("%s.add(value);\n", name.string()); sb.Append(prefix).Append("}\n"); } + +void ASTListType::EmitCMallocVar(const String& name, const String& lenName, bool isClient, const String& gotoLabel, + StringBuilder& sb, const String& prefix) const +{ + String varName = isClient ? String::Format("*%s", name.string()) : name; + String lenVarName = isClient ? String::Format("*%s", lenName.string()) : lenName; + + sb.Append(prefix).AppendFormat("%s = (%s*)OsalMemCalloc(sizeof(%s) * (%s));\n", varName.string(), + elementType_->EmitCType().string(), elementType_->EmitCType().string(), lenVarName.string()); + sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", varName.string()); + sb.Append(prefix + g_tab).AppendFormat("ec = HDF_ERR_MALLOC_FAIL;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix).AppendFormat("}\n"); +} + +void ASTListType::EmitCProxyReadStrElement(const String& parcelName, const String& name, const String& gotoLabel, + StringBuilder& sb, const String& prefix) const +{ + String cpName = String::Format("%sCp", name.string()); + elementType_->EmitCProxyReadVar(parcelName, cpName, true, gotoLabel, sb, prefix + g_tab); + sb.Append("\n"); + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix + g_tab).AppendFormat("(*%s)[i] = (char*)OsalMemCalloc(strlen(%s) + 1);\n", + name.string(), cpName.string()); + sb.Append(prefix + g_tab).AppendFormat("if ((*%s)[i] == NULL) {\n", name.string()); + sb.Append(prefix + g_tab + g_tab).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); + sb.Append(prefix + g_tab + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("}\n\n"); + sb.Append(prefix + g_tab).AppendFormat("if (strcpy_s((*%s)[i], (strlen(%s) + 1), %s) != HDF_SUCCESS) {\n", + name.string(), cpName.string(), cpName.string()); + sb.Append(prefix + g_tab + g_tab).AppendFormat("HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", + cpName.string()); + sb.Append(prefix + g_tab + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("}\n"); + } else { + sb.Append(prefix + g_tab).AppendFormat("(*%s)[i] = strdup(%sCp);\n", + name.string(), name.string()); + } +} + +void ASTListType::EmitCStubReadStrElement(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + String element = String::Format("%sCp", name.string()); + String newPrefix = prefix + g_tab + g_tab; + elementType_->EmitCStubReadVar(parcelName, element, sb, newPrefix); + sb.Append("\n"); + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(newPrefix).AppendFormat("%s[i] = (char*)OsalMemCalloc(strlen(%s) + 1);\n", + name.string(), element.string()); + sb.Append(newPrefix).AppendFormat("if (%s[i] == NULL) {\n", name.string()); + sb.Append(newPrefix + g_tab).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); + sb.Append(newPrefix + g_tab).AppendFormat("goto errors;\n"); + sb.Append(newPrefix).Append("}\n\n"); + + sb.Append(newPrefix).AppendFormat("if (strcpy_s((%s)[i], (strlen(%s) + 1), %s) != HDF_SUCCESS) {\n", + name.string(), element.string(), element.string()); + sb.Append(newPrefix + g_tab).AppendFormat("HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", + element.string()); + sb.Append(newPrefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(newPrefix + g_tab).Append("goto errors;\n"); + sb.Append(newPrefix).Append("}\n"); + } else { + sb.Append(newPrefix).AppendFormat("%s[i] = strdup(%sCp);\n", name.string(), name.string()); + } +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_list_type.h b/tools/hdi-gen/ast/ast_list_type.h index c58233d512fccd11c3074488a8bf170d0f195adb..a0ab05eba24eed929f5618f4759ade54feff727c 100755 --- a/tools/hdi-gen/ast/ast_list_type.h +++ b/tools/hdi-gen/ast/ast_list_type.h @@ -38,12 +38,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -66,10 +63,34 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitMemoryRecycle(const String& name, bool isClient, bool ownership, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, StringBuilder& sb, + const String& prefix) const override; private: + void EmitCMallocVar(const String& name, const String& lenName, bool isClient, const String& gotoLabel, + StringBuilder& sb, const String& prefix) const; + + void EmitCProxyReadStrElement(const String& parcelName, const String& name, const String& gotoLabel, + StringBuilder& sb, const String& prefix) const; + + void EmitCStubReadStrElement(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const; + + void EmitCStringElementUnMarshalling(const String& name, StringBuilder& sb, const String& newPrefix, + std::vector& freeObjStatements) const; + AutoPtr elementType_ = nullptr; }; } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTLISTTYPE_H +#endif // OHOS_HDI_ASTLISTTYPE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_long_type.cpp b/tools/hdi-gen/ast/ast_long_type.cpp index 55264732bd38c94552781ad0524205d66729ce10..fa0cd6f25acf5250440d669d2945656df2a06093 100755 --- a/tools/hdi-gen/ast/ast_long_type.cpp +++ b/tools/hdi-gen/ast/ast_long_type.cpp @@ -62,27 +62,15 @@ String ASTLongType::EmitJavaType(TypeMode mode, bool isInnerType) const return isInnerType ? "Long" : "long"; } -void ASTLongType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTLongType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt64(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTLongType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt64(%s, %s)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -90,10 +78,10 @@ void ASTLongType::EmitCProxyReadVar(const String& parcelName, const String& name const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt64(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -101,10 +89,10 @@ void ASTLongType::EmitCStubReadVar(const String& parcelName, const String& name, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt64(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -112,9 +100,9 @@ void ASTLongType::EmitCppWriteVar(const String& parcelName, const String& name, const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteInt64(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -132,9 +120,9 @@ void ASTLongType::EmitCppReadVar(const String& parcelName, const String& name, S void ASTLongType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt64(data, %s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -142,10 +130,10 @@ void ASTLongType::EmitCUnMarshalling(const String& name, StringBuilder& sb, cons std::vector& freeObjStatements) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt64(data, &%s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - EmitFreeStatements(freeObjStatements, sb, prefix + TAB); - sb.Append(prefix + TAB).Append("goto errors;\n"); + EmitFreeStatements(freeObjStatements, sb, prefix + g_tab); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -153,9 +141,9 @@ void ASTLongType::EmitCppMarshalling(const String& parcelName, const String& nam const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteInt64(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -169,5 +157,24 @@ void ASTLongType::EmitCppUnMarshalling(const String& parcelName, const String& n sb.Append(prefix).AppendFormat("%s = %s.ReadInt64();\n", name.string(), parcelName.string()); } } + +void ASTLongType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s.writeLong(%s);\n", parcelName.string(), name.string()); +} + +void ASTLongType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s = %s.readLong();\n", name.string(), parcelName.string()); +} + +void ASTLongType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s %s = %s.readLong();\n", + EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_long_type.h b/tools/hdi-gen/ast/ast_long_type.h index dde4c8d0128f3ff16a03c3c24dde73f751d968bc..130a4bbe51f56b49105ecf8ac73979413dd9586e 100755 --- a/tools/hdi-gen/ast/ast_long_type.h +++ b/tools/hdi-gen/ast/ast_long_type.h @@ -27,12 +27,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -55,8 +52,17 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, StringBuilder& sb, + const String& prefix) const override; }; } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTLONGTYPE_H +#endif // OHOS_HDI_ASTLONGTYPE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_map_type.cpp b/tools/hdi-gen/ast/ast_map_type.cpp index f51f0eba4d12d7cdd8c8f656e04c530a81514f0b..4fcd823e8a45f1d5e223c94872498e1ee31f1549 100755 --- a/tools/hdi-gen/ast/ast_map_type.cpp +++ b/tools/hdi-gen/ast/ast_map_type.cpp @@ -61,17 +61,17 @@ void ASTMapType::EmitCppWriteVar(const String& parcelName, const String& name, S const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteUint32(%s.size())) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); String elementName = String::Format("it%d", innerLevel++); sb.Append(prefix).AppendFormat("for (auto %s : %s) {\n", elementName.string(), name.string()); String keyName = String::Format("(%s.first)", elementName.string()); String valueName = String::Format("(%s.second)", elementName.string()); - keyType_->EmitCppWriteVar(parcelName, keyName, sb, prefix + TAB, innerLevel); - valueType_->EmitCppWriteVar(parcelName, valueName, sb, prefix + TAB, innerLevel); + keyType_->EmitCppWriteVar(parcelName, keyName, sb, prefix + g_tab, innerLevel); + valueType_->EmitCppWriteVar(parcelName, valueName, sb, prefix + g_tab, innerLevel); sb.Append(prefix).Append("}\n"); } @@ -87,9 +87,9 @@ void ASTMapType::EmitCppReadVar(const String& parcelName, const String& name, St String KeyName = String::Format("key%d", innerLevel); String valueName = String::Format("value%d", innerLevel); innerLevel++; - keyType_->EmitCppReadVar(parcelName, KeyName, sb, prefix + TAB, true, innerLevel); - valueType_->EmitCppReadVar(parcelName, valueName, sb, prefix + TAB, true, innerLevel); - sb.Append(prefix + TAB).AppendFormat("%s[%s] = %s;\n", name.string(), KeyName.string(), valueName.string()); + keyType_->EmitCppReadVar(parcelName, KeyName, sb, prefix + g_tab, true, innerLevel); + valueType_->EmitCppReadVar(parcelName, valueName, sb, prefix + g_tab, true, innerLevel); + sb.Append(prefix + g_tab).AppendFormat("%s[%s] = %s;\n", name.string(), KeyName.string(), valueName.string()); sb.Append(prefix).Append("}\n"); } @@ -97,17 +97,17 @@ void ASTMapType::EmitCppMarshalling(const String& parcelName, const String& name const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteUint32(%s.size())) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s.size failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); String elementName = String::Format("it%d", innerLevel++); sb.Append(prefix).AppendFormat("for (auto %s : %s) {\n", elementName.string(), name.string()); String keyName = String::Format("(%s.first)", elementName.string()); String valName = String::Format("(%s.second)", elementName.string()); - keyType_->EmitCppMarshalling(parcelName, keyName, sb, prefix + TAB, innerLevel); - valueType_->EmitCppMarshalling(parcelName, valName, sb, prefix + TAB, innerLevel); + keyType_->EmitCppMarshalling(parcelName, keyName, sb, prefix + g_tab, innerLevel); + valueType_->EmitCppMarshalling(parcelName, valName, sb, prefix + g_tab, innerLevel); sb.Append(prefix).Append("}\n"); } @@ -123,11 +123,50 @@ void ASTMapType::EmitCppUnMarshalling(const String& parcelName, const String& na String KeyName = String::Format("key%d", innerLevel); String valueName = String::Format("value%d", innerLevel); innerLevel++; - keyType_->EmitCppUnMarshalling(parcelName, KeyName, sb, prefix + TAB, true, innerLevel); - valueType_->EmitCppUnMarshalling(parcelName, valueName, sb, prefix + TAB, true, innerLevel); - sb.Append(prefix + TAB).AppendFormat("%s[%s] = %s;\n", + keyType_->EmitCppUnMarshalling(parcelName, KeyName, sb, prefix + g_tab, true, innerLevel); + valueType_->EmitCppUnMarshalling(parcelName, valueName, sb, prefix + g_tab, true, innerLevel); + sb.Append(prefix + g_tab).AppendFormat("%s[%s] = %s;\n", name.string(), KeyName.string(), valueName.string()); sb.Append(prefix).Append("}\n"); } + +void ASTMapType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s.writeInt(%s.size());\n", parcelName.string(), name.string()); + sb.Append(prefix).AppendFormat("for (Map.Entry<%s, %s> entry : %s.entrySet()) {\n", + keyType_->EmitJavaType(TypeMode::NO_MODE, true).string(), + valueType_->EmitJavaType(TypeMode::NO_MODE, true).string(), name.string()); + keyType_->EmitJavaWriteVar(parcelName, "entry.getKey()", sb, prefix + g_tab); + valueType_->EmitJavaWriteVar(parcelName, "entry.getValue()", sb, prefix + g_tab); + sb.Append(prefix).Append("}\n"); +} + +void ASTMapType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("int %sSize = %s.readInt();\n", name.string(), parcelName.string()); + sb.Append(prefix).AppendFormat("for (int i = 0; i < %sSize; ++i) {\n", name.string()); + + keyType_->EmitJavaReadInnerVar(parcelName, "key", false, sb, prefix + g_tab); + valueType_->EmitJavaReadInnerVar(parcelName, "value", false, sb, prefix + g_tab); + + sb.Append(prefix + g_tab).AppendFormat("%s.put(key, value);\n", name.string()); + sb.Append(prefix).Append("}\n"); +} + +void ASTMapType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s %s = new Hash%s();\n", + EmitJavaType(TypeMode::NO_MODE).string(), name.string(), EmitJavaType(TypeMode::NO_MODE).string()); + sb.Append(prefix).AppendFormat("int %sSize = %s.readInt();\n", name.string(), parcelName.string()); + sb.Append(prefix).AppendFormat("for (int i = 0; i < %sSize; ++i) {\n", name.string()); + + keyType_->EmitJavaReadInnerVar(parcelName, "key", true, sb, prefix + g_tab); + valueType_->EmitJavaReadInnerVar(parcelName, "value", true, sb, prefix + g_tab); + sb.Append(prefix + g_tab).AppendFormat("%s.put(key, value);\n", name.string()); + sb.Append(prefix).Append("}\n"); +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_map_type.h b/tools/hdi-gen/ast/ast_map_type.h index 44c011a1eea1ce93fb0aaf58f05b288284a8e0fe..b020d59985d4ab358030b73a7c5fab56515508cd 100755 --- a/tools/hdi-gen/ast/ast_map_type.h +++ b/tools/hdi-gen/ast/ast_map_type.h @@ -59,6 +59,15 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, StringBuilder& sb, + const String& prefix) const override; private: AutoPtr keyType_; AutoPtr valueType_; diff --git a/tools/hdi-gen/ast/ast_method.h b/tools/hdi-gen/ast/ast_method.h index fd157b22d4a1c604680b6845554f4ac55c45ad7b..9b4a21d004ca2ba14bc621bc34f5d24c99468cdf 100755 --- a/tools/hdi-gen/ast/ast_method.h +++ b/tools/hdi-gen/ast/ast_method.h @@ -82,4 +82,4 @@ private: } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTMETHOD_H +#endif // OHOS_HDI_ASTMETHOD_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_namespace.h b/tools/hdi-gen/ast/ast_namespace.h index 26944c59423e2f12c7a8b431c1282c39034dc38c..b3d6fc96019083644e4d027ac19f1a6b98bb06dd 100755 --- a/tools/hdi-gen/ast/ast_namespace.h +++ b/tools/hdi-gen/ast/ast_namespace.h @@ -75,4 +75,4 @@ private: } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTNAMESPACE_H +#endif // OHOS_HDI_ASTNAMESPACE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_node.h b/tools/hdi-gen/ast/ast_node.h index 0aebbaafb19bdc83023970a63d86352d1b4db6e0..5f894f6153b73d0875f23e2bd0cd5c1558106cb4 100755 --- a/tools/hdi-gen/ast/ast_node.h +++ b/tools/hdi-gen/ast/ast_node.h @@ -25,4 +25,4 @@ public: } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTNODE_H +#endif // OHOS_HDI_ASTNODE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_parameter.cpp b/tools/hdi-gen/ast/ast_parameter.cpp index 6247f981ddac6b8cdd07db796afc9ddd4bb6f099..1e87e1b2b15c5dbeeba1078a3185671cc9fde7df 100755 --- a/tools/hdi-gen/ast/ast_parameter.cpp +++ b/tools/hdi-gen/ast/ast_parameter.cpp @@ -205,5 +205,37 @@ String ASTParameter::EmitJavaLocalVar() { return ""; } + +void ASTParameter::EmitCWriteVar(const String& parcelName, const String& gotoLabel, StringBuilder& sb, + const String& prefix) const +{ + if (type_ == nullptr) { + return; + } + + type_->EmitCWriteVar(parcelName, name_, gotoLabel, sb, prefix); +} + +void ASTParameter::EmitJavaWriteVar(const String& parcelName, StringBuilder& sb, const String& prefix) const +{ + if (attribute_ == ParamAttr::PARAM_IN) { + type_->EmitJavaWriteVar(parcelName, name_, sb, prefix); + } else { + if (type_->GetTypeKind() == TypeKind::TYPE_ARRAY) { + sb.Append(prefix).AppendFormat("if (%s == null) {\n", name_.string()); + sb.Append(prefix + g_tab).AppendFormat("%s.writeInt(-1);\n", parcelName.string()); + sb.Append(prefix).Append("} else {\n"); + sb.Append(prefix + g_tab).AppendFormat("%s.writeInt(%s.length);\n", parcelName.string(), name_.string()); + sb.Append(prefix).Append("}\n"); + } + } +} + +void ASTParameter::EmitJavaReadVar(const String& parcelName, StringBuilder& sb, const String& prefix) const +{ + if (attribute_ == ParamAttr::PARAM_OUT) { + type_->EmitJavaReadVar(parcelName, name_, sb, prefix); + } +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_parameter.h b/tools/hdi-gen/ast/ast_parameter.h index d2c9051987ef36552144d7109c046b5780df3f4f..97e4cd226c34da618c3ad0de01728e035d99ae4b 100755 --- a/tools/hdi-gen/ast/ast_parameter.h +++ b/tools/hdi-gen/ast/ast_parameter.h @@ -67,6 +67,13 @@ public: String EmitCppLocalVar(); String EmitJavaLocalVar(); + + void EmitCWriteVar(const String& parcelName, const String& gotoLabel, StringBuilder& sb, + const String& prefix) const; + + void EmitJavaWriteVar(const String& parcelName, StringBuilder& sb, const String& prefix) const; + + void EmitJavaReadVar(const String& parcelName, StringBuilder& sb, const String& prefix) const; private: String name_; AutoPtr type_ = nullptr; @@ -75,4 +82,4 @@ private: } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTPARAMETER_H +#endif // OHOS_HDI_ASTPARAMETER_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_sequenceable_type.cpp b/tools/hdi-gen/ast/ast_sequenceable_type.cpp index da20f21ab8405ed8bb708f4b6c2d8fbf2efa7927..dac9ef18fc3afc00ced65ec1d41752514f0ed811 100755 --- a/tools/hdi-gen/ast/ast_sequenceable_type.cpp +++ b/tools/hdi-gen/ast/ast_sequenceable_type.cpp @@ -85,9 +85,9 @@ void ASTSequenceableType::EmitCppWriteVar(const String& parcelName, const String { sb.Append(prefix).AppendFormat("if (!%s.WriteStrongParcelable(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -108,9 +108,9 @@ void ASTSequenceableType::EmitCppMarshalling(const String& parcelName, const Str { sb.Append(prefix).AppendFormat("if (!%s.WriteStrongParcelable(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -125,5 +125,40 @@ void ASTSequenceableType::EmitCppUnMarshalling(const String& parcelName, const S name.string(), parcelName.string(), name_.string()); } } + +void ASTSequenceableType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + if (EmitJavaType(TypeMode::NO_MODE).Equals("IRemoteObject")) { + sb.Append(prefix).AppendFormat("%s.writeRemoteObject(%s);\n", parcelName.string(), name.string()); + return; + } + sb.Append(prefix).AppendFormat("%s.writeSequenceable(%s);\n", parcelName.string(), name.string()); +} + +void ASTSequenceableType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + if (EmitJavaType(TypeMode::NO_MODE).Equals("IRemoteObject")) { + sb.Append(prefix).AppendFormat("%s = %s.readRemoteObject();\n", name.string(), parcelName.string()); + return; + } + sb.Append(prefix).AppendFormat("%s.readSequenceable(%s);\n", parcelName.string(), name.string()); +} + +void ASTSequenceableType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + if (!isInner && EmitJavaType(TypeMode::NO_MODE).Equals("IRemoteObject")) { + sb.Append(prefix).AppendFormat("IRemoteObject %s = %s.readRemoteObject();\n", + name.string(), parcelName.string()); + return; + } + if (!isInner) { + sb.Append(prefix).AppendFormat("%s %s = new %s();\n", + EmitJavaType(TypeMode::NO_MODE).string(), name.string(), EmitJavaType(TypeMode::NO_MODE).string()); + } + sb.Append(prefix).AppendFormat("%s.readSequenceable(%s);\n", parcelName.string(), name.string()); +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_sequenceable_type.h b/tools/hdi-gen/ast/ast_sequenceable_type.h index 92539424bdbf422651bb8079f62ca098eab1698d..8a1b28261215731cf7d16d3417f7d32e64d460d1 100755 --- a/tools/hdi-gen/ast/ast_sequenceable_type.h +++ b/tools/hdi-gen/ast/ast_sequenceable_type.h @@ -44,8 +44,17 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const override; }; } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTSEQUENCEABLETYPE_H +#endif // OHOS_HDI_ASTSEQUENCEABLETYPE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_short_type.cpp b/tools/hdi-gen/ast/ast_short_type.cpp index a30e7a101f30e87d9e6fb88abaff356e637c06d8..9f2b4eeafb491c8c7b55666dc834d01b22eae496 100755 --- a/tools/hdi-gen/ast/ast_short_type.cpp +++ b/tools/hdi-gen/ast/ast_short_type.cpp @@ -62,27 +62,15 @@ String ASTShortType::EmitJavaType(TypeMode mode, bool isInnerType) const return isInnerType ? "Short" : "short"; } -void ASTShortType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTShortType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt16(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTShortType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt16(%s, %s)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -90,10 +78,10 @@ void ASTShortType::EmitCProxyReadVar(const String& parcelName, const String& nam const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt16(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -101,10 +89,10 @@ void ASTShortType::EmitCStubReadVar(const String& parcelName, const String& name const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt16(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -112,9 +100,9 @@ void ASTShortType::EmitCppWriteVar(const String& parcelName, const String& name, const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteInt16(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -133,9 +121,9 @@ void ASTShortType::EmitCppReadVar(const String& parcelName, const String& name, void ASTShortType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteInt16(data, %s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -143,10 +131,10 @@ void ASTShortType::EmitCUnMarshalling(const String& name, StringBuilder& sb, con std::vector& freeObjStatements) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadInt16(data, &%s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - EmitFreeStatements(freeObjStatements, sb, prefix + TAB); - sb.Append(prefix + TAB).Append("goto errors;\n"); + EmitFreeStatements(freeObjStatements, sb, prefix + g_tab); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -154,9 +142,9 @@ void ASTShortType::EmitCppMarshalling(const String& parcelName, const String& na const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteInt16(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -170,5 +158,24 @@ void ASTShortType::EmitCppUnMarshalling(const String& parcelName, const String& sb.Append(prefix).AppendFormat("%s = %s.ReadInt16();\n", name.string(), parcelName.string()); } } + +void ASTShortType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s.writeShort(%s);\n", parcelName.string(), name.string()); +} + +void ASTShortType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s = %s.readShort();\n", name.string(), parcelName.string()); +} + +void ASTShortType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s %s = %s.readShort();\n", + EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_short_type.h b/tools/hdi-gen/ast/ast_short_type.h index b85ff37157d2c3979fb69cad2d16809d2a8ba562..1b5e7642bcf605861bf7c331ec1c10916b4e7a01 100755 --- a/tools/hdi-gen/ast/ast_short_type.h +++ b/tools/hdi-gen/ast/ast_short_type.h @@ -27,12 +27,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -55,8 +52,17 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, StringBuilder& sb, + const String& prefix) const override; }; } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTSHORTTYPE_H +#endif // OHOS_HDI_ASTSHORTTYPE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_string_type.cpp b/tools/hdi-gen/ast/ast_string_type.cpp index d658766fd17c86e95434a40b3965bf1128920a79..a3c891b16a64d280992609a5da260b17d168f1ab 100755 --- a/tools/hdi-gen/ast/ast_string_type.cpp +++ b/tools/hdi-gen/ast/ast_string_type.cpp @@ -62,27 +62,15 @@ String ASTStringType::EmitJavaType(TypeMode mode, bool isInnerType) const return "String"; } -void ASTStringType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTStringType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteString(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTStringType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteString(%s, %s)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -92,10 +80,10 @@ void ASTStringType::EmitCProxyReadVar(const String& parcelName, const String& na sb.Append(prefix).AppendFormat("const char *%s = HdfSbufReadString(%s);\n", name.string(), parcelName.string()); sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -105,10 +93,10 @@ void ASTStringType::EmitCStubReadVar(const String& parcelName, const String& nam sb.Append(prefix).AppendFormat("const char *%s = HdfSbufReadString(%s);\n", name.string(), parcelName.string()); sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -116,9 +104,9 @@ void ASTStringType::EmitCppWriteVar(const String& parcelName, const String& name const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteString(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -136,9 +124,9 @@ void ASTStringType::EmitCppReadVar(const String& parcelName, const String& name, void ASTStringType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteString(data, %s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -147,10 +135,10 @@ void ASTStringType::EmitCUnMarshalling(const String& name, StringBuilder& sb, co { sb.Append(prefix).AppendFormat("const char *%s = HdfSbufReadString(data);\n", name.string()); sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - EmitFreeStatements(freeObjStatements, sb, prefix + TAB); - sb.Append(prefix + TAB).Append("goto errors;\n"); + EmitFreeStatements(freeObjStatements, sb, prefix + g_tab); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -158,9 +146,9 @@ void ASTStringType::EmitCppMarshalling(const String& parcelName, const String& n const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteString(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -175,5 +163,34 @@ void ASTStringType::EmitCppUnMarshalling(const String& parcelName, const String& name.string(), parcelName.string()); } } + +void ASTStringType::EmitMemoryRecycle(const String& name, bool isClient, bool ownership, StringBuilder& sb, + const String& prefix) const +{ + String varName = isClient ? String::Format("*%s", name.string()) : name; + sb.Append(prefix).AppendFormat("if (%s != NULL) {\n", varName.string()); + sb.Append(prefix + g_tab).AppendFormat("OsalMemFree(%s);\n", varName.string()); + sb.Append(prefix + g_tab).AppendFormat("%s = NULL;\n", varName.string()); + sb.Append(prefix).Append("}\n"); +} + +void ASTStringType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s.writeString(%s);\n", parcelName.string(), name.string()); +} + +void ASTStringType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s = %s.readString();\n", name.string(), parcelName.string()); +} + +void ASTStringType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + sb.Append(prefix).AppendFormat("%s %s = %s.readString();\n", + EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_string_type.h b/tools/hdi-gen/ast/ast_string_type.h index 84f4ff7b0120f0ac921dd37a2d8963cb2a4765cf..55f6707619377ccc00bfda59b55504403f69ae1c 100755 --- a/tools/hdi-gen/ast/ast_string_type.h +++ b/tools/hdi-gen/ast/ast_string_type.h @@ -27,12 +27,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -55,8 +52,20 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitMemoryRecycle(const String& name, bool isClient, bool ownership, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const override; + + void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, StringBuilder& sb, + const String& prefix) const override; }; } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTSTRINGTYPE_H +#endif // OHOS_HDI_ASTSTRINGTYPE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_struct_type.cpp b/tools/hdi-gen/ast/ast_struct_type.cpp index 9ce8920aa16d2296ae02fd72b048a8ec8853cedb..474c12d6f733ae0318c0579acc90d752b1fc8a01 100755 --- a/tools/hdi-gen/ast/ast_struct_type.cpp +++ b/tools/hdi-gen/ast/ast_struct_type.cpp @@ -147,27 +147,15 @@ String ASTStructType::EmitJavaTypeDecl() const return sb.ToString(); } -void ASTStructType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTStructType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!%sBlockMarshalling(%s, %s)) {\n", name_.string(), parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTStructType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!%sBlockMarshalling(%s, %s)) {\n", - name_.string(), parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -176,10 +164,10 @@ void ASTStructType::EmitCProxyReadVar(const String& parcelName, const String& na { sb.Append(prefix).AppendFormat("if (!%sBlockUnmarshalling(%s, %s)) {\n", name_.string(), parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -188,10 +176,10 @@ void ASTStructType::EmitCStubReadVar(const String& parcelName, const String& nam { sb.Append(prefix).AppendFormat("if (!%sBlockUnmarshalling(%s, %s)) {\n", name_.string(), parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).AppendFormat("}\n"); } @@ -200,9 +188,9 @@ void ASTStructType::EmitCppWriteVar(const String& parcelName, const String& name { sb.Append(prefix).AppendFormat("if (!%sBlockMarshalling(%s, %s)) {\n", EmitCppType().string(), parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -214,8 +202,8 @@ void ASTStructType::EmitCppReadVar(const String& parcelName, const String& name, } sb.Append(prefix).AppendFormat("if (!%sBlockUnmarshalling(%s, %s)) {\n", name_.string(), parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat("HDF_LOGE(\"%%s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("HDF_LOGE(\"%%s: read %s failed!\", __func__);\n", name.string()); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -223,9 +211,9 @@ void ASTStructType::EmitCMarshalling(const String& name, StringBuilder& sb, cons { sb.Append(prefix).AppendFormat("if (!%sBlockMarshalling(data, &%s)) {\n", name_.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -234,9 +222,9 @@ void ASTStructType::EmitCUnMarshalling(const String& name, StringBuilder& sb, co { sb.Append(prefix).AppendFormat("if (!%sBlockUnmarshalling(data, %s)) {\n", name_.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -245,9 +233,9 @@ void ASTStructType::EmitCppMarshalling(const String& parcelName, const String& n { sb.Append(prefix).AppendFormat("if (!%sBlockMarshalling(%s, %s)) {\n", name_.string(), parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -256,10 +244,24 @@ void ASTStructType::EmitCppUnMarshalling(const String& parcelName, const String& { sb.Append(prefix).AppendFormat("if (!%sBlockUnmarshalling(data, %s)) {\n", EmitCppType().string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } + +void ASTStructType::EmitMemoryRecycle(const String& name, bool isClient, bool ownership, StringBuilder& sb, + const String& prefix) const +{ + String varName = isClient ? String::Format("*%s", name.string()) : name; + if (ownership) { + sb.Append(prefix).AppendFormat("if (%s != NULL) {\n", varName.string()); + sb.Append(prefix + g_tab).AppendFormat("%sFree(%s, true);\n", name_.string(), varName.string()); + sb.Append(prefix + g_tab).AppendFormat("%s = NULL;\n", varName.string()); + sb.Append(prefix).Append("}\n"); + } else { + sb.Append(prefix).AppendFormat("%sFree(&%s, false);\n", name_.string(), name.string()); + } +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_struct_type.h b/tools/hdi-gen/ast/ast_struct_type.h index fb69c32075668ed6bbbf0fc92120b124409599d3..3eb3f24627d69e6b630b887f19cc9e7e3b5b2de9 100755 --- a/tools/hdi-gen/ast/ast_struct_type.h +++ b/tools/hdi-gen/ast/ast_struct_type.h @@ -92,12 +92,9 @@ public: String EmitJavaTypeDecl() const; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -120,6 +117,9 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitMemoryRecycle(const String& name, bool isClient, bool ownership, StringBuilder& sb, + const String& prefix) const override; private: bool isFull_ = false; bool isLite_ = false; diff --git a/tools/hdi-gen/ast/ast_type.cpp b/tools/hdi-gen/ast/ast_type.cpp index 6e18d8e0894fc58085668cc0dcd5a5e03d39b39a..61b859e83a0b4f1bef22ffaca51acc9fd3cad2fa 100755 --- a/tools/hdi-gen/ast/ast_type.cpp +++ b/tools/hdi-gen/ast/ast_type.cpp @@ -10,7 +10,7 @@ namespace OHOS { namespace HDI { -const char* ASTType::TAB = " "; +const char* g_tab = " "; void ASTType::SetName(const String& name) { @@ -172,18 +172,12 @@ String ASTType::EmitJavaType(TypeMode mode, bool isInnerType) const return "unknow"; } -void ASTType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("//Writeing \"%s\" type of data is not supported\n", name_.string()); } -void ASTType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("//Writing \"%s\" type of data is not supported\n", name_.string()); -} - void ASTType::EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { @@ -238,5 +232,29 @@ void ASTType::EmitCppUnMarshalling(const String& parcelName, const String& name, { sb.Append(prefix).AppendFormat("//Reading \"%s\" type of data is not supported\n", name_.string()); } + +void ASTType::EmitMemoryRecycle(const String& name, bool isClient, bool ownership, StringBuilder& sb, + const String& prefix) const +{ + // only String, Array, List, struct and union type need recycle memory +} + +void ASTType::EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("//Writeing \"%s\" type of data is not supported\n", name_.string()); +} + +void ASTType::EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const +{ + sb.Append(prefix).AppendFormat("//Reading \"%s\" type of data is not supported\n", name_.string()); +} + +void ASTType::EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, + StringBuilder& sb, const String& prefix) const +{ + sb.Append(prefix).AppendFormat("//Reading \"%s\" type of data is not supported\n", name_.string()); +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_type.h b/tools/hdi-gen/ast/ast_type.h index d2fee8085c05fc486f6c1f735b59483ebc273bfa..7e8cdd4aac6de98e5cc95dbf0224ebb324808082 100755 --- a/tools/hdi-gen/ast/ast_type.h +++ b/tools/hdi-gen/ast/ast_type.h @@ -16,6 +16,8 @@ namespace OHOS { namespace HDI { +extern const char* g_tab; + enum class TypeKind { TYPE_UNKNOWN = 0, TYPE_BOOLEAN, @@ -121,12 +123,9 @@ public: virtual String EmitJavaType(TypeMode mode, bool isInnerType = false) const; - virtual void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + virtual void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const; - virtual void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const; - virtual void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const; @@ -152,8 +151,19 @@ public: virtual void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const; + + virtual void EmitMemoryRecycle(const String& name, bool isClient, bool ownership, StringBuilder& sb, + const String& prefix) const; + + virtual void EmitJavaWriteVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const; + + virtual void EmitJavaReadVar(const String& parcelName, const String& name, StringBuilder& sb, + const String& prefix) const; + + virtual void EmitJavaReadInnerVar(const String& parcelName, const String& name, bool isInner, StringBuilder& sb, + const String& prefix) const; protected: - static const char* TAB; String name_; AutoPtr namespace_; TypeKind typeKind_; @@ -161,4 +171,4 @@ protected: } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTTYPE_H +#endif // OHOS_HDI_ASTTYPE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_uchar_type.cpp b/tools/hdi-gen/ast/ast_uchar_type.cpp index 50e70e5161a6f8d6bae7059094772bd9b290560f..94e177824811ef650536f77144fb57aec94c90f7 100755 --- a/tools/hdi-gen/ast/ast_uchar_type.cpp +++ b/tools/hdi-gen/ast/ast_uchar_type.cpp @@ -63,27 +63,15 @@ String ASTUcharType::EmitJavaType(TypeMode mode, bool isInnerType) const return "/"; } -void ASTUcharType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTUcharType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint8(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTUcharType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint8(%s, %s)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -91,10 +79,10 @@ void ASTUcharType::EmitCProxyReadVar(const String& parcelName, const String& nam const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint8(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -102,10 +90,10 @@ void ASTUcharType::EmitCStubReadVar(const String& parcelName, const String& name const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint8(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -113,9 +101,9 @@ void ASTUcharType::EmitCppWriteVar(const String& parcelName, const String& name, const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteUint8(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -133,9 +121,9 @@ void ASTUcharType::EmitCppReadVar(const String& parcelName, const String& name, void ASTUcharType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint8(data, %s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -143,10 +131,10 @@ void ASTUcharType::EmitCUnMarshalling(const String& name, StringBuilder& sb, con std::vector& freeObjStatements) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint8(data, &%s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - EmitFreeStatements(freeObjStatements, sb, prefix + TAB); - sb.Append(prefix + TAB).Append("goto errors;\n"); + EmitFreeStatements(freeObjStatements, sb, prefix + g_tab); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -154,9 +142,9 @@ void ASTUcharType::EmitCppMarshalling(const String& parcelName, const String& na const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteUint8(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } diff --git a/tools/hdi-gen/ast/ast_uchar_type.h b/tools/hdi-gen/ast/ast_uchar_type.h index 825b503c6ecb3d0a35face4272bf1f54d33efcc5..87cd06151faf261e6fa5fb979e293917009a5615 100755 --- a/tools/hdi-gen/ast/ast_uchar_type.h +++ b/tools/hdi-gen/ast/ast_uchar_type.h @@ -27,12 +27,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; diff --git a/tools/hdi-gen/ast/ast_uint_type.cpp b/tools/hdi-gen/ast/ast_uint_type.cpp index 6d27b5499535a3c57ba0bad9c48dc1e5183c32e4..964d61ea595b25dd1c68afb0a677bb8987f962f6 100755 --- a/tools/hdi-gen/ast/ast_uint_type.cpp +++ b/tools/hdi-gen/ast/ast_uint_type.cpp @@ -63,27 +63,15 @@ String ASTUintType::EmitJavaType(TypeMode mode, bool isInnerType) const return "/"; } -void ASTUintType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTUintType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint32(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTUintType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint32(%s, %s)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -91,10 +79,10 @@ void ASTUintType::EmitCProxyReadVar(const String& parcelName, const String& name const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint32(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -102,10 +90,10 @@ void ASTUintType::EmitCStubReadVar(const String& parcelName, const String& name, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint32(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -113,9 +101,9 @@ void ASTUintType::EmitCppWriteVar(const String& parcelName, const String& name, const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteUint32(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -133,9 +121,9 @@ void ASTUintType::EmitCppReadVar(const String& parcelName, const String& name, S void ASTUintType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint32(data, %s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -143,10 +131,10 @@ void ASTUintType::EmitCUnMarshalling(const String& name, StringBuilder& sb, cons std::vector& freeObjStatements) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint32(data, &%s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - EmitFreeStatements(freeObjStatements, sb, prefix + TAB); - sb.Append(prefix + TAB).Append("goto errors;\n"); + EmitFreeStatements(freeObjStatements, sb, prefix + g_tab); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -154,9 +142,9 @@ void ASTUintType::EmitCppMarshalling(const String& parcelName, const String& nam const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteUint32(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } diff --git a/tools/hdi-gen/ast/ast_uint_type.h b/tools/hdi-gen/ast/ast_uint_type.h index 97458c444b886688652b6a9a473d6c82b926acab..d33e9fcd45e808a881d179a06c18a2f4a1c11263 100755 --- a/tools/hdi-gen/ast/ast_uint_type.h +++ b/tools/hdi-gen/ast/ast_uint_type.h @@ -27,12 +27,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -59,4 +56,4 @@ public: } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTUINTTYPE_H +#endif // OHOS_HDI_ASTUINTTYPE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_ulong_type.cpp b/tools/hdi-gen/ast/ast_ulong_type.cpp index d42fe90b88aae5f53ddcb1d7c2a13571d87ba76f..dd09f23f26ec20a89c96a4dfa83956a5cc7df63c 100755 --- a/tools/hdi-gen/ast/ast_ulong_type.cpp +++ b/tools/hdi-gen/ast/ast_ulong_type.cpp @@ -63,27 +63,15 @@ String ASTUlongType::EmitJavaType(TypeMode mode, bool isInnerType) const return "/"; } -void ASTUlongType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTUlongType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint64(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTUlongType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint64(%s, %s)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -91,10 +79,10 @@ void ASTUlongType::EmitCProxyReadVar(const String& parcelName, const String& nam const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint64(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -102,10 +90,10 @@ void ASTUlongType::EmitCStubReadVar(const String& parcelName, const String& name const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint64(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -113,9 +101,9 @@ void ASTUlongType::EmitCppWriteVar(const String& parcelName, const String& name, const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteUint64(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -133,9 +121,9 @@ void ASTUlongType::EmitCppReadVar(const String& parcelName, const String& name, void ASTUlongType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint64(data, %s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -143,10 +131,10 @@ void ASTUlongType::EmitCUnMarshalling(const String& name, StringBuilder& sb, con std::vector& freeObjStatements) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint64(data, &%s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - EmitFreeStatements(freeObjStatements, sb, prefix + TAB); - sb.Append(prefix + TAB).Append("goto errors;\n"); + EmitFreeStatements(freeObjStatements, sb, prefix + g_tab); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -154,9 +142,9 @@ void ASTUlongType::EmitCppMarshalling(const String& parcelName, const String& na const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteUint64(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } diff --git a/tools/hdi-gen/ast/ast_ulong_type.h b/tools/hdi-gen/ast/ast_ulong_type.h index 599ccd29411d955d463f9a677fbe611ffa03faab..9d616eb9b6e945b1f0f28fe823c53a5b0b0e4cc5 100755 --- a/tools/hdi-gen/ast/ast_ulong_type.h +++ b/tools/hdi-gen/ast/ast_ulong_type.h @@ -27,12 +27,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -59,4 +56,4 @@ public: } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_ASTULONGTYPE_H +#endif // OHOS_HDI_ASTULONGTYPE_H \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_union_type.cpp b/tools/hdi-gen/ast/ast_union_type.cpp index dfdf7bd9e4bc0da4b6de4429afa1d8651e39a125..328b4eabdab4ba94fa1544984e6736caa5ef1a1b 100755 --- a/tools/hdi-gen/ast/ast_union_type.cpp +++ b/tools/hdi-gen/ast/ast_union_type.cpp @@ -7,6 +7,7 @@ */ #include "ast/ast_union_type.h" +#include "util/options.h" #include "util/string_builder.h" namespace OHOS { @@ -147,53 +148,76 @@ String ASTUnionType::EmitJavaTypeDecl() const return sb.ToString(); } -void ASTUnionType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTUnionType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUnpadBuffer(%s, (const uint8_t *)%s, sizeof(%s))) {\n", - parcelName.string(), name.string(), EmitCType().string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTUnionType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUnpadBuffer(%s, (const uint8_t *)%s, sizeof(%s))) {\n", - parcelName.string(), name.string(), EmitCType().string()); - sb.Append(prefix + TAB).AppendFormat( + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix).AppendFormat("if (!HdfSbufWriteBuffer(%s, (const void *)%s, sizeof(%s))) {\n", + parcelName.string(), name.string(), EmitCType().string()); + } else { + sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUnpadBuffer(%s, (const uint8_t *)%s, sizeof(%s))) {\n", + parcelName.string(), name.string(), EmitCType().string()); + } + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } void ASTUnionType::EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { - sb.Append(prefix).AppendFormat("const %s *%s = (%s *)HdfSbufReadUnpadBuffer(%s, sizeof(%s));\n", - EmitCType().string(), name.string(), EmitCType().string(), parcelName.string(), - EmitCType().string()); - sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix).AppendFormat("%s *%s = NULL;\n", EmitCType().string(), name.string()); + sb.Append(prefix).Append("uint32_t len = 0;\n"); + sb.Append(prefix).AppendFormat("if (!HdfSbufReadBuffer(%s, (const void **)&%s, &len)) {\n", + parcelName.string(), name.string()); + sb.Append(prefix + g_tab).AppendFormat( + "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix).Append("}\n\n"); + sb.Append(prefix).AppendFormat("if (%s == NULL || sizeof(%s) != len) {\n", + name.string(), EmitCType().string()); + } else { + sb.Append(prefix).AppendFormat("const %s *%s = (%s *)HdfSbufReadUnpadBuffer(%s, sizeof(%s));\n", + EmitCType().string(), name.string(), EmitCType().string(), parcelName.string(), EmitCType().string()); + sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", name.string()); + } + + sb.Append(prefix + g_tab).AppendFormat( + "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } void ASTUnionType::EmitCStubReadVar(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix) const { - sb.Append(prefix).AppendFormat("const %s *%s = (%s *)HdfSbufReadUnpadBuffer(%s, sizeof(%s));\n", - EmitCType().string(), name.string(), EmitCType().string(), parcelName.string(), - EmitCType().string()); - sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix).AppendFormat("%s *%s = NULL;\n", EmitCType().string(), name.string()); + sb.Append(prefix).Append("uint32_t len = 0;\n"); + sb.Append(prefix).AppendFormat("if (!HdfSbufReadBuffer(%s, (const void **)&%s, &len)) {\n", + parcelName.string(), name.string()); + sb.Append(prefix + g_tab).AppendFormat( + "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); + sb.Append(prefix).Append("}\n\n"); + sb.Append(prefix).AppendFormat("if (%s == NULL || sizeof(%s) != len) {\n", + name.string(), EmitCType().string()); + } else { + sb.Append(prefix).AppendFormat("const %s *%s = (%s *)HdfSbufReadUnpadBuffer(%s, sizeof(%s));\n", + EmitCType().string(), name.string(), EmitCType().string(), parcelName.string(), EmitCType().string()); + sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", name.string()); + } + + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -202,9 +226,9 @@ void ASTUnionType::EmitCppWriteVar(const String& parcelName, const String& name, { sb.Append(prefix).AppendFormat("if (!%s.WriteUnpadBuffer((const uint8_t *)&%s, sizeof(%s))) {\n", parcelName.string(), name.string(), EmitCppType().string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -219,8 +243,8 @@ void ASTUnionType::EmitCppReadVar(const String& parcelName, const String& name, EmitCppType().string(), name.string(), EmitCppType().string(), parcelName.string(), EmitCppType().string()); sb.Append(prefix).AppendFormat("if (%sCp == nullptr) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat("HDF_LOGE(\"%%s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("HDF_LOGE(\"%%s: read %s failed!\", __func__);\n", name.string()); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); sb.Append(prefix).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %sCp, sizeof(%s));\n", name.string(), EmitCppType().string(), name.string(), EmitCppType().string()); @@ -228,23 +252,41 @@ void ASTUnionType::EmitCppReadVar(const String& parcelName, const String& name, void ASTUnionType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUnpadBuffer(data, (const uint8_t *)&%s, sizeof(%s))) {\n", - name.string(), EmitCType().string()); - sb.Append(prefix + TAB).AppendFormat( + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix).AppendFormat("if (!HdfSbufWriteBuffer(data, (const void *)&%s, sizeof(%s))) {\n", + name.string(), EmitCType().string()); + } else { + sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUnpadBuffer(data, (const uint8_t *)&%s, sizeof(%s))) {\n", + name.string(), EmitCType().string()); + } + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } void ASTUnionType::EmitCUnMarshalling(const String& name, StringBuilder& sb, const String& prefix, std::vector& freeObjStatements) const { - sb.Append(prefix).AppendFormat("const %s *%s = (const %s *)HdfSbufReadUnpadBuffer(data, sizeof(%s));\n", - EmitCType().string(), name.string(), EmitCType().string(), EmitCType().string()); - sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(prefix).AppendFormat("%s *%s = NULL;\n", EmitCType().string(), name.string()); + sb.Append(prefix).Append("uint32_t len = 0;\n"); + sb.Append(prefix).AppendFormat("if (!HdfSbufReadBuffer(data, (const void **)&%s, &len)) {\n", name.string()); + sb.Append(prefix + g_tab).AppendFormat( + "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); + sb.Append(prefix + g_tab).Append("goto errors;\n"); + sb.Append(prefix).Append("}\n\n"); + sb.Append(prefix).AppendFormat("if (%s == NULL || sizeof(%s) != len) {\n", + name.string(), EmitCType().string()); + } else { + sb.Append(prefix).AppendFormat("const %s *%s = (const %s *)HdfSbufReadUnpadBuffer(data, sizeof(%s));\n", + EmitCType().string(), name.string(), EmitCType().string(), EmitCType().string()); + sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", name.string()); + } + + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -253,9 +295,9 @@ void ASTUnionType::EmitCppMarshalling(const String& parcelName, const String& na { sb.Append(prefix).AppendFormat("if (!%s.WriteUnpadBuffer((const void*)&%s, sizeof(%s))) {\n", parcelName.string(), name.string(), EmitCppType().string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -267,10 +309,22 @@ void ASTUnionType::EmitCppUnMarshalling(const String& parcelName, const String& EmitCppType().string(), name.string(), EmitCppType().string(), parcelName.string(), EmitCppType().string()); sb.Append(prefix).AppendFormat("if (%s == nullptr) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } + +void ASTUnionType::EmitMemoryRecycle(const String& name, bool isClient, bool ownership, StringBuilder& sb, + const String& prefix) const +{ + if (ownership) { + String varName = isClient ? String::Format("*%s", name.string()) : name; + sb.Append(prefix).AppendFormat("if (%s != NULL) {\n", varName.string()); + sb.Append(prefix + g_tab).AppendFormat("OsalMemFree(%s);\n", varName.string()); + sb.Append(prefix + g_tab).AppendFormat("%s = NULL;\n", varName.string()); + sb.Append(prefix).Append("}\n"); + } +} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/ast/ast_union_type.h b/tools/hdi-gen/ast/ast_union_type.h index 4d494896a37c3c125e33f1a32b8e7669ba56b3d1..951e08ba1c5c2398e50383603bbb80f95cf208d3 100755 --- a/tools/hdi-gen/ast/ast_union_type.h +++ b/tools/hdi-gen/ast/ast_union_type.h @@ -92,12 +92,9 @@ public: String EmitJavaTypeDecl() const; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; @@ -120,6 +117,9 @@ public: void EmitCppUnMarshalling(const String& parcelName, const String& name, StringBuilder& sb, const String& prefix, bool emitType, unsigned int innerLevel = 0) const override; + + void EmitMemoryRecycle(const String& name, bool isClient, bool ownership, StringBuilder& sb, + const String& prefix) const override; private: bool isFull_ = false; bool isLite_ = false; diff --git a/tools/hdi-gen/ast/ast_ushort_type.cpp b/tools/hdi-gen/ast/ast_ushort_type.cpp index 5e81653c64847ac449c6dc9c106b86e78eaa72c1..57e2c76ecdb238a7e53ef32af0d035a08b34fefe 100755 --- a/tools/hdi-gen/ast/ast_ushort_type.cpp +++ b/tools/hdi-gen/ast/ast_ushort_type.cpp @@ -63,27 +63,15 @@ String ASTUshortType::EmitJavaType(TypeMode mode, bool isInnerType) const return "/"; } -void ASTUshortType::EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, +void ASTUshortType::EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint16(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); - sb.Append(prefix).Append("}\n"); -} - -void ASTUshortType::EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const -{ - sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint16(%s, %s)) {\n", - parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -91,10 +79,10 @@ void ASTUshortType::EmitCProxyReadVar(const String& parcelName, const String& na const String& gotoLabel, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint16(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); } @@ -102,10 +90,10 @@ void ASTUshortType::EmitCStubReadVar(const String& parcelName, const String& nam const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint16(%s, %s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -113,9 +101,9 @@ void ASTUshortType::EmitCppWriteVar(const String& parcelName, const String& name const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteUint16(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); sb.Append(prefix).Append("}\n"); } @@ -133,9 +121,9 @@ void ASTUshortType::EmitCppReadVar(const String& parcelName, const String& name, void ASTUshortType::EmitCMarshalling(const String& name, StringBuilder& sb, const String& prefix) const { sb.Append(prefix).AppendFormat("if (!HdfSbufWriteUint16(data, %s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } @@ -143,10 +131,10 @@ void ASTUshortType::EmitCUnMarshalling(const String& name, StringBuilder& sb, co std::vector& freeObjStatements) const { sb.Append(prefix).AppendFormat("if (!HdfSbufReadUint16(data, &%s)) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", name.string()); - EmitFreeStatements(freeObjStatements, sb, prefix + TAB); - sb.Append(prefix + TAB).Append("goto errors;\n"); + EmitFreeStatements(freeObjStatements, sb, prefix + g_tab); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); } @@ -154,9 +142,9 @@ void ASTUshortType::EmitCppMarshalling(const String& parcelName, const String& n const String& prefix, unsigned int innerLevel) const { sb.Append(prefix).AppendFormat("if (!%s.WriteUint16(%s)) {\n", parcelName.string(), name.string()); - sb.Append(prefix + TAB).AppendFormat( + sb.Append(prefix + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: write %s failed!\", __func__);\n", name.string()); - sb.Append(prefix + TAB).Append("return false;\n"); + sb.Append(prefix + g_tab).Append("return false;\n"); sb.Append(prefix).Append("}\n"); } diff --git a/tools/hdi-gen/ast/ast_ushort_type.h b/tools/hdi-gen/ast/ast_ushort_type.h index 08489189fd67abcf651fcd6fe92f9c25492e2dbe..3ba7204a5b2f60ad5a007932f61f2595b02a8175 100755 --- a/tools/hdi-gen/ast/ast_ushort_type.h +++ b/tools/hdi-gen/ast/ast_ushort_type.h @@ -27,12 +27,9 @@ public: String EmitJavaType(TypeMode mode, bool isInnerType = false) const override; - void EmitCProxyWriteVar(const String& parcelName, const String& name, const String& gotoLabel, + void EmitCWriteVar(const String& parcelName, const String& name, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; - void EmitCStubWriteVar(const String& parcelName, const String& name, StringBuilder& sb, - const String& prefix) const override; - void EmitCProxyReadVar(const String& parcelName, const String& name, bool isInnerType, const String& gotoLabel, StringBuilder& sb, const String& prefix) const override; diff --git a/tools/hdi-gen/build_hdi_files.py b/tools/hdi-gen/build_hdi_files.py new file mode 100755 index 0000000000000000000000000000000000000000..640136b957d471b7356f168badd01f1961740366 --- /dev/null +++ b/tools/hdi-gen/build_hdi_files.py @@ -0,0 +1,304 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- + +# +# Copyright (c) 2021, Huawei Device Co., Ltd. All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions +# are met: +# +# * Redistributions of source code must retain the above copyright +# notice, this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above +# copyright notice, this list of conditions and the following +# disclaimer in the documentation and/or other materials provided +# with the distribution. +# * Neither the name of Willow Garage, Inc. nor the names of its +# contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# 'AS IS' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +# FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +# COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +# INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +# BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +# CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +# POSSIBILITY OF SUCH DAMAGE. + +import os +import sys + +class IdlType: + INTERFACE = 1 + CALLBACK = 2 + TYPES = 3 + +def translate_file_name(file_name): + name = file_name[1:] if file_name.startswith("I") else file_name + translate_name = "" + for i in range(len(name)): + c = name[i] + if c >= 'A' and c <= 'Z': + if i > 1: + translate_name += "_" + translate_name += c.lower() + else: + translate_name += c + return translate_name + + +def get_idl_file_type(file_path): + idl_type = IdlType.TYPES + file = open(file_path, "r") + for file_line in file.readlines(): + interface_index = file_line.find("interface") + if interface_index != -1: + if file_line.find("[callback]", 0, interface_index) != -1: + idl_type = IdlType.CALLBACK + else: + idl_type = IdlType.INTERFACE + break + else: + continue + file.close() + return idl_type + + +def c_interface_file_translate(idl_file, out_dir, part, outputs): + file = idl_file.split("/")[-1] + file_name = translate_file_name(file.split(".")[0]) + + iface_header_file = os.path.join(out_dir, "i" + file_name + ".h") + client_proxy_source_file = os.path.join(out_dir, file_name + "_proxy.c") + server_driver_source_file = os.path.join(out_dir, file_name + "_driver.c") + server_stub_header_file = os.path.join(out_dir, file_name + "_stub.h") + server_stub_source_file = os.path.join(out_dir, file_name + "_stub.c") + server_impl_header_file = os.path.join(out_dir, file_name + "_service.h") + server_impl_source_file = os.path.join(out_dir, file_name + "_service.c") + + if part == "client_lib_source": + outputs.append(iface_header_file) + outputs.append(client_proxy_source_file) + elif part == "server_lib_source": + outputs.append(iface_header_file) + outputs.append(server_stub_header_file) + outputs.append(server_stub_source_file) + else: + outputs.append(iface_header_file) + outputs.append(client_proxy_source_file) + outputs.append(server_driver_source_file) + outputs.append(server_stub_header_file) + outputs.append(server_stub_source_file) + outputs.append(server_impl_header_file) + outputs.append(server_impl_source_file) + + +def c_callback_file_translate(idl_file, out_dir, part, outputs): + file = idl_file.split("/")[-1] + file_name = translate_file_name(file.split(".")[0]) + + iface_header_file = os.path.join(out_dir, "i" + file_name + ".h") + client_proxy_source_file = os.path.join(out_dir, file_name + "_proxy.c") + server_stub_header_file = os.path.join(out_dir, file_name + "_stub.h") + server_stub_source_file = os.path.join(out_dir, file_name + "_stub.c") + server_impl_header_file = os.path.join(out_dir, file_name + "_service.h") + server_impl_source_file = os.path.join(out_dir, file_name + "_service.c") + + if part == "client_lib_source": + outputs.append(iface_header_file) + outputs.append(server_stub_header_file) + outputs.append(server_stub_source_file) + elif part == "server_lib_source": + outputs.append(iface_header_file) + outputs.append(client_proxy_source_file) + else: + outputs.append(iface_header_file) + outputs.append(client_proxy_source_file) + outputs.append(server_stub_header_file) + outputs.append(server_stub_source_file) + outputs.append(server_impl_header_file) + outputs.append(server_impl_source_file) + + +def c_types_file_translate(idl_file, out_dir, outputs): + file = idl_file.split("/")[-1] + file_name = translate_file_name(file.split(".")[0]) + + types_header_file = os.path.join(out_dir, file_name + ".h") + types_source_file = os.path.join(out_dir, file_name + ".c") + + outputs.append(types_header_file) + outputs.append(types_source_file) + + +def c_idl_translate(idl_files, out_dir): + outputs = [] + for idl_file in idl_files: + idl_file_type = get_idl_file_type(idl_file) + if idl_file_type == IdlType.INTERFACE: + c_interface_file_translate(idl_file, out_dir, "all", outputs) + elif idl_file_type == IdlType.CALLBACK: + c_callback_file_translate(idl_file, out_dir, "all", outputs) + elif idl_file_type == IdlType.TYPES: + c_types_file_translate(idl_file, out_dir, outputs) + return outputs + + +def cpp_interface_file_translate(idl_file, out_dir, part, outputs): + file = idl_file.split("/")[-1] + file_name = translate_file_name(file.split(".")[0]) + + iface_header_file = os.path.join(out_dir, "i" + file_name + ".h") + client_proxy_header_file = os.path.join(out_dir, file_name + "_proxy.h") + client_proxy_source_file = os.path.join(out_dir, file_name + "_proxy.cpp") + server_driver_source_file = os.path.join(out_dir, file_name + "_driver.cpp") + server_stub_header_file = os.path.join(out_dir, file_name + "_stub.h") + server_stub_source_file = os.path.join(out_dir, file_name + "_stub.cpp") + server_impl_header_file = os.path.join(out_dir, file_name + "_service.h") + server_impl_source_file = os.path.join(out_dir, file_name + "_service.cpp") + + if part == "client_lib_source": + outputs.append(iface_header_file) + outputs.append(client_proxy_header_file) + outputs.append(client_proxy_source_file) + elif part == "server_lib_source": + outputs.append(iface_header_file) + outputs.append(server_stub_header_file) + outputs.append(server_stub_source_file) + else: + outputs.append(iface_header_file) + outputs.append(client_proxy_header_file) + outputs.append(client_proxy_source_file) + outputs.append(server_driver_source_file) + outputs.append(server_stub_header_file) + outputs.append(server_stub_source_file) + outputs.append(server_impl_header_file) + outputs.append(server_impl_source_file) + + +def cpp_callback_file_translate(idl_file, out_dir, part, outputs): + file = idl_file.split("/")[-1] + file_name = translate_file_name(file.split(".")[0]) + + iface_header_file = os.path.join(out_dir, "i" + file_name + ".h") + client_proxy_header_file = os.path.join(out_dir, file_name + "_proxy.h") + client_proxy_source_file = os.path.join(out_dir, file_name + "_proxy.cpp") + server_stub_header_file = os.path.join(out_dir, file_name + "_stub.h") + server_stub_source_file = os.path.join(out_dir, file_name + "_stub.cpp") + server_impl_header_file = os.path.join(out_dir, file_name + "_service.h") + server_impl_source_file = os.path.join(out_dir, file_name + "_service.cpp") + + if part == "client_lib_source": + outputs.append(iface_header_file) + outputs.append(server_stub_header_file) + outputs.append(server_stub_source_file) + elif part == "server_lib_source": + outputs.append(iface_header_file) + outputs.append(client_proxy_header_file) + outputs.append(client_proxy_source_file) + else: + outputs.append(iface_header_file) + outputs.append(client_proxy_header_file) + outputs.append(client_proxy_source_file) + outputs.append(server_stub_header_file) + outputs.append(server_stub_source_file) + outputs.append(server_impl_header_file) + outputs.append(server_impl_source_file) + + +def cpp_types_file_translate(idl_file, out_dir, outputs): + file = idl_file.split("/")[-1] + file_name = translate_file_name(file.split(".")[0]) + + types_header_file = os.path.join(out_dir, file_name + ".h") + types_source_file = os.path.join(out_dir, file_name + ".cpp") + + outputs.append(types_header_file) + outputs.append(types_source_file) + + +def cpp_idl_translate(idl_files, out_dir): + outputs = [] + for idl_file in idl_files: + idl_file_type = get_idl_file_type(idl_file) + if idl_file_type == IdlType.INTERFACE: + cpp_interface_file_translate(idl_file, out_dir, "all", outputs) + elif idl_file_type == IdlType.CALLBACK: + cpp_callback_file_translate(idl_file, out_dir, "all", outputs) + elif idl_file_type == IdlType.TYPES: + cpp_types_file_translate(idl_file, out_dir, outputs) + return outputs + + +def idl_translate(idl_files, language, out_dir): + outputs = [] + if language == "c": + outputs = c_idl_translate(idl_files, out_dir) + elif language == "cpp": + outputs = cpp_idl_translate(idl_files, out_dir) + return outputs + + +def c_get_compile_source_file(idl_files, out_dir, part): + outputs = [] + for idl_file in idl_files: + idl_file_type = get_idl_file_type(idl_file) + if idl_file_type == IdlType.INTERFACE: + c_interface_file_translate(idl_file, out_dir, part, outputs) + elif idl_file_type == IdlType.CALLBACK: + c_callback_file_translate(idl_file, out_dir, part, outputs) + elif idl_file_type == IdlType.TYPES: + c_types_file_translate(idl_file, out_dir, outputs) + return outputs + + +def cpp_get_compile_source_file(idl_files, out_dir, part): + outputs = [] + for idl_file in idl_files: + idl_file_type = get_idl_file_type(idl_file) + if idl_file_type == IdlType.INTERFACE: + cpp_interface_file_translate(idl_file, out_dir, part, outputs) + elif idl_file_type == IdlType.CALLBACK: + cpp_callback_file_translate(idl_file, out_dir, part, outputs) + elif idl_file_type == IdlType.TYPES: + cpp_types_file_translate(idl_file, out_dir, outputs) + return outputs + + +def get_compile_source_file(idl_files, language, out_dir, part): + outputs = [] + if language == "c": + outputs = c_get_compile_source_file(idl_files, out_dir, part) + elif language == "cpp": + outputs = cpp_get_compile_source_file(idl_files, out_dir, part) + return outputs + + +def main(argv): + outputs = [] + if len(argv) < 4: + return outputs + + option = argv[1] + language = argv[2] + out_dir = argv[3] + files = argv[4:] + + if option == "-o": + outputs = idl_translate(files, language, out_dir) + elif option == "-c": + outputs = get_compile_source_file(argv[4:], language, out_dir, "client_lib_source") + elif option == "-s": + outputs = get_compile_source_file(argv[4:], language, out_dir, "server_lib_source") + + sys.stdout.write('\n'.join(outputs)) + + +if __name__ == "__main__": + main(sys.argv) \ No newline at end of file diff --git a/tools/hdi-gen/codegen/Makefile b/tools/hdi-gen/codegen/Makefile deleted file mode 100755 index 64ac5af8dfd3918ca8fba0f2b0b88ef9eca2746a..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/codegen/Makefile +++ /dev/null @@ -1,12 +0,0 @@ -OBJS_DIR:=$(BUILD_DIR)/codegen -TARGET = $(OBJS_DIR)/codegen.a -SOURCE:=$(wildcard *.cpp) -OBJS:=$(patsubst %.cpp, $(OBJS_DIR)/%.o, $(SOURCE)) - -$(TARGET):$(OBJS) - $(Q) echo $(TARGET) - $(Q) ar -rc $@ $^ - -$(OBJS_DIR)/%.o:%.cpp - $(Q) mkdir -p $(dir $@) - $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ \ No newline at end of file diff --git a/tools/hdi-gen/codegen/c_client_interface_code_emitter.cpp b/tools/hdi-gen/codegen/c_client_interface_code_emitter.cpp deleted file mode 100755 index 75aec71e4f1e1728c34013d964b020c878e195fa..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/codegen/c_client_interface_code_emitter.cpp +++ /dev/null @@ -1,141 +0,0 @@ -/* - * Copyright (c) 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 "codegen/c_client_interface_code_emitter.h" -#include "util/file.h" -#include "util/logger.h" - -namespace OHOS { -namespace HDI { -void CClientInterfaceCodeEmitter::EmitCode() -{ - EmitInterfaceHeaderFile(); -} - -void CClientInterfaceCodeEmitter::EmitInterfaceHeaderFile() -{ - String filePath; - if (!isCallbackInterface()) { - filePath = String::Format("%sclient/%s.h", directory_.string(), FileName(interfaceName_).string()); - } else { - filePath = String::Format("%s%s.h", directory_.string(), FileName(interfaceName_).string()); - } - - if (!File::CreateParentDir(filePath)) { - Logger::E("CClientInterfaceCodeEmitter", "Create '%s' failed!", filePath.string()); - return; - } - - File file(filePath, File::WRITE); - - StringBuilder sb; - - EmitLicense(sb); - EmitHeadMacro(sb, interfaceFullName_); - sb.Append("\n"); - EmitImportInclusions(sb); - sb.Append("\n"); - EmitHeadExternC(sb); - sb.Append("\n"); - EmitForwardDecls(sb); - sb.Append("\n"); - EmitInterfaceMethodCommands(sb); - sb.Append("\n"); - EmitInterfaceDecl(sb); - sb.Append("\n"); - EmitTailExternC(sb); - sb.Append("\n"); - EmitTailMacro(sb, interfaceFullName_); - - String data = sb.ToString(); - file.WriteData(data.string(), data.GetLength()); - file.Flush(); - file.Close(); -} - -void CClientInterfaceCodeEmitter::EmitImportInclusions(StringBuilder& sb) -{ - sb.Append("#include \n"); - for (const auto& importPair : ast_->GetImports()) { - AutoPtr importAst = importPair.second; - - String fileName; - if (importAst->GetASTFileType() == ASTFileType::AST_ICALLBACK && importAst->GetInterfaceDef() != nullptr) { - String ifaceName = importAst->GetInterfaceDef()->GetName(); - String name = ifaceName.StartsWith("I") ? ifaceName.Substring(1) : ifaceName; - String stubName = name + "Stub"; - fileName = FileName(importAst->GetInterfaceDef()->GetNamespace()->ToString() + stubName); - } else { - fileName = FileName(importAst->GetFullName()); - } - sb.Append("#include ").AppendFormat("\"%s.h\"\n", fileName.string()); - } -} - -void CClientInterfaceCodeEmitter::EmitForwardDecls(StringBuilder& sb) -{ - sb.Append("struct HdfRemoteService;\n"); -} - -void CClientInterfaceCodeEmitter::EmitInterfaceDecl(StringBuilder& sb) -{ - sb.AppendFormat("struct %s {\n", interfaceName_.string()); - sb.Append(TAB).Append("struct HdfRemoteService *remote;\n"); - sb.Append("\n"); - EmitInterfaceMethodsDecl(sb, TAB); - sb.Append("};\n"); - if (!isCallbackInterface()) { - sb.Append("\n"); - EmitInterfaceInstanceMethod(sb); - } -} - -void CClientInterfaceCodeEmitter::EmitInterfaceMethodsDecl(StringBuilder& sb, const String& prefix) -{ - for (size_t i = 0; i < interface_->GetMethodNumber(); i++) { - AutoPtr method = interface_->GetMethod(i); - EmitInterfaceMethodDecl(method, sb, prefix); - if (i + 1 < interface_->GetMethodNumber()) { - sb.Append("\n"); - } - } -} - -void CClientInterfaceCodeEmitter::EmitInterfaceMethodDecl(const AutoPtr& method, StringBuilder& sb, - const String& prefix) -{ - if (method->GetParameterNumber() == 0) { - sb.Append(prefix).AppendFormat("int32_t (*%s)(struct %s *self);\n", - method->GetName().string(), interfaceName_.string()); - } else { - StringBuilder paramStr; - paramStr.Append(prefix).AppendFormat("int32_t (*%s)(", method->GetName().string()); - paramStr.AppendFormat("struct %s *self, ", interfaceName_.string()); - - for (size_t i = 0; i < method->GetParameterNumber(); i++) { - AutoPtr param = method->GetParameter(i); - EmitInterfaceMethodParameter(param, paramStr, ""); - if (i + 1 < method->GetParameterNumber()) { - paramStr.Append(", "); - } - } - - paramStr.Append(");"); - sb.Append(SpecificationParam(paramStr, prefix + TAB)); - sb.Append("\n"); - } -} - -void CClientInterfaceCodeEmitter::EmitInterfaceInstanceMethod(StringBuilder& sb) -{ - sb.AppendFormat("struct %s *Hdi%sGet();\n", interfaceName_.string(), infName_.string()); - sb.Append("\n"); - sb.AppendFormat("void Hdi%sRelease(struct %s *instance);\n", infName_.string(), interfaceName_.string()); -} -} // namespace HDI -} // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/codegen/c_client_interface_code_emitter.h b/tools/hdi-gen/codegen/c_client_interface_code_emitter.h deleted file mode 100755 index edf0b2068b835f64c61ae1554e2c2a9b1b7886ef..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/codegen/c_client_interface_code_emitter.h +++ /dev/null @@ -1,42 +0,0 @@ -/* - * Copyright (c) 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 OHOS_HDI_C_CLIENT_INTERFACE_CODE_EMITTER_H -#define OHOS_HDI_C_CLIENT_INTERFACE_CODE_EMITTER_H - -#include "codegen/c_code_emitter.h" - -namespace OHOS { -namespace HDI { -class CClientInterfaceCodeEmitter : public CCodeEmitter { -public: - CClientInterfaceCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - : CCodeEmitter(ast, targetDirectory) {} - - virtual ~CClientInterfaceCodeEmitter() = default; - - void EmitCode() override; -private: - void EmitInterfaceHeaderFile(); - - void EmitImportInclusions(StringBuilder& sb); - - void EmitForwardDecls(StringBuilder& sb); - - void EmitInterfaceDecl(StringBuilder& sb); - - void EmitInterfaceMethodsDecl(StringBuilder& sb, const String& prefix); - - void EmitInterfaceMethodDecl(const AutoPtr& method, StringBuilder& sb, const String& prefix); - - void EmitInterfaceInstanceMethod(StringBuilder& sb); -}; -} // namespace HDI -} // namespace OHOS - -#endif // OHOS_HDI_C_CLIENT_INTERFACE_CODE_EMITTER_H diff --git a/tools/hdi-gen/codegen/c_client_proxy_code_emitter.cpp b/tools/hdi-gen/codegen/c_client_proxy_code_emitter.cpp index 157ddc698659310c6f25d171cea5ced17e27cde3..d325f6a554dd7eb0a14a44e6297826010266a780 100755 --- a/tools/hdi-gen/codegen/c_client_proxy_code_emitter.cpp +++ b/tools/hdi-gen/codegen/c_client_proxy_code_emitter.cpp @@ -12,83 +12,39 @@ namespace OHOS { namespace HDI { -CClientProxyCodeEmitter::CClientProxyCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - :CCodeEmitter(ast, targetDirectory) +bool CClientProxyCodeEmitter::ResolveDirectory(const String& targetDirectory) { - String infFullName = String::Format("%sclient.%s", - interface_->GetNamespace()->ToString().string(), infName_.string()); - sourceFileName_ = String::Format("%s_proxy.c", FileName(infFullName).string()); -} - -void CClientProxyCodeEmitter::EmitCode() -{ - if (isCallbackInterface()) { - EmitCbProxyHeaderFile(); + if (ast_->GetASTFileType() == ASTFileType::AST_IFACE || + ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) { + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); + } else { + return false; } - EmitProxySourceFile(); -} -void CClientProxyCodeEmitter::EmitCbProxyHeaderFile() -{ - String filePath = String::Format("%s%s.h", directory_.string(), FileName(proxyName_).string()); - if (!File::CreateParentDir(filePath)) { - Logger::E("CClientProxyCodeEmitter", "Create '%s' failed!", filePath.string()); - return; + if (!File::CreateParentDir(directory_)) { + Logger::E("CClientProxyCodeEmitter", "Create '%s' failed!", directory_.string()); + return false; } - File file(filePath, File::WRITE); - - StringBuilder sb; - - EmitLicense(sb); - EmitHeadMacro(sb, proxyFullName_); - sb.Append("\n"); - sb.AppendFormat("#include \"%s.h\"\n", FileName(interfaceName_).string()); - sb.Append("\n"); - EmitHeadExternC(sb); - sb.Append("\n"); - EmitCbProxyMethodsDcl(sb); - sb.Append("\n"); - EmitTailExternC(sb); - sb.Append("\n"); - EmitTailMacro(sb, proxyFullName_); - - String data = sb.ToString(); - file.WriteData(data.string(), data.GetLength()); - file.Flush(); - file.Close(); + return true; } -void CClientProxyCodeEmitter::EmitCbProxyMethodsDcl(StringBuilder& sb) +void CClientProxyCodeEmitter::EmitCode() { - sb.AppendFormat("struct %s *%sProxyObtain(struct HdfRemoteService *remote);\n", - interfaceName_.string(), infName_.string()); - sb.Append("\n"); - sb.AppendFormat("void %sProxyRelease(struct %s *callback);\n", infName_.string(), interfaceName_.string()); + EmitProxySourceFile(); } void CClientProxyCodeEmitter::EmitProxySourceFile() { - String filePath; - if (!isCallbackInterface()) { - filePath = String::Format("%sclient/%s.c", directory_.string(), FileName(proxyName_).string()); - } else { - filePath = String::Format("%s%s.c", directory_.string(), FileName(proxyName_).string()); - } - - if (!File::CreateParentDir(filePath)) { - Logger::E("CClientProxyCodeEmitter", "Create '%s' failed!", filePath.string()); - return; - } - + String filePath = String::Format("%s%s.c", directory_.string(), FileName(proxyName_).string()); File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); EmitProxyInclusions(sb); sb.Append("\n"); - EmitHeadExternC(sb); + EmitProxyDefinition(sb); sb.Append("\n"); EmitProxyCallMethodImpl(sb); sb.Append("\n"); @@ -99,17 +55,22 @@ void CClientProxyCodeEmitter::EmitProxySourceFile() sb.Append("\n"); EmitProxyGetMethodImpl(sb); sb.Append("\n"); - EmitProxyReleaseMethodImpl(sb); + if (isKernelCode_) { + EmitKernelProxyGetInstanceMethodImpl(sb); + sb.Append("\n"); + EmitKernelProxyReleaseMethodImpl(sb); + } else { + EmitProxyGetInstanceMethodImpl(sb); + sb.Append("\n"); + EmitProxyReleaseMethodImpl(sb); + } } else { sb.Append("\n"); - EmitCbProxyObtainMethodImpl(sb); + EmitCbProxyGetMethodImpl(sb); sb.Append("\n"); - EmitCbProxyReleaseMethodImpl(sb); + EmitProxyReleaseMethodImpl(sb); } - sb.Append("\n"); - EmitTailExternC(sb); - String data = sb.ToString(); file.WriteData(data.string(), data.GetLength()); file.Flush(); @@ -118,46 +79,86 @@ void CClientProxyCodeEmitter::EmitProxySourceFile() void CClientProxyCodeEmitter::EmitProxyInclusions(StringBuilder& sb) { - if (!isCallbackInterface()) { - EmitProxyStdlibInclusions(sb); - sb.AppendFormat("#include \"%s.h\"\n", FileName(interfaceName_).string()); - } else { - sb.AppendFormat("#include \"%s.h\"\n", FileName(proxyName_).string()); - EmitProxyStdlibInclusions(sb); + HeaderFile::HeaderFileSet headerFiles; + + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_MODULE_HEADER_FILE, FileName(interfaceName_))); + GetHeaderOtherLibInclusions(headerFiles); + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); } } -void CClientProxyCodeEmitter::EmitProxyStdlibInclusions(StringBuilder& sb) +void CClientProxyCodeEmitter::GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles) { - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.Append("#include \n"); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_base")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_log")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_sbuf")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "osal_mem")); + + if (isKernelCode_) { + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_io_service_if")); + } else { + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "servmgr_hdi")); + if (!isCallbackInterface()) { + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_dlist")); + } + } const AST::TypeStringMap& types = ast_->GetTypes(); for (const auto& pair : types) { AutoPtr type = pair.second; if (type->GetTypeKind() == TypeKind::TYPE_UNION) { - sb.Append("#include \n"); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "securec")); break; } } } +void CClientProxyCodeEmitter::EmitProxyDefinition(StringBuilder& sb) +{ + sb.AppendFormat("struct %sProxy {\n", infName_.string()); + sb.Append(g_tab).AppendFormat("struct %s instance;\n", interfaceName_.string()); + if (isKernelCode_) { + sb.Append(g_tab).Append("struct HdfIoService *serv;\n"); + } else { + sb.Append(g_tab).Append("struct HdfRemoteService *remote;\n"); + } + + sb.Append("};\n"); +} + void CClientProxyCodeEmitter::EmitProxyCallMethodImpl(StringBuilder& sb) { sb.AppendFormat("static int32_t %sProxyCall(struct %s *self, int32_t id, struct HdfSBuf *data,\n", infName_.string(), interfaceName_.string()); - sb.Append(TAB).Append("struct HdfSBuf *reply)\n"); + sb.Append(g_tab).Append("struct HdfSBuf *reply)\n"); sb.Append("{\n"); - sb.Append(TAB).Append("if (self->remote == NULL\n"); - sb.Append(TAB).Append(TAB).Append("|| self->remote->dispatcher == NULL\n"); - sb.Append(TAB).Append(TAB).Append("|| self->remote->dispatcher->Dispatch == NULL) {\n"); - sb.Append(TAB).Append(TAB).Append("HDF_LOGE(\"%{public}s: obj is null\", __func__);\n"); - sb.Append(TAB).Append(TAB).Append("return HDF_ERR_INVALID_OBJECT;\n"); - sb.Append(TAB).Append("}\n"); - sb.Append(TAB).Append("return self->remote->dispatcher->Dispatch(self->remote, id, data, reply);\n"); + + String proxyName = "self"; + if (!isCallbackInterface()) { + sb.Append(g_tab).AppendFormat("struct %sProxy *proxy = CONTAINER_OF(self, struct %sProxy, instance);\n", + infName_.string(), infName_.string()); + proxyName = "proxy"; + } + + String remoteName = isKernelCode_ ? "serv" : "remote"; + sb.Append(g_tab).AppendFormat("if (%s->%s == NULL\n", proxyName.string(), remoteName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("|| %s->%s->dispatcher == NULL\n", + proxyName.string(), remoteName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("|| %s->%s->dispatcher->Dispatch == NULL) {\n", + proxyName.string(), remoteName.string()); + sb.Append(g_tab).Append(g_tab).Append("HDF_LOGE(\"%{public}s: obj is null\", __func__);\n"); + sb.Append(g_tab).Append(g_tab).Append("return HDF_ERR_INVALID_OBJECT;\n"); + sb.Append(g_tab).Append("}\n"); + + if (isKernelCode_) { + sb.Append(g_tab).AppendFormat("return %s->serv->dispatcher->Dispatch", proxyName.string()); + sb.AppendFormat("((struct HdfObject *)&(%s->serv->object), id, data, reply);\n", proxyName.string()); + } else { + sb.Append(g_tab).AppendFormat("return %s->remote->dispatcher->Dispatch(%s->remote, id, data, reply);\n", + proxyName.string(), proxyName.string()); + } sb.Append("}\n"); } @@ -190,7 +191,7 @@ void CClientProxyCodeEmitter::EmitProxyMethodImpl(const AutoPtr& meth } paramStr.Append(")"); - sb.Append(SpecificationParam(paramStr, TAB)); + sb.Append(SpecificationParam(paramStr, g_tab)); sb.Append("\n"); } EmitProxyMethodBody(method, sb, ""); @@ -199,66 +200,90 @@ void CClientProxyCodeEmitter::EmitProxyMethodImpl(const AutoPtr& meth void CClientProxyCodeEmitter::EmitProxyMethodBody(const AutoPtr& method, StringBuilder& sb, const String& prefix) { + String dataName = "data_"; + String replyName = "reply_"; sb.Append(prefix).Append("{\n"); - sb.Append(prefix + TAB).Append("int32_t ec = HDF_FAILURE;\n"); - sb.Append("\n"); + sb.Append(prefix + g_tab).Append("int32_t ec = HDF_FAILURE;\n"); - sb.Append(prefix + TAB).Append("struct HdfSBuf *data = HdfSBufTypedObtain(SBUF_IPC);\n"); - sb.Append(prefix + TAB).Append("struct HdfSBuf *reply = HdfSBufTypedObtain(SBUF_IPC);\n"); - sb.Append("\n"); + // Local variable definitions must precede all execution statements. + if (isKernelCode_) { + for (size_t i = 0; i < method->GetParameterNumber(); i++) { + AutoPtr param = method->GetParameter(i); + AutoPtr type = param->GetType(); + if (type->GetTypeKind() == TypeKind::TYPE_ARRAY || + type->GetTypeKind() == TypeKind::TYPE_LIST) { + sb.Append(prefix + g_tab).Append("uint32_t i = 0;\n"); + break; + } + } + } - sb.Append(prefix + TAB).Append("if (data == NULL || reply == NULL) {\n"); - sb.Append(prefix + TAB + TAB).Append("HDF_LOGE(\"%{public}s: HdfSubf malloc failed!\", __func__);\n"); - sb.Append(prefix + TAB + TAB).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); - sb.Append(prefix + TAB + TAB).Append("goto finished;\n"); - sb.Append(prefix + TAB).Append("}\n"); + sb.Append("\n"); + EmitCreateBuf(dataName, replyName, sb, prefix + g_tab); sb.Append("\n"); String gotoName = GetGotLabel(method); - for (size_t i = 0; i < method->GetParameterNumber(); i++) { AutoPtr param = method->GetParameter(i); if (param->GetAttribute() == ParamAttr::PARAM_IN) { - EmitWriteProxyMethodParameter(param, "data", gotoName, sb, prefix + TAB); + param->EmitCWriteVar(dataName, gotoName, sb, prefix + g_tab); sb.Append("\n"); } } - sb.Append(prefix + TAB).AppendFormat("ec = %sCall(self, CMD_%s, data, reply);\n", - proxyName_.string(), ConstantName(method->GetName()).string()); - sb.Append(prefix + TAB).Append("if (ec != HDF_SUCCESS) {\n"); - sb.Append(prefix + TAB + TAB).Append( + sb.Append(prefix + g_tab).AppendFormat("ec = %sCall(self, CMD_%s, %s, %s);\n", + proxyName_.string(), ConstantName(method->GetName()).string(), dataName.string(), replyName.string()); + sb.Append(prefix + g_tab).Append("if (ec != HDF_SUCCESS) {\n"); + sb.Append(prefix + g_tab + g_tab).Append( "HDF_LOGE(\"%{public}s: call failed! error code is %{public}d\", __func__, ec);\n"); - sb.Append(prefix + TAB + TAB).AppendFormat("goto %s;\n", gotoName.string()); - sb.Append(prefix + TAB).Append("}\n"); + sb.Append(prefix + g_tab + g_tab).AppendFormat("goto %s;\n", gotoName.string()); + sb.Append(prefix + g_tab).Append("}\n"); sb.Append("\n"); for (size_t i = 0; i < method->GetParameterNumber(); i++) { AutoPtr param = method->GetParameter(i); if (param->GetAttribute() == ParamAttr::PARAM_OUT) { - EmitReadProxyMethodParameter(param, "reply", gotoName, sb, prefix + TAB); + EmitReadProxyMethodParameter(param, replyName, gotoName, sb, prefix + g_tab); sb.Append("\n"); } } - EmitErrorHandle(method, sb, prefix); - + EmitErrorHandle(method, "errors", true, sb, prefix); sb.Append(prefix).Append("finished:\n"); - sb.Append(prefix + TAB).Append("if (data != NULL) {\n"); - sb.Append(prefix + TAB + TAB).Append("HdfSBufRecycle(data);\n"); - sb.Append(prefix + TAB).Append("}\n"); - sb.Append(prefix + TAB).Append("if (reply != NULL) {\n"); - sb.Append(prefix + TAB + TAB).Append("HdfSBufRecycle(reply);\n"); - sb.Append(prefix + TAB).Append("}\n"); - sb.Append(prefix + TAB).Append("return ec;\n"); + EmitReleaseBuf(dataName, replyName, sb, prefix + g_tab); + + sb.Append(prefix + g_tab).Append("return ec;\n"); sb.Append("}\n"); } -void CClientProxyCodeEmitter::EmitWriteProxyMethodParameter(const AutoPtr& param, - const String& parcelName, const String& gotoLabel, StringBuilder& sb, const String& prefix) +void CClientProxyCodeEmitter::EmitCreateBuf(const String& dataBufName, const String& replyBufName, + StringBuilder& sb, const String& prefix) { - AutoPtr type = param->GetType(); - type->EmitCProxyWriteVar(parcelName, param->GetName(), gotoLabel, sb, prefix); + if (isKernelCode_) { + sb.Append(prefix).AppendFormat("struct HdfSBuf *%s = HdfSBufObtainDefaultSize();\n", dataBufName.string()); + sb.Append(prefix).AppendFormat("struct HdfSBuf *%s = HdfSBufObtainDefaultSize();\n", replyBufName.string()); + } else { + sb.Append(prefix).AppendFormat("struct HdfSBuf *%s = HdfSBufTypedObtain(SBUF_IPC);\n", dataBufName.string()); + sb.Append(prefix).AppendFormat("struct HdfSBuf *%s = HdfSBufTypedObtain(SBUF_IPC);\n", replyBufName.string()); + } + + sb.Append("\n"); + sb.Append(prefix).AppendFormat("if (%s == NULL || %s == NULL) {\n", dataBufName.string(), replyBufName.string()); + sb.Append(prefix + g_tab).Append("HDF_LOGE(\"%{public}s: HdfSubf malloc failed!\", __func__);\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); + sb.Append(prefix + g_tab).Append("goto finished;\n"); + sb.Append(prefix).Append("}\n"); +} + +void CClientProxyCodeEmitter::EmitReleaseBuf(const String& dataBufName, const String& replyBufName, StringBuilder& sb, + const String& prefix) +{ + sb.Append(prefix).AppendFormat("if (%s != NULL) {\n", dataBufName.string()); + sb.Append(prefix + g_tab).AppendFormat("HdfSBufRecycle(%s);\n", dataBufName.string()); + sb.Append(prefix).Append("}\n"); + sb.Append(prefix).AppendFormat("if (%s != NULL) {\n", replyBufName.string()); + sb.Append(prefix + g_tab).AppendFormat("HdfSBufRecycle(%s);\n", replyBufName.string()); + sb.Append(prefix).Append("}\n"); } void CClientProxyCodeEmitter::EmitReadProxyMethodParameter(const AutoPtr& param, @@ -269,14 +294,31 @@ void CClientProxyCodeEmitter::EmitReadProxyMethodParameter(const AutoPtrGetName().string()); type->EmitCProxyReadVar(parcelName, cloneName, false, gotoLabel, sb, prefix); String leftVar = String::Format("*%s", param->GetName().string()); - sb.Append(prefix).AppendFormat("%s = strdup(%s);\n", leftVar.string(), cloneName.string()); + if (isKernelCode_) { + sb.Append("\n"); + sb.Append(prefix).AppendFormat("%s = (char*)OsalMemCalloc(strlen(%s) + 1);\n", + leftVar.string(), cloneName.string()); + sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", leftVar.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix).Append("}\n\n"); + sb.Append(prefix).AppendFormat("if (strcpy_s(%s, (strlen(%s) + 1), %s) != HDF_SUCCESS) {\n", + leftVar.string(), cloneName.string(), cloneName.string()); + sb.Append(prefix + g_tab).AppendFormat("HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", + leftVar.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix).Append("}\n"); + } else { + sb.Append(prefix).AppendFormat("%s = strdup(%s);\n", leftVar.string(), cloneName.string()); + } } else if (type->GetTypeKind() == TypeKind::TYPE_STRUCT) { String name = String::Format("*%s", param->GetName().string()); sb.Append(prefix).AppendFormat("%s = (%s*)OsalMemAlloc(sizeof(%s));\n", name.string(), type->EmitCType().string(), type->EmitCType().string()); sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", name.string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); type->EmitCProxyReadVar(parcelName, name, false, gotoLabel, sb, prefix); } else if (type->GetTypeKind() == TypeKind::TYPE_UNION) { @@ -285,8 +327,8 @@ void CClientProxyCodeEmitter::EmitReadProxyMethodParameter(const AutoPtrGetName().string(), type->EmitCType().string(), type->EmitCType().string()); sb.Append(prefix).AppendFormat("if (*%s == NULL) {\n", param->GetName().string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); - sb.Append(prefix + TAB).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); sb.Append(prefix).Append("}\n"); sb.Append(prefix).AppendFormat("(void)memcpy_s(*%s, sizeof(%s), %s, sizeof(%s));\n", param->GetName().string(), type->EmitCType().string(), cpName.string(), type->EmitCType().string()); @@ -315,127 +357,16 @@ String CClientProxyCodeEmitter::GetGotLabel(const AutoPtr& method) return labelName; } -void CClientProxyCodeEmitter::EmitErrorHandle(const AutoPtr& method, StringBuilder& sb, - const String& prefix) -{ - bool errorLabel = false; - for (size_t i = 0; i < method->GetParameterNumber(); i++) { - AutoPtr param = method->GetParameter(i); - AutoPtr paramType = param->GetType(); - if (param->GetAttribute() == ParamAttr::PARAM_OUT && - (paramType->GetTypeKind() == TypeKind::TYPE_STRING - || paramType->GetTypeKind() == TypeKind::TYPE_ARRAY - || paramType->GetTypeKind() == TypeKind::TYPE_LIST - || paramType->GetTypeKind() == TypeKind::TYPE_STRUCT - || paramType->GetTypeKind() == TypeKind::TYPE_UNION)) { - if (!errorLabel) { - sb.Append(prefix + TAB).Append("goto finished;\n"); - sb.Append("\n"); - sb.Append(prefix).Append("errors:\n"); - errorLabel = true; - } - - EmitError(paramType, param->GetName(), sb, prefix + TAB); - sb.Append("\n"); - } - } -} - -void CClientProxyCodeEmitter::EmitError(const AutoPtr& type, const String& name, StringBuilder& sb, - const String& prefix) -{ - switch (type->GetTypeKind()) { - case TypeKind::TYPE_STRING: - case TypeKind::TYPE_UNION: { - sb.Append(prefix).AppendFormat("if (*%s != NULL) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat("OsalMemFree(*%s);\n", name.string()); - sb.Append(prefix + TAB).AppendFormat("*%s = NULL;\n", name.string()); - sb.Append(prefix).Append("}\n"); - break; - } - case TypeKind::TYPE_ARRAY: { - String lenName = String::Format("%sLen", name.string()); - sb.Append(prefix).AppendFormat("if (*%s > 0 && *%s != NULL) {\n", lenName.string(), name.string()); - - AutoPtr arrayType = dynamic_cast(type.Get()); - AutoPtr elementType = arrayType->GetElementType(); - - if (elementType->GetTypeKind() == TypeKind::TYPE_STRING - || elementType->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append(prefix + TAB).AppendFormat("for (uint32_t i = 0; i < *%s; i++) {\n", lenName.string()); - String elementName = String::Format("(*%s)[i]", name.string()); - - if (elementType->GetTypeKind() == TypeKind::TYPE_STRING) { - sb.Append(prefix + TAB + TAB).AppendFormat("if (%s != NULL) {\n", elementName.string()); - sb.Append(prefix + TAB + TAB + TAB).AppendFormat("OsalMemFree(%s);\n", elementName.string()); - sb.Append(prefix + TAB + TAB).Append("}\n"); - } else { - sb.Append(prefix + TAB + TAB).AppendFormat("%sFree(&%s, false);\n", - elementType->GetName().string(), elementName.string()); - } - sb.Append(prefix + TAB).Append("}\n"); - } - sb.Append(prefix + TAB).AppendFormat("OsalMemFree(*%s);\n", name.string()); - sb.Append(prefix + TAB).AppendFormat("*%s = NULL;\n", name.string()); - sb.Append(prefix).Append("}\n"); - break; - } - case TypeKind::TYPE_LIST: { - String lenName = String::Format("%sLen", name.string()); - sb.Append(prefix).AppendFormat("if (*%s > 0 && *%s != NULL) {\n", lenName.string(), name.string()); - - AutoPtr listType = dynamic_cast(type.Get()); - AutoPtr elementType = listType->GetElementType(); - - if (elementType->GetTypeKind() == TypeKind::TYPE_STRING - || elementType->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append(prefix + TAB).AppendFormat("for (uint32_t i = 0; i < *%s; i++) {\n", lenName.string()); - String elementName = String::Format("(*%s)[i]", name.string()); - - if (elementType->GetTypeKind() == TypeKind::TYPE_STRING) { - sb.Append(prefix + TAB + TAB).AppendFormat("if (%s != NULL) {\n", elementName.string()); - sb.Append(prefix + TAB + TAB + TAB).AppendFormat("OsalMemFree(%s);\n", elementName.string()); - sb.Append(prefix + TAB + TAB).Append("}\n"); - } else { - sb.Append(prefix + TAB + TAB).AppendFormat("%sFree(&%s, false);\n", - elementType->GetName().string(), elementName.string()); - } - sb.Append(prefix + TAB).Append("}\n"); - } - sb.Append(prefix + TAB).AppendFormat("OsalMemFree(*%s);\n", name.string()); - sb.Append(prefix + TAB).AppendFormat("*%s = NULL;\n", name.string()); - sb.Append(prefix).Append("}\n"); - break; - } - case TypeKind::TYPE_STRUCT: { - sb.Append(prefix).AppendFormat("if (*%s != NULL) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat("%sFree(*%s, true);\n", type->GetName().string(), name.string()); - sb.Append(prefix + TAB).AppendFormat("*%s = NULL;\n", name.string()); - sb.Append(prefix).Append("}\n"); - break; - } - default: - break; - } -} - void CClientProxyCodeEmitter::EmitProxyConstruction(StringBuilder& sb) { - String objName; - if (!isCallbackInterface()) { - objName = "inst"; - sb.AppendFormat("static void %sConstruct(struct %s *%s)\n", - infName_.string(), interfaceName_.string(), objName.string()); - } else { - objName = "callback"; - sb.AppendFormat("static void %sProxyConstruct(struct %s *%s)\n", - infName_.string(), interfaceName_.string(), objName.string()); - } + String objName = "instance"; + sb.AppendFormat("static void %sProxyConstruct(struct %s *%s)\n", + infName_.string(), interfaceName_.string(), objName.string()); sb.Append("{\n"); for (size_t i = 0; i < interface_->GetMethodNumber(); i++) { AutoPtr method = interface_->GetMethod(i); - sb.Append(TAB).AppendFormat("%s->%s = %sProxy%s;\n", + sb.Append(g_tab).AppendFormat("%s->%s = %sProxy%s;\n", objName.string(), method->GetName().string(), infName_.string(), method->GetName().string()); } @@ -444,79 +375,126 @@ void CClientProxyCodeEmitter::EmitProxyConstruction(StringBuilder& sb) void CClientProxyCodeEmitter::EmitProxyGetMethodImpl(StringBuilder& sb) { - sb.AppendFormat("struct %s *Hdi%sGet()\n", interfaceName_.string(), infName_.string()); + sb.AppendFormat("struct %s *%sGet()\n", interfaceName_.string(), infName_.string()); + sb.Append("{\n"); + sb.Append(g_tab).AppendFormat("return %sGetInstance(\"%s\");\n", infName_.string(), FileName(implName_).string()); + sb.Append("}\n"); +} + +void CClientProxyCodeEmitter::EmitProxyGetInstanceMethodImpl(StringBuilder& sb) +{ + sb.AppendFormat("struct %s *%sGetInstance(const char *instanceName)\n", + interfaceName_.string(), infName_.string()); sb.Append("{\n"); - sb.Append(TAB).Append("struct HDIServiceManager *serviceMgr = HDIServiceManagerGet();\n"); - sb.Append(TAB).Append("if (serviceMgr == NULL) {\n"); - sb.Append(TAB).Append(TAB).Append("HDF_LOGE(\"%{public}s: HDIServiceManager not found!\", __func__);\n"); - sb.Append(TAB).Append(TAB).Append("return NULL;\n"); - sb.Append(TAB).Append("}\n"); + sb.Append(g_tab).Append("struct HDIServiceManager *serviceMgr = HDIServiceManagerGet();\n"); + sb.Append(g_tab).Append("if (serviceMgr == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).Append("HDF_LOGE(\"%{public}s: HDIServiceManager not found!\", __func__);\n"); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n"); sb.Append("\n"); - sb.Append(TAB).Append("struct HdfRemoteService *remote = "); - sb.AppendFormat("serviceMgr->GetService(serviceMgr, \"%sService\");\n", infName_.string()); - sb.Append(TAB).Append("HDIServiceManagerRelease(serviceMgr);\n"); - sb.Append(TAB).Append("if (remote == NULL) {\n"); - sb.Append(TAB).Append(TAB).AppendFormat( + sb.Append(g_tab).Append("struct HdfRemoteService *remote = "); + sb.Append("serviceMgr->GetService(serviceMgr, instanceName);\n"); + sb.Append(g_tab).Append("HDIServiceManagerRelease(serviceMgr);\n"); + sb.Append(g_tab).Append("if (remote == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: %sService not found!\", __func__);\n", infName_.string()); - sb.Append(TAB).Append(TAB).Append("return NULL;\n"); - sb.Append(TAB).Append("}\n"); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n"); sb.Append("\n"); - sb.Append(TAB).AppendFormat("struct %s *%sClient = (struct %s *)OsalMemAlloc(sizeof(struct %s));\n", - interfaceName_.string(), infName_.string(), interfaceName_.string(), interfaceName_.string()); - sb.Append(TAB).AppendFormat("if (%sClient == NULL) {\n", infName_.string()); - sb.Append(TAB).Append(TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: malloc %s instance failed!\", __func__);\n", interfaceName_.string()); - sb.Append(TAB).Append(TAB).Append("HdfRemoteServiceRecycle(remote);\n"); - sb.Append(TAB).Append(TAB).Append("return NULL;\n"); - sb.Append(TAB).Append("}\n"); + sb.Append(g_tab).AppendFormat("struct %sProxy *proxy = ", infName_.string()); + sb.AppendFormat("(struct %sProxy *)OsalMemAlloc(sizeof(struct %sProxy));\n", infName_.string(), infName_.string()); + sb.Append(g_tab).Append("if (proxy == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).AppendFormat( + "HDF_LOGE(\"%%{public}s: malloc %s proxy failed!\", __func__);\n", interfaceName_.string()); + sb.Append(g_tab).Append(g_tab).Append("HdfRemoteServiceRecycle(remote);\n"); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n"); sb.Append("\n"); - sb.Append(TAB).AppendFormat("%sClient->remote = remote;\n", infName_.string()); - sb.Append(TAB).AppendFormat("%sConstruct(%sClient);\n", infName_.string(), infName_.string()); - sb.Append(TAB).AppendFormat("return %sClient;\n", infName_.string()); + sb.Append(g_tab).Append("proxy->remote = remote;\n"); + sb.Append(g_tab).AppendFormat("%sProxyConstruct(&proxy->instance);\n", infName_.string()); + sb.Append(g_tab).Append("return &proxy->instance;\n"); sb.Append("}\n"); } -void CClientProxyCodeEmitter::EmitProxyReleaseMethodImpl(StringBuilder& sb) +void CClientProxyCodeEmitter::EmitKernelProxyGetInstanceMethodImpl(StringBuilder& sb) { - sb.AppendFormat("void Hdi%sRelease(struct %s *instance)\n", infName_.string(), interfaceName_.string()); + sb.AppendFormat("struct %s *%sGetInstance(const char* serviceName)\n", interfaceName_.string(), infName_.string()); sb.Append("{\n"); - sb.Append(TAB).Append("if (instance == NULL) {\n"); - sb.Append(TAB).Append(TAB).Append("return;\n"); - sb.Append(TAB).Append("}\n"); + sb.Append(g_tab).AppendFormat("struct HdfIoService *serv = "); + sb.Append("HdfIoServiceBind(serviceName);\n"); + sb.Append(g_tab).Append("if (serv == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).AppendFormat( + "HDF_LOGE(\"%%{public}s: %sService not found!\", __func__);\n", infName_.string()); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n"); + sb.Append("\n"); + + sb.Append(g_tab).AppendFormat("struct %sProxy *proxy = (struct %sProxy *)OsalMemAlloc(sizeof(struct %sProxy));\n", + infName_.string(), infName_.string(), infName_.string()); + sb.Append(g_tab).Append("if (proxy == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).AppendFormat( + "HDF_LOGE(\"%%{public}s: malloc %s proxy failed!\", __func__);\n", interfaceName_.string()); + sb.Append(g_tab).Append(g_tab).Append("HdfIoServiceRecycle(serv);\n"); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n"); + sb.Append("\n"); - sb.Append(TAB).Append("HdfRemoteServiceRecycle(instance->remote);\n"); - sb.Append(TAB).Append("OsalMemFree(instance);\n"); + sb.Append(g_tab).Append("proxy->serv = serv;\n"); + sb.Append(g_tab).AppendFormat("%sProxyConstruct(&proxy->instance);\n", infName_.string()); + sb.Append(g_tab).Append("return &proxy->instance;\n"); sb.Append("}\n"); } -void CClientProxyCodeEmitter::EmitCbProxyObtainMethodImpl(StringBuilder& sb) +void CClientProxyCodeEmitter::EmitCbProxyGetMethodImpl(StringBuilder& sb) { - sb.AppendFormat("struct %s *%sProxyObtain(struct HdfRemoteService *remote)\n", + sb.AppendFormat("struct %s *%sGet(struct HdfRemoteService *remote)\n", interfaceName_.string(), infName_.string()); sb.Append("{\n"); - sb.Append(TAB).AppendFormat("struct %s *callback = (struct %s*)OsalMemAlloc(sizeof(struct %s));\n", + sb.Append(g_tab).AppendFormat("struct %s *instance = (struct %s*)OsalMemAlloc(sizeof(struct %s));\n", interfaceName_.string(), interfaceName_.string(), interfaceName_.string()); - sb.Append(TAB).Append("if (callback == NULL) {\n"); - sb.Append(TAB).Append(TAB).Append("HDF_LOGE(\"%{public}s: OsalMemAlloc failed!\", __func__);\n"); - sb.Append(TAB).Append(TAB).Append("return NULL;\n"); - sb.Append(TAB).Append("}\n\n"); - sb.Append(TAB).Append("callback->remote = remote;\n"); - sb.Append(TAB).AppendFormat("%sProxyConstruct(callback);\n", infName_.string()); - sb.Append(TAB).Append("return callback;\n"); + sb.Append(g_tab).Append("if (instance == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).Append("HDF_LOGE(\"%{public}s: OsalMemAlloc failed!\", __func__);\n"); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n\n"); + sb.Append(g_tab).Append("instance->remote = remote;\n"); + sb.Append(g_tab).AppendFormat("%sProxyConstruct(instance);\n", infName_.string()); + sb.Append(g_tab).Append("return instance;\n"); + sb.Append("}\n"); +} + +void CClientProxyCodeEmitter::EmitProxyReleaseMethodImpl(StringBuilder& sb) +{ + sb.AppendFormat("void %sRelease(struct %s *instance)\n", infName_.string(), interfaceName_.string()); + sb.Append("{\n"); + sb.Append(g_tab).Append("if (instance == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).Append("return;\n"); + sb.Append(g_tab).Append("}\n"); + + if (!isCallbackInterface()) { + sb.Append(g_tab).AppendFormat("struct %sProxy *proxy = CONTAINER_OF(instance, struct %sProxy, instance);\n", + infName_.string(), infName_.string()); + sb.Append(g_tab).Append("HdfRemoteServiceRecycle(proxy->remote);\n"); + sb.Append(g_tab).Append("OsalMemFree(proxy);\n"); + } else { + sb.Append(g_tab).Append("OsalMemFree(instance);\n"); + } sb.Append("}\n"); } -void CClientProxyCodeEmitter::EmitCbProxyReleaseMethodImpl(StringBuilder& sb) +void CClientProxyCodeEmitter::EmitKernelProxyReleaseMethodImpl(StringBuilder& sb) { - sb.AppendFormat("void %sProxyRelease(struct %s *callback)\n", infName_.string(), interfaceName_.string()); + sb.AppendFormat("void %sRelease(struct %s *instance)\n", infName_.string(), interfaceName_.string()); sb.Append("{\n"); - sb.Append(TAB).Append("if (callback == NULL) {\n"); - sb.Append(TAB).Append(TAB).Append("return;\n"); - sb.Append(TAB).Append("}\n"); - sb.Append(TAB).Append("OsalMemFree(callback);\n"); + sb.Append(g_tab).Append("if (instance == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).Append("return;\n"); + sb.Append(g_tab).Append("}\n"); + sb.Append(g_tab).AppendFormat("struct %sProxy *proxy = CONTAINER_OF(instance, struct %sProxy, instance);\n", + infName_.string(), infName_.string()); + sb.Append(g_tab).Append("HdfIoServiceRecycle(proxy->serv);\n"); + sb.Append(g_tab).Append("OsalMemFree(proxy);\n"); sb.Append("}\n"); } } // namespace HDI diff --git a/tools/hdi-gen/codegen/c_client_proxy_code_emitter.h b/tools/hdi-gen/codegen/c_client_proxy_code_emitter.h index 8594cfc202c5d3a5a4df30c1e95021e755d0a71c..0c0c6448f746049c633a19c1b6887fcd4df61041 100755 --- a/tools/hdi-gen/codegen/c_client_proxy_code_emitter.h +++ b/tools/hdi-gen/codegen/c_client_proxy_code_emitter.h @@ -15,21 +15,21 @@ namespace OHOS { namespace HDI { class CClientProxyCodeEmitter : public CCodeEmitter { public: - CClientProxyCodeEmitter(const AutoPtr& ast, const String& targetDirectory); + CClientProxyCodeEmitter() : CCodeEmitter() {} virtual ~CClientProxyCodeEmitter() = default; +private: + bool ResolveDirectory(const String& targetDirectory) override; void EmitCode() override; -private: - void EmitCbProxyHeaderFile(); void EmitProxySourceFile(); - void EmitCbProxyMethodsDcl(StringBuilder& sb); + void EmitProxyDefinition(StringBuilder& sb); void EmitProxyInclusions(StringBuilder& sb); - void EmitProxyStdlibInclusions(StringBuilder& sb); + void GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); void EmitProxyCallMethodImpl(StringBuilder& sb); @@ -39,27 +39,29 @@ private: void EmitProxyMethodBody(const AutoPtr& method, StringBuilder& sb, const String& prefix); - void EmitWriteProxyMethodParameter(const AutoPtr& param, const String& parcelName, - const String& gotoLabel, StringBuilder& sb, const String& prefix); + void EmitCreateBuf(const String& dataBufName, const String& replyBufName, StringBuilder& sb, const String& prefix); + + void EmitReleaseBuf(const String& dataBufName, const String& replyBufName, StringBuilder& sb, + const String& prefix); void EmitReadProxyMethodParameter(const AutoPtr& param, const String& parcelName, const String& gotoLabel, StringBuilder& sb, const String& prefix); String GetGotLabel(const AutoPtr& method); - void EmitErrorHandle(const AutoPtr& method, StringBuilder& sb, const String& prefix); - - void EmitError(const AutoPtr& type, const String& name, StringBuilder& sb, const String& prefix); - void EmitProxyConstruction(StringBuilder&); void EmitProxyGetMethodImpl(StringBuilder& sb); - void EmitProxyReleaseMethodImpl(StringBuilder& sb); + void EmitProxyGetInstanceMethodImpl(StringBuilder& sb); + + void EmitKernelProxyGetInstanceMethodImpl(StringBuilder& sb); - void EmitCbProxyObtainMethodImpl(StringBuilder& sb); + void EmitCbProxyGetMethodImpl(StringBuilder& sb); + + void EmitProxyReleaseMethodImpl(StringBuilder& sb); - void EmitCbProxyReleaseMethodImpl(StringBuilder& sb); + void EmitKernelProxyReleaseMethodImpl(StringBuilder& sb); std::vector freeObjStatements_; }; diff --git a/tools/hdi-gen/codegen/c_code_emitter.cpp b/tools/hdi-gen/codegen/c_code_emitter.cpp index 03c5edcd32581bf2b595d5a3aa6b106fb9d6249d..6bed3067072cb18d18c76b939145d10377f65178 100755 --- a/tools/hdi-gen/codegen/c_code_emitter.cpp +++ b/tools/hdi-gen/codegen/c_code_emitter.cpp @@ -11,36 +11,8 @@ #include #include -#include "util/logger.h" - namespace OHOS { namespace HDI { -const char* CCodeEmitter::TAB = " "; - -CCodeEmitter::CCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - :LightRefCountBase(), ast_(ast), directory_(targetDirectory) -{ - if (ast_->GetASTFileType() == ASTFileType::AST_IFACE || ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) { - interface_ = ast_->GetInterfaceDef(); - } - - if (interface_ != nullptr) { - interfaceName_ = interface_->GetName(); - interfaceFullName_ = interface_->GetNamespace()->ToString() + interfaceName_; - infName_ = interfaceName_.StartsWith("I") ? interfaceName_.Substring(1) : interfaceName_; - proxyName_ = infName_ + "Proxy"; - proxyFullName_ = interface_->GetNamespace()->ToString() + proxyName_; - - stubName_ = infName_ + "Stub"; - stubFullName_ = interface_->GetNamespace()->ToString() + stubName_; - - ImplName_ = infName_ + "Service"; - ImplFullName_ = interface_->GetNamespace()->ToString() + ImplName_; - } else { - infName_ = ast_->GetName(); - } -} - String CCodeEmitter::FileName(const String& name) { if (name.IsEmpty()) { @@ -70,11 +42,20 @@ void CCodeEmitter::EmitInterfaceMethodCommands(StringBuilder& sb) sb.Append("enum {\n"); for (size_t i = 0; i < interface_->GetMethodNumber(); i++) { AutoPtr method = interface_->GetMethod(i); - sb.Append(TAB).AppendFormat("CMD_%s,\n", ConstantName(method->GetName()).string()); + sb.Append(g_tab).AppendFormat("CMD_%s,\n", ConstantName(method->GetName()).string()); } sb.Append("};\n"); } +void CCodeEmitter::GetImportInclusions(HeaderFile::HeaderFileSet& headerFiles) +{ + for (const auto& importPair : ast_->GetImports()) { + AutoPtr importAst = importPair.second; + String fileName = FileName(importAst->GetFullName()); + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_MODULE_HEADER_FILE, FileName(importAst->GetFullName()))); + } +} + void CCodeEmitter::EmitInterfaceMethodParameter(const AutoPtr& parameter, StringBuilder& sb, const String& prefix) { @@ -82,6 +63,42 @@ void CCodeEmitter::EmitInterfaceMethodParameter(const AutoPtr& par sb.Append(prefix).Append(parameter->EmitCParameter()); } +void CCodeEmitter::EmitErrorHandle(const AutoPtr& method, const String& gotoLabel, bool isClient, + StringBuilder& sb, const String& prefix) +{ + if (!isClient) { + sb.Append(prefix).AppendFormat("%s:\n", gotoLabel.string()); + for (int i = 0; i < method->GetParameterNumber(); i++) { + AutoPtr param = method->GetParameter(i); + AutoPtr paramType = param->GetType(); + paramType->EmitMemoryRecycle(param->GetName(), isClient, true, sb, prefix + g_tab); + } + return; + } + + bool errorLabel = false; + for (size_t i = 0; i < method->GetParameterNumber(); i++) { + AutoPtr param = method->GetParameter(i); + AutoPtr paramType = param->GetType(); + if (param->GetAttribute() == ParamAttr::PARAM_OUT && + (paramType->GetTypeKind() == TypeKind::TYPE_STRING + || paramType->GetTypeKind() == TypeKind::TYPE_ARRAY + || paramType->GetTypeKind() == TypeKind::TYPE_LIST + || paramType->GetTypeKind() == TypeKind::TYPE_STRUCT + || paramType->GetTypeKind() == TypeKind::TYPE_UNION)) { + if (!errorLabel) { + sb.Append(prefix + g_tab).Append("goto finished;\n"); + sb.Append("\n"); + sb.Append(prefix).AppendFormat("%s:\n", gotoLabel.string()); + errorLabel = true; + } + + paramType->EmitMemoryRecycle(param->GetName(), isClient, true, sb, prefix + g_tab); + sb.Append("\n"); + } + } +} + void CCodeEmitter::EmitLicense(StringBuilder& sb) { if (ast_->GetLicense().IsEmpty()) { diff --git a/tools/hdi-gen/codegen/c_code_emitter.h b/tools/hdi-gen/codegen/c_code_emitter.h index a067ff799d37c8121ee0e922152b7a7b9ce21b2e..0ed14fa084e39b19aa67af64942819eab19ab50b 100755 --- a/tools/hdi-gen/codegen/c_code_emitter.h +++ b/tools/hdi-gen/codegen/c_code_emitter.h @@ -9,41 +9,29 @@ #ifndef OHOS_HDI_C_CODE_EMITTER_H #define OHOS_HDI_C_CODE_EMITTER_H -#include #include "ast/ast.h" +#include "codegen/code_emitter.h" #include "util/autoptr.h" -#include "util/light_refcount_base.h" #include "util/string.h" #include "util/string_builder.h" namespace OHOS { namespace HDI { -class CCodeEmitter : public LightRefCountBase { +class CCodeEmitter : public CodeEmitter { public: - CCodeEmitter(const AutoPtr& ast, const String& targetDirectory); - virtual ~CCodeEmitter() = default; - virtual void EmitCode() = 0; - - inline String GetSourceFile() - { - return sourceFileName_; - } - - inline bool isInvaildDir() - { - return directory_.Equals(""); - } - static String FileName(const String& name); - protected: - void EmitInterfaceMethodCommands(StringBuilder& sb); + void GetImportInclusions(HeaderFile::HeaderFileSet& headerFiles); + void EmitInterfaceMethodParameter(const AutoPtr& parameter, StringBuilder& sb, const String& prefix); + void EmitErrorHandle(const AutoPtr& method, const String& gotoLabel, bool isClient, StringBuilder& sb, + const String& prefix); + void EmitLicense(StringBuilder& sb); void EmitHeadMacro(StringBuilder& sb, const String& fullName); @@ -68,26 +56,8 @@ protected: } String SpecificationParam(StringBuilder& sb, const String& prefix); - - static const char* TAB; - - AutoPtr ast_; - AutoPtr interface_; - - String directory_; - String sourceFileName_; - - String interfaceName_; - String interfaceFullName_; - String infName_; - String proxyName_; - String proxyFullName_; - String stubName_; - String stubFullName_; - String ImplName_; - String ImplFullName_; }; } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_C_CODE_EMITTER_H +#endif // OHOS_HDI_C_CODE_EMITTER_H \ No newline at end of file diff --git a/tools/hdi-gen/codegen/c_code_generator.cpp b/tools/hdi-gen/codegen/c_code_generator.cpp deleted file mode 100755 index 2fadd06aa7a73e16d572a69e21922b9da089988d..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/codegen/c_code_generator.cpp +++ /dev/null @@ -1,84 +0,0 @@ -/* - * Copyright (c) 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 "c_code_generator.h" -#include -#include -#include -#include "codegen/c_client_interface_code_emitter.h" -#include "codegen/c_client_proxy_code_emitter.h" -#include "codegen/c_custom_types_code_emitter.h" -#include "codegen/c_service_driver_code_emitter.h" -#include "codegen/c_service_impl_code_emitter.h" -#include "codegen/c_service_interface_code_emitter.h" -#include "codegen/c_service_stub_code_emitter.h" -#include "util/file.h" -#include "util/logger.h" - -namespace OHOS { -namespace HDI { -const char* CCodeGenerator::TAG = "CCodeGenerator"; - -bool CCodeGenerator::Initializate(const AutoPtr& ast, const String& targetDirectory) -{ - ast_ = ast; - targetDirectory_ = targetDirectory; - - if (!ResolveDirectory()) { - return false; - } - - if (ast_->GetASTFileType() == ASTFileType::AST_TYPES) { - AutoPtr customTypesCodeEmitter = new CCustomTypesCodeEmitter(ast_, targetDirectory_); - emitters_.push_back(customTypesCodeEmitter); - return true; - } - - AutoPtr clientInterfaceCodeEmitter = new CClientInterfaceCodeEmitter(ast_, targetDirectory_); - AutoPtr clientProxyCodeEmitter = new CClientProxyCodeEmitter(ast_, targetDirectory_); - - AutoPtr serviceInterfaceCodeEmitter = new CServiceInterfaceCodeEmitter(ast_, targetDirectory_); - AutoPtr serviceDriverCodeEmitter = new CServiceDriverCodeEmitter(ast_, targetDirectory_); - AutoPtr serviceStubCodeEmitter = new CServiceStubCodeEmitter(ast_, targetDirectory_); - AutoPtr serviceImplCodeEmitter = new CServiceImplCodeEmitter(ast_, targetDirectory_); - - emitters_.push_back(clientInterfaceCodeEmitter); - emitters_.push_back(clientProxyCodeEmitter); - emitters_.push_back(serviceInterfaceCodeEmitter); - emitters_.push_back(serviceDriverCodeEmitter); - emitters_.push_back(serviceStubCodeEmitter); - emitters_.push_back(serviceImplCodeEmitter); - - return true; -} - -bool CCodeGenerator::Generate() const -{ - for (auto emitter : emitters_) { - if (!emitter->isInvaildDir()) { - emitter->EmitCode(); - } - } - - return true; -} - -bool CCodeGenerator::ResolveDirectory() -{ - String packageFilePath = String::Format("%s/%s/", - targetDirectory_.string(), CCodeEmitter::FileName(ast_->GetPackageName()).string()); - targetDirectory_ = packageFilePath; - - if (!File::CreateParentDir(targetDirectory_)) { - Logger::E(TAG, "create '%s' directory failed!", targetDirectory_); - return false; - } - return true; -} -} // namespace HDI -} // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/codegen/c_code_generator.h b/tools/hdi-gen/codegen/c_code_generator.h deleted file mode 100755 index bfdd046de98f893160871d438dbc971978429f1f..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/codegen/c_code_generator.h +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright (c) 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 OHOS_HDI_C_CODE_GENERATOR_H -#define OHOS_HDI_C_CODE_GENERATOR_H - -#include "codegen/c_code_emitter.h" -#include "codegen/code_generator.h" - -namespace OHOS { -namespace HDI { -class CCodeGenerator : public CodeGenerator { -public: - CCodeGenerator() : CodeGenerator(), - emitters_() {} - - virtual ~CCodeGenerator() = default; - - bool Initializate(const AutoPtr& ast, const String& targetDirectory) override; - bool Generate() const override; -private: - bool ResolveDirectory() override; - - static const char* TAG; - std::vector> emitters_; -}; -} // namespace HDI -} // namespace OHOS - -#endif // OHOS_HDI_C_CODE_GENERATOR_H \ No newline at end of file diff --git a/tools/hdi-gen/codegen/c_custom_types_code_emitter.cpp b/tools/hdi-gen/codegen/c_custom_types_code_emitter.cpp index 4cecdd681ce1d1b1ae2b6d70f37132195f744448..51942e8afb8d16c1af4a9931ae1051a749b29cba 100755 --- a/tools/hdi-gen/codegen/c_custom_types_code_emitter.cpp +++ b/tools/hdi-gen/codegen/c_custom_types_code_emitter.cpp @@ -8,9 +8,27 @@ #include "codegen/c_custom_types_code_emitter.h" #include "util/file.h" +#include "util/logger.h" +#include "util/options.h" namespace OHOS { namespace HDI { +bool CCustomTypesCodeEmitter::ResolveDirectory(const String& targetDirectory) +{ + if (ast_->GetASTFileType() != ASTFileType::AST_TYPES) { + return false; + } + + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); + if (!File::CreateParentDir(directory_)) { + Logger::E("CCustomTypesCodeEmitter", "Create '%s' failed!", directory_.string()); + return false; + } + + return true; +} + void CCustomTypesCodeEmitter::EmitCode() { EmitCustomTypesHeaderFile(); @@ -19,9 +37,8 @@ void CCustomTypesCodeEmitter::EmitCode() void CCustomTypesCodeEmitter::EmitCustomTypesHeaderFile() { - String filePath = String::Format("%s%s.h", directory_.string(), FileName(infName_).string()); + String filePath = String::Format("%s/%s.h", directory_.string(), FileName(infName_).string()); File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); @@ -46,11 +63,21 @@ void CCustomTypesCodeEmitter::EmitCustomTypesHeaderFile() } void CCustomTypesCodeEmitter::EmitHeaderInclusions(StringBuilder& sb) +{ + HeaderFile::HeaderFileSet headerFiles; + GetHeaderOtherLibInclusions(headerFiles); + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); + } +} + +void CCustomTypesCodeEmitter::GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles) { for (size_t i = 0; i < ast_->GetTypeDefinitionNumber(); i++) { AutoPtr type = ast_->GetTypeDefintion(i); if (type->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append("#include \n"); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_sbuf")); break; } } @@ -136,7 +163,6 @@ void CCustomTypesCodeEmitter::EmitCustomTypesSourceFile() { String filePath = String::Format("%s%s.c", directory_.string(), FileName(infName_).string()); File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); @@ -152,21 +178,26 @@ void CCustomTypesCodeEmitter::EmitCustomTypesSourceFile() void CCustomTypesCodeEmitter::EmitSoucreIncludsions(StringBuilder& sb) { - sb.AppendFormat("#include \"%s.h\"\n", FileName(infName_).string()); - EmitSourceStdlibInclusions(sb); + HeaderFile::HeaderFileSet headerFiles; + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_HEADER_FILE, FileName(infName_))); + GetSourceOtherLibInclusions(headerFiles); + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); + } } -void CCustomTypesCodeEmitter::EmitSourceStdlibInclusions(StringBuilder& sb) +void CCustomTypesCodeEmitter::GetSourceOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles) { - sb.Append("#include \n"); - sb.Append("#include \n"); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_log")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "osal_mem")); const AST::TypeStringMap& types = ast_->GetTypes(); for (const auto& pair : types) { AutoPtr type = pair.second; if (type->GetTypeKind() == TypeKind::TYPE_STRUCT || type->GetTypeKind() == TypeKind::TYPE_UNION) { - sb.Append("#include \n"); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "securec")); break; } } @@ -196,15 +227,27 @@ void CCustomTypesCodeEmitter::EmitCustomTypeMarshallingImpl(StringBuilder& sb, c sb.AppendFormat("bool %sBlockMarshalling(struct HdfSBuf *data, const %s *%s)\n", type->GetName().string(), type->EmitCType().string(), objName.string()); sb.Append("{\n"); + + for (size_t i = 0; i < type->GetMemberNumber(); i++) { + AutoPtr memberType = type->GetMemberType(i); + if (isKernelCode_) { + if (memberType->GetTypeKind() == TypeKind::TYPE_ARRAY || + memberType->GetTypeKind() == TypeKind::TYPE_LIST) { + sb.Append(g_tab).Append("uint32_t i = 0;\n"); + break; + } + } + } + for (size_t i = 0; i < type->GetMemberNumber(); i++) { String memberName = type->GetMemberName(i); AutoPtr memberType = type->GetMemberType(i); String name = String::Format("%s->%s", objName.string(), memberName.string()); - memberType->EmitCMarshalling(name, sb, TAB); + memberType->EmitCMarshalling(name, sb, g_tab); sb.Append("\n"); } - sb.Append(TAB).Append("return true;\n"); + sb.Append(g_tab).Append("return true;\n"); sb.Append("}\n"); } @@ -217,229 +260,183 @@ void CCustomTypesCodeEmitter::EmitCustomTypeUnmarshallingImpl(StringBuilder& sb, type->GetName().string(), type->EmitCType().string(), objName.string()); sb.Append("{\n"); - sb.Append(TAB).AppendFormat("if (%s == NULL) {\n", objName.string()); - sb.Append(TAB).Append(TAB).Append("return false;\n"); - sb.Append(TAB).Append("}\n"); - - for (size_t i = 0; i < type->GetMemberNumber(); i++) { - AutoPtr memberType = type->GetMemberType(i); - String memberName = type->GetMemberName(i); - String name = String::Format("%s->%s", objName.string(), memberName.string()); - - if (memberType->GetTypeKind() == TypeKind::TYPE_STRING) { - String tmpName = String::Format("%sCp", memberName.string()); - memberType->EmitCUnMarshalling(tmpName, sb, TAB, freeObjStatements_); - sb.Append(TAB).AppendFormat("%s = strdup(%s);\n", name.string(), tmpName.string()); - sb.Append(TAB).AppendFormat("if (%s == NULL) {\n", name.string()); - sb.Append(TAB).Append(TAB).Append("goto errors;\n"); - sb.Append(TAB).Append("}\n"); - sb.Append("\n"); - } else if (memberType->GetTypeKind() == TypeKind::TYPE_STRUCT) { - String paramName = String::Format("&%s", name.string()); - memberType->EmitCUnMarshalling(paramName, sb, TAB, freeObjStatements_); - sb.Append("\n"); - } else if (memberType->GetTypeKind() == TypeKind::TYPE_UNION) { - String tmpName = String::Format("%sCp", memberName.string()); - memberType->EmitCUnMarshalling(tmpName, sb, TAB, freeObjStatements_); - sb.Append(TAB).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", - name.string(), memberType->EmitCType().string(), - tmpName.string(), memberType->EmitCType().string()); - sb.Append("\n"); - } else if (memberType->GetTypeKind() == TypeKind::TYPE_ARRAY) { - String tmpName = String::Format("%sCp", memberName.string()); - AutoPtr arrayType = dynamic_cast(memberType.Get()); - AutoPtr elementType = arrayType->GetElementType(); - sb.Append(TAB).AppendFormat("%s* %s = NULL;\n", elementType->EmitCType().string(), tmpName.string()); - sb.Append(TAB).AppendFormat("uint32_t %sLen = 0;\n", tmpName.string()); - memberType->EmitCUnMarshalling(tmpName, sb, TAB, freeObjStatements_); - sb.Append(TAB).AppendFormat("%s = %s;\n", name.string(), tmpName.string()); - sb.Append(TAB).AppendFormat("%sLen = %sLen;\n", name.string(), tmpName.string()); - sb.Append("\n"); - } else if (memberType->GetTypeKind() == TypeKind::TYPE_LIST) { - String tmpName = String::Format("%sCp", memberName.string()); - AutoPtr listType = dynamic_cast(memberType.Get()); - AutoPtr elementType = listType->GetElementType(); - sb.Append(TAB).AppendFormat("%s* %s = NULL;\n", elementType->EmitCType().string(), tmpName.string()); - sb.Append(TAB).AppendFormat("uint32_t %sLen = 0;\n", tmpName.string()); - memberType->EmitCUnMarshalling(tmpName, sb, TAB, freeObjStatements_); - sb.Append(TAB).AppendFormat("%s = %s;\n", name.string(), tmpName.string()); - sb.Append(TAB).AppendFormat("%sLen = %sLen;\n", name.string(), tmpName.string()); - sb.Append("\n"); - } else { - memberType->EmitCUnMarshalling(name, sb, TAB, freeObjStatements_); - sb.Append("\n"); + if (isKernelCode_) { + for (size_t i = 0; i < type->GetMemberNumber(); i++) { + AutoPtr memberType = type->GetMemberType(i); + if (memberType->GetTypeKind() == TypeKind::TYPE_ARRAY || + memberType->GetTypeKind() == TypeKind::TYPE_LIST) { + sb.Append(g_tab).Append("uint32_t i = 0;\n"); + break; + } } } - sb.Append(TAB).AppendFormat("return true;\n"); - sb.Append("errors:\n"); + sb.Append(g_tab).AppendFormat("if (%s == NULL) {\n", objName.string()); + sb.Append(g_tab).Append(g_tab).Append("return false;\n"); + sb.Append(g_tab).Append("}\n"); + for (size_t i = 0; i < type->GetMemberNumber(); i++) { AutoPtr memberType = type->GetMemberType(i); - String memberName = type->GetMemberName(i); - String name = String::Format("%s->%s", objName.string(), memberName.string()); - EmitError(name, memberType, sb, TAB); + EmitMemberUnmarshalling(memberType, objName, type->GetMemberName(i), sb, g_tab); } - sb.Append(TAB).Append("return false;\n"); + sb.Append(g_tab).AppendFormat("return true;\n"); + sb.Append("errors:\n"); + EmitCustomTypeMemoryRecycle(type, objName, sb, g_tab); + + sb.Append(g_tab).Append("return false;\n"); sb.Append("}\n"); } - -void CCustomTypesCodeEmitter::EmitError(const String& name, const AutoPtr& type, - StringBuilder& sb, const String& prefix) +void CCustomTypesCodeEmitter::EmitMemberUnmarshalling(const AutoPtr& type, const String& name, + const String& memberName, StringBuilder& sb, const String& prefix) { + String varName = String::Format("%s->%s", name.string(), memberName.string()); switch (type->GetTypeKind()) { case TypeKind::TYPE_STRING: { - sb.Append(prefix).AppendFormat("if (%s != NULL) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat("OsalMemFree(%s);\n", name.string()); - sb.Append(prefix).Append("}\n\n"); - break; - } - case TypeKind::TYPE_ARRAY: { - AutoPtr arrayType = dynamic_cast(type.Get()); - AutoPtr elementType = arrayType->GetElementType(); - String lenName = String::Format("%sLen", name.string()); - - sb.Append(prefix).AppendFormat("if (%s > 0 && %s != NULL) {\n", lenName.string(), name.string()); - if (elementType->GetTypeKind() == TypeKind::TYPE_STRING - || elementType->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append(prefix + TAB).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); - String elementName = String::Format("(%s)[i]", name.string()); - - if (elementType->GetTypeKind() == TypeKind::TYPE_STRING) { - sb.Append(prefix + TAB + TAB).AppendFormat("if (%s != NULL) {\n", elementName.string()); - sb.Append(prefix + TAB + TAB + TAB).AppendFormat("OsalMemFree(%s);\n", elementName.string()); - sb.Append(prefix + TAB + TAB).Append("}\n"); - } else if (elementType->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append(prefix + TAB + TAB).AppendFormat("%sFree(&(%s), false);\n", - elementType->GetName().string(), elementName.string()); - } - - sb.Append(prefix + TAB).Append("}\n"); + String tmpName = String::Format("%sCp", memberName.string()); + type->EmitCUnMarshalling(tmpName, sb, g_tab, freeObjStatements_); + + if (Options::GetInstance().DoGenerateKernelCode()) { + sb.Append(g_tab).AppendFormat("%s = (char*)OsalMemCalloc(strlen(%s) + 1);\n", + varName.string(), tmpName.string()); + sb.Append(g_tab).AppendFormat("if (%s == NULL) {\n", varName.string()); + sb.Append(g_tab).Append(g_tab).Append("goto errors;\n"); + sb.Append(g_tab).Append("}\n"); + + sb.Append(g_tab).AppendFormat("if (strcpy_s(%s, (strlen(%s) + 1), %s) != HDF_SUCCESS) {\n", + varName.string(), tmpName.string(), tmpName.string()); + sb.Append(g_tab).Append(g_tab).Append("goto errors;\n"); + sb.Append(g_tab).Append("}\n"); + } else { + sb.Append(g_tab).AppendFormat("%s = strdup(%s);\n", varName.string(), tmpName.string()); } - sb.Append(prefix + TAB).AppendFormat("OsalMemFree(%s);\n", name.string()); - sb.Append(prefix).Append("}\n"); + sb.Append(g_tab).AppendFormat("if (%s == NULL) {\n", varName.string()); + sb.Append(g_tab).Append(g_tab).Append("goto errors;\n"); + sb.Append(g_tab).Append("}\n"); sb.Append("\n"); break; } - case TypeKind::TYPE_LIST: { - AutoPtr listType = dynamic_cast(type.Get()); - AutoPtr elementType = listType->GetElementType(); - String lenName = String::Format("%sLen", name.string()); - - sb.Append(prefix).AppendFormat("if (%s > 0 && %s != NULL) {\n", lenName.string(), name.string()); - if (elementType->GetTypeKind() == TypeKind::TYPE_STRING - || elementType->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append(prefix + TAB).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); - String elementName = String::Format("(%s)[i]", name.string()); - - if (elementType->GetTypeKind() == TypeKind::TYPE_STRING) { - sb.Append(prefix + TAB + TAB).AppendFormat("if (%s != NULL) {\n", elementName.string()); - sb.Append(prefix + TAB + TAB + TAB).AppendFormat("OsalMemFree(%s);\n", elementName.string()); - sb.Append(prefix + TAB + TAB).Append("}\n"); - } else if (elementType->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append(prefix + TAB + TAB).AppendFormat("%sFree(&(%s), false);\n", - elementType->GetName().string(), elementName.string()); - } - - sb.Append(prefix + TAB).Append("}\n"); - } - - sb.Append(prefix + TAB).AppendFormat("OsalMemFree(%s);\n", name.string()); - sb.Append(prefix).Append("}\n"); + case TypeKind::TYPE_STRUCT: { + String paramName = String::Format("&%s", varName.string()); + type->EmitCUnMarshalling(paramName, sb, g_tab, freeObjStatements_); sb.Append("\n"); break; } - case TypeKind::TYPE_STRUCT: { - sb.Append(prefix).AppendFormat("%sFree(&%s, false);\n", type->GetName().string(), name.string()); - sb.Append(prefix).Append("\n"); + case TypeKind::TYPE_UNION: { + String tmpName = String::Format("%sCp", memberName.string()); + type->EmitCUnMarshalling(tmpName, sb, g_tab, freeObjStatements_); + sb.Append(g_tab).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", + varName.string(), type->EmitCType().string(), + tmpName.string(), type->EmitCType().string()); + sb.Append("\n"); break; } - default: + case TypeKind::TYPE_ARRAY: + case TypeKind::TYPE_LIST: { + EmitArrayMemberUnmarshalling(type, memberName, varName, sb, g_tab); + sb.Append("\n"); break; + } + default: { + type->EmitCUnMarshalling(varName, sb, g_tab, freeObjStatements_); + sb.Append("\n"); + } } } +void CCustomTypesCodeEmitter::EmitArrayMemberUnmarshalling(const AutoPtr& type, const String& memberName, + const String& varName, StringBuilder& sb, const String& prefix) +{ + String tmpName = String::Format("%sCp", memberName.string()); + AutoPtr elementType = nullptr; + if (type->GetTypeKind() == TypeKind::TYPE_ARRAY) { + AutoPtr arrayType = dynamic_cast(type.Get()); + elementType = arrayType->GetElementType(); + } else { + AutoPtr listType = dynamic_cast(type.Get()); + elementType = listType->GetElementType(); + } + + sb.Append(prefix).AppendFormat("%s* %s = NULL;\n", elementType->EmitCType().string(), tmpName.string()); + sb.Append(prefix).AppendFormat("uint32_t %sLen = 0;\n", tmpName.string()); + type->EmitCUnMarshalling(tmpName, sb, prefix, freeObjStatements_); + sb.Append(prefix).AppendFormat("%s = %s;\n", varName.string(), tmpName.string()); + sb.Append(prefix).AppendFormat("%sLen = %sLen;\n", varName.string(), tmpName.string()); +} + void CCustomTypesCodeEmitter::EmitCustomTypeFreeImpl(StringBuilder& sb, const AutoPtr& type) { String objName("dataBlock"); sb.AppendFormat("void %sFree(%s *%s, bool freeSelf)\n", type->GetName().string(), type->EmitCType().string(), objName.string()); sb.Append("{\n"); - sb.Append(TAB).AppendFormat("if (%s == NULL) {\n", objName.string()); - sb.Append(TAB).Append(TAB).Append("return;\n"); - sb.Append(TAB).Append("}\n"); - sb.Append("\n"); - for (size_t i = 0; i < type->GetMemberNumber(); i++) { - AutoPtr memberType = type->GetMemberType(i); - String memberName = type->GetMemberName(i); - String name = String::Format("%s->%s", objName.string(), memberName.string()); - EmitCustomTypeMemberFree(sb, name, memberType, TAB); + if (isKernelCode_) { + for (size_t i = 0; i < type->GetMemberNumber(); i++) { + AutoPtr memberType = type->GetMemberType(i); + if (NeedEmitInitVar(memberType)) { + sb.Append(g_tab).Append("uint32_t i = 0;\n"); + break; + } + } } - sb.Append(TAB).Append("if (freeSelf) {\n"); - sb.Append(TAB).Append(TAB).Append("OsalMemFree(dataBlock);\n"); - sb.Append(TAB).Append("}\n"); + sb.Append(g_tab).AppendFormat("if (%s == NULL) {\n", objName.string()); + sb.Append(g_tab).Append(g_tab).Append("return;\n"); + sb.Append(g_tab).Append("}\n"); + sb.Append("\n"); + + EmitCustomTypeMemoryRecycle(type, objName, sb, g_tab); + sb.Append(g_tab).Append("if (freeSelf) {\n"); + sb.Append(g_tab).Append(g_tab).Append("OsalMemFree(dataBlock);\n"); + sb.Append(g_tab).Append("}\n"); sb.Append("}\n"); } -void CCustomTypesCodeEmitter::EmitCustomTypeMemberFree(StringBuilder& sb, const String& name, - const AutoPtr& type, const String& prefix) +bool CCustomTypesCodeEmitter::NeedEmitInitVar(const AutoPtr& type) { - switch (type->GetTypeKind()) { - case TypeKind::TYPE_STRING: { - sb.Append(prefix).AppendFormat("if (%s != NULL) {\n", name.string()); - sb.Append(prefix + TAB).AppendFormat("OsalMemFree(%s);\n", name.string()); - sb.Append(prefix).Append("}\n\n"); - break; - } - case TypeKind::TYPE_ARRAY: { - AutoPtr arrayType = dynamic_cast(type.Get()); - AutoPtr elementType = arrayType->GetElementType(); - - sb.Append(prefix).AppendFormat("if (%sLen > 0 && %s != NULL) {\n", name.string(), name.string()); - if (elementType->GetTypeKind() == TypeKind::TYPE_STRING) { - sb.Append(prefix + TAB).AppendFormat("for (uint32_t i = 0; i < %sLen; i++) {\n", name.string()); - sb.Append(prefix + TAB + TAB).AppendFormat("OsalMemFree(%s[i]);\n", name.string()); - sb.Append(prefix + TAB).Append("}\n"); - } else if (elementType->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append(prefix + TAB).AppendFormat("for (uint32_t i = 0; i < %sLen; i++) {\n", name.string()); - sb.Append(prefix + TAB + TAB).AppendFormat("%sFree(%s, false);\n", - elementType->GetName().string(), name.string()); - sb.Append(prefix + TAB).Append("}\n"); - } - sb.Append(prefix + TAB).AppendFormat("OsalMemFree(%s);\n", name.string()); - sb.Append(prefix).Append("}\n\n"); - break; + if (type == nullptr) { + return false; + } + + if (type->IsArrayType()) { + AutoPtr ArrType = dynamic_cast(type.Get()); + AutoPtr elementType = ArrType->GetElementType(); + if (elementType->IsStringType() || elementType->IsStructType()) { + return true; } - case TypeKind::TYPE_LIST: { - AutoPtr listType = dynamic_cast(type.Get()); - AutoPtr elementType = listType->GetElementType(); - - sb.Append(prefix).AppendFormat("if (%sLen > 0 && %s != NULL) {\n", name.string(), name.string()); - if (elementType->GetTypeKind() == TypeKind::TYPE_STRING) { - sb.Append(prefix + TAB).AppendFormat("for (uint32_t i = 0; i < %sLen; i++) {\n", name.string()); - sb.Append(prefix + TAB + TAB).AppendFormat("OsalMemFree(%s[i]);\n", name.string()); - sb.Append(prefix + TAB).Append("}\n"); - } else if (elementType->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append(prefix + TAB).AppendFormat("for (uint32_t i = 0; i < %sLen; i++) {\n", name.string()); - sb.Append(prefix + TAB + TAB).AppendFormat("%sFree(%s, false);\n", - elementType->GetName().string(), name.string()); - sb.Append(prefix + TAB).Append("}\n"); - } - sb.Append(prefix + TAB).AppendFormat("OsalMemFree(%s);\n", name.string()); - sb.Append(prefix).Append("}\n\n"); - break; + } else if (type->IsListType()) { + AutoPtr ListType = dynamic_cast(type.Get()); + AutoPtr elementType = ListType->GetElementType(); + if (elementType->IsStringType() || elementType->IsStructType()) { + return true; } - case TypeKind::TYPE_STRUCT: { - sb.Append(prefix).AppendFormat("%sFree(&%s, false);\n\n", type->GetName().string(), name.string()); - break; + } + + return false; +} + +void CCustomTypesCodeEmitter::EmitCustomTypeMemoryRecycle(const AutoPtr& type, const String& name, + StringBuilder& sb, const String& prefix) +{ + for (size_t i = 0; i < type->GetMemberNumber(); i++) { + AutoPtr memberType = type->GetMemberType(i); + String memberName = type->GetMemberName(i); + String varName = String::Format("%s->%s", name.string(), memberName.string()); + switch (memberType->GetTypeKind()) { + case TypeKind::TYPE_STRING: + case TypeKind::TYPE_STRUCT: + case TypeKind::TYPE_ARRAY: + case TypeKind::TYPE_LIST: + memberType->EmitMemoryRecycle(varName, false, false, sb, prefix); + sb.Append("\n"); + break; + default: + break; } - default: - break; } } } // namespace HDI diff --git a/tools/hdi-gen/codegen/c_custom_types_code_emitter.h b/tools/hdi-gen/codegen/c_custom_types_code_emitter.h index 2473df8a1285e04020affb8266b086a5e32d7ba9..e7d93c9e870bd8a9dcd072dc67adef2931b20aec 100755 --- a/tools/hdi-gen/codegen/c_custom_types_code_emitter.h +++ b/tools/hdi-gen/codegen/c_custom_types_code_emitter.h @@ -15,17 +15,20 @@ namespace OHOS { namespace HDI { class CCustomTypesCodeEmitter : public CCodeEmitter { public: - CCustomTypesCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - : CCodeEmitter(ast, targetDirectory) {} + CCustomTypesCodeEmitter() : CCodeEmitter() {} virtual ~CCustomTypesCodeEmitter() = default; +private: + bool ResolveDirectory(const String& targetDirectory) override; void EmitCode() override; -private: + void EmitCustomTypesHeaderFile(); void EmitHeaderInclusions(StringBuilder& sb); + void GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); + void EmitCustomTypeDecls(StringBuilder& sb); void EmitCustomTypeDecl(StringBuilder& sb, const AutoPtr& type); @@ -42,7 +45,7 @@ private: void EmitSoucreIncludsions(StringBuilder& sb); - void EmitSourceStdlibInclusions(StringBuilder& sb); + void GetSourceOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); void EmitCustomTypeDataProcess(StringBuilder& sb); @@ -50,11 +53,17 @@ private: void EmitCustomTypeUnmarshallingImpl(StringBuilder& sb, const AutoPtr& type); - void EmitError(const String& name, const AutoPtr& type, StringBuilder& sb, const String& prefix); + void EmitMemberUnmarshalling(const AutoPtr& type, const String& name, const String& memberName, + StringBuilder& sb, const String& prefix); + + void EmitArrayMemberUnmarshalling(const AutoPtr& type, const String& memberName, const String& varName, + StringBuilder& sb, const String& prefix); void EmitCustomTypeFreeImpl(StringBuilder& sb, const AutoPtr& type); - void EmitCustomTypeMemberFree(StringBuilder& sb, const String& name, const AutoPtr& type, + bool NeedEmitInitVar(const AutoPtr& type); + + void EmitCustomTypeMemoryRecycle(const AutoPtr& type, const String& name, StringBuilder& sb, const String& prefix); std::vector freeObjStatements_; @@ -62,4 +71,4 @@ private: } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_C_CUSTOM_TYPES_CODE_EMITTER_H +#endif // OHOS_HDI_C_CUSTOM_TYPES_CODE_EMITTER_H \ No newline at end of file diff --git a/tools/hdi-gen/codegen/c_service_interface_code_emitter.cpp b/tools/hdi-gen/codegen/c_interface_code_emitter.cpp similarity index 42% rename from tools/hdi-gen/codegen/c_service_interface_code_emitter.cpp rename to tools/hdi-gen/codegen/c_interface_code_emitter.cpp index a38821b7d2db97aa35447c168acdfb5c30c008f7..2dca6a5d609e334b9cdb49f45ad44e214a123378 100755 --- a/tools/hdi-gen/codegen/c_service_interface_code_emitter.cpp +++ b/tools/hdi-gen/codegen/c_interface_code_emitter.cpp @@ -6,35 +6,39 @@ * See the LICENSE file in the root of this repository for complete details. */ -#include "codegen/c_service_interface_code_emitter.h" +#include "codegen/c_interface_code_emitter.h" #include "util/file.h" #include "util/logger.h" namespace OHOS { namespace HDI { -void CServiceInterfaceCodeEmitter::EmitCode() +bool CInterfaceCodeEmitter::ResolveDirectory(const String& targetDirectory) { - if (!isCallbackInterface()) { - EmitInterfaceHeadrFile(); - } -} - -void CServiceInterfaceCodeEmitter::EmitInterfaceHeadrFile() -{ - String filePath; - if (!isCallbackInterface()) { - filePath = String::Format("%sserver/%s.h", directory_.string(), FileName(interfaceName_).string()); + if (ast_->GetASTFileType() == ASTFileType::AST_IFACE || + ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) { + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); } else { - filePath = String::Format("%s%s.h", directory_.string(), FileName(interfaceName_).string()); + return false; } - if (!File::CreateParentDir(filePath)) { - Logger::E("CServiceInterfaceCodeEmitter", "Create '%s' failed!", filePath.string()); - return; + if (!File::CreateParentDir(directory_)) { + Logger::E("CInterfaceCodeEmitter", "Create '%s' failed!", directory_.string()); + return false; } - File file(filePath, File::WRITE); + return true; +} +void CInterfaceCodeEmitter::EmitCode() +{ + EmitInterfaceHeaderFile(); +} + +void CInterfaceCodeEmitter::EmitInterfaceHeaderFile() +{ + String filePath = String::Format("%s%s.h", directory_.string(), FileName(interfaceName_).string()); + File file(filePath, File::WRITE); StringBuilder sb; EmitLicense(sb); @@ -42,12 +46,18 @@ void CServiceInterfaceCodeEmitter::EmitInterfaceHeadrFile() sb.Append("\n"); EmitImportInclusions(sb); sb.Append("\n"); - EmitInterfaceDataDecls(sb); + EmitHeadExternC(sb); sb.Append("\n"); EmitInterfaceMethodCommands(sb); sb.Append("\n"); EmitInterfaceDefinition(sb); sb.Append("\n"); + EmitInterfaceGetMethodDecl(sb); + sb.Append("\n"); + EmitInterfaceReleaseMethodDecl(sb); + sb.Append("\n"); + EmitTailExternC(sb); + sb.Append("\n"); EmitTailMacro(sb, interfaceFullName_); String data = sb.ToString(); @@ -56,45 +66,35 @@ void CServiceInterfaceCodeEmitter::EmitInterfaceHeadrFile() file.Close(); } -void CServiceInterfaceCodeEmitter::EmitImportInclusions(StringBuilder& sb) +void CInterfaceCodeEmitter::EmitImportInclusions(StringBuilder& sb) { - sb.Append("#include \n"); - for (const auto& importPair : ast_->GetImports()) { - AutoPtr importAst = importPair.second; - - String fileName; - if (importAst->GetASTFileType() == ASTFileType::AST_ICALLBACK && importAst->GetInterfaceDef() != nullptr) { - String ifaceName = importAst->GetInterfaceDef()->GetName(); - String name = ifaceName.StartsWith("I") ? ifaceName.Substring(1) : ifaceName; - String stubName = name + "Proxy"; - fileName = FileName(importAst->GetInterfaceDef()->GetNamespace()->ToString() + stubName); - } else { - fileName = FileName(importAst->GetFullName()); - } - sb.Append("#include ").AppendFormat("\"%s.h\"\n", fileName.string()); + HeaderFile::HeaderFileSet headerFiles; + + GetImportInclusions(headerFiles); + GetHeaderOtherLibInclusions(headerFiles); + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); } } -void CServiceInterfaceCodeEmitter::EmitInterfaceDataDecls(StringBuilder& sb) +void CInterfaceCodeEmitter::GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles) { - sb.Append("struct HdfSBuf;\n"); - sb.Append("struct HdfDeviceObject;\n"); - sb.Append("struct HdfDeviceIoClient;\n"); + headerFiles.emplace(HeaderFile(HeaderFileType::C_STD_HEADER_FILE, "stdint")); } -void CServiceInterfaceCodeEmitter::EmitInterfaceDefinition(StringBuilder& sb) +void CInterfaceCodeEmitter::EmitInterfaceDefinition(StringBuilder& sb) { sb.AppendFormat("struct %s {\n", interfaceName_.string()); - EmitInterfaceMethods(sb, TAB); - sb.Append("};\n\n"); - EmitInterfaceInstanceMethodDecl(sb); - sb.Append("\n"); - EmitInterfaceReleaseMethodDecl(sb); - sb.Append("\n"); - EmitInterfaceRequestMethodDecl(sb); + if (isCallbackInterface()) { + sb.Append(g_tab).Append("struct HdfRemoteService *remote;\n"); + sb.Append("\n"); + } + EmitInterfaceMethods(sb, g_tab); + sb.Append("};\n"); } -void CServiceInterfaceCodeEmitter::EmitInterfaceMethods(StringBuilder& sb, const String& prefix) +void CInterfaceCodeEmitter::EmitInterfaceMethods(StringBuilder& sb, const String& prefix) { for (size_t i = 0; i < interface_->GetMethodNumber(); i++) { AutoPtr method = interface_->GetMethod(i); @@ -105,7 +105,7 @@ void CServiceInterfaceCodeEmitter::EmitInterfaceMethods(StringBuilder& sb, const } } -void CServiceInterfaceCodeEmitter::EmitInterfaceMethod(const AutoPtr& method, StringBuilder& sb, +void CInterfaceCodeEmitter::EmitInterfaceMethod(const AutoPtr& method, StringBuilder& sb, const String& prefix) { if (method->GetParameterNumber() == 0) { @@ -124,26 +124,26 @@ void CServiceInterfaceCodeEmitter::EmitInterfaceMethod(const AutoPtr& } paramStr.Append(");"); - sb.Append(SpecificationParam(paramStr, prefix + TAB)); + sb.Append(SpecificationParam(paramStr, prefix + g_tab)); sb.Append("\n"); } } -void CServiceInterfaceCodeEmitter::EmitInterfaceInstanceMethodDecl(StringBuilder& sb) +void CInterfaceCodeEmitter::EmitInterfaceGetMethodDecl(StringBuilder& sb) { - sb.AppendFormat("struct %s *Hdi%sInstance();\n", interfaceName_.string(), infName_.string()); + String methodParamStr = isCallbackInterface() ? "struct HdfRemoteService *remote" : "void"; + sb.AppendFormat("struct %s *%sGet(%s);\n", interfaceName_.string(), infName_.string(), methodParamStr.string()); + if (!isCallbackInterface()) { + sb.Append("\n"); + sb.AppendFormat("struct %s *%sGetInstance(const char *instanceName);\n", + interfaceName_.string(), infName_.string()); + } } -void CServiceInterfaceCodeEmitter::EmitInterfaceReleaseMethodDecl(StringBuilder& sb) +void CInterfaceCodeEmitter::EmitInterfaceReleaseMethodDecl(StringBuilder& sb) { - sb.AppendFormat("void Hdi%sRelease(struct %s *instance);\n", - infName_.string(), interfaceName_.string()); + sb.AppendFormat("void %sRelease(struct %s *instance);\n", infName_.string(), interfaceName_.string()); } -void CServiceInterfaceCodeEmitter::EmitInterfaceRequestMethodDecl(StringBuilder& sb) -{ - sb.AppendFormat("int32_t %sServiceOnRemoteRequest(void *service, int cmdId,\n", infName_.string()); - sb.Append(TAB).Append("struct HdfSBuf *data, struct HdfSBuf *reply);\n"); -} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/codegen/c_service_interface_code_emitter.h b/tools/hdi-gen/codegen/c_interface_code_emitter.h similarity index 53% rename from tools/hdi-gen/codegen/c_service_interface_code_emitter.h rename to tools/hdi-gen/codegen/c_interface_code_emitter.h index b1b6f7a9513b5e7dc0da8d7cc876158bdc54a6bd..dfdab7c1423aa07ebb2f68484c6fcd2d50e1f540 100755 --- a/tools/hdi-gen/codegen/c_service_interface_code_emitter.h +++ b/tools/hdi-gen/codegen/c_interface_code_emitter.h @@ -6,27 +6,28 @@ * See the LICENSE file in the root of this repository for complete details. */ -#ifndef OHOS_HDI_C_SERVICE_INTERFACE_CODEE_MITTER_H -#define OHOS_HDI_C_SERVICE_INTERFACE_CODEE_MITTER_H +#ifndef OHOS_HDI_C_CLIENT_INTERFACE_CODE_EMITTER_H +#define OHOS_HDI_C_CLIENT_INTERFACE_CODE_EMITTER_H #include "codegen/c_code_emitter.h" namespace OHOS { namespace HDI { -class CServiceInterfaceCodeEmitter : public CCodeEmitter { +class CInterfaceCodeEmitter : public CCodeEmitter { public: - CServiceInterfaceCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - : CCodeEmitter(ast, targetDirectory) {} + CInterfaceCodeEmitter() : CCodeEmitter() {} - virtual ~CServiceInterfaceCodeEmitter() = default; + virtual ~CInterfaceCodeEmitter() = default; +private: + bool ResolveDirectory(const String& targetDirectory) override; void EmitCode() override; -private: - void EmitInterfaceHeadrFile(); + + void EmitInterfaceHeaderFile(); void EmitImportInclusions(StringBuilder& sb); - void EmitInterfaceDataDecls(StringBuilder& sb); + void GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); void EmitInterfaceDefinition(StringBuilder& sb); @@ -34,13 +35,13 @@ private: void EmitInterfaceMethod(const AutoPtr& method, StringBuilder& sb, const String& prefix); - void EmitInterfaceInstanceMethodDecl(StringBuilder& sb); + void EmitInterfaceGetMethodDecl(StringBuilder& sb); void EmitInterfaceReleaseMethodDecl(StringBuilder& sb); - void EmitInterfaceRequestMethodDecl(StringBuilder& sb); }; + } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_C_SERVICE_INTERFACE_CODEE_MITTER_H \ No newline at end of file +#endif // OHOS_HDI_C_CLIENT_INTERFACE_CODE_EMITTER_H \ No newline at end of file diff --git a/tools/hdi-gen/codegen/c_service_driver_code_emitter.cpp b/tools/hdi-gen/codegen/c_service_driver_code_emitter.cpp index d67c84584d57b4ba6f32fb374ac04496b79716b9..1f3efb4af7b46912ab428832868ed267d86a0d5e 100755 --- a/tools/hdi-gen/codegen/c_service_driver_code_emitter.cpp +++ b/tools/hdi-gen/codegen/c_service_driver_code_emitter.cpp @@ -9,15 +9,24 @@ #include "codegen/c_service_driver_code_emitter.h" #include "util/file.h" #include "util/logger.h" +#include "util/options.h" namespace OHOS { namespace HDI { -CServiceDriverCodeEmitter::CServiceDriverCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - :CCodeEmitter(ast, targetDirectory) +bool CServiceDriverCodeEmitter::ResolveDirectory(const String& targetDirectory) { - String infFullName = String::Format("%sserver.%s", - interface_->GetNamespace()->ToString().string(), infName_.string()); - sourceFileName_ = String::Format("%s_driver.c", FileName(infFullName).string()); + if (ast_->GetASTFileType() != ASTFileType::AST_IFACE) { + return false; + } + + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); + if (!File::CreateParentDir(directory_)) { + Logger::E("CServiceDriverCodeEmitter", "Create '%s' failed!", directory_.string()); + return false; + } + + return true; } void CServiceDriverCodeEmitter::EmitCode() @@ -30,20 +39,8 @@ void CServiceDriverCodeEmitter::EmitCode() void CServiceDriverCodeEmitter::EmitDriverSourceFile() { - String filePath; - if (!isCallbackInterface()) { - filePath = String::Format("%sserver/%s.c", directory_.string(), FileName(infName_ + "Driver").string()); - } else { - filePath = String::Format("%s%s.c", directory_.string(), FileName(infName_ + "Driver").string()); - } - - if (!File::CreateParentDir(filePath)) { - Logger::E("CServiceDriverCodeEmitter", "Create '%s' failed!", filePath.string()); - return; - } - + String filePath = String::Format("%s%s.c", directory_.string(), FileName(infName_ + "Driver").string()); File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); @@ -69,33 +66,45 @@ void CServiceDriverCodeEmitter::EmitDriverSourceFile() void CServiceDriverCodeEmitter::EmitDriverIncluions(StringBuilder& sb) { - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.AppendFormat("#include \"%s.h\"\n", FileName(interfaceName_).string()); + HeaderFile::HeaderFileSet headerFiles; + + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_MODULE_HEADER_FILE, FileName(stubName_))); + GetDriverSourceOtherLibInclusions(headerFiles); + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); + } +} + +void CServiceDriverCodeEmitter::GetDriverSourceOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles) +{ + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_base")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_log")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "osal_mem")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_device_desc")); } void CServiceDriverCodeEmitter::EmitDriverServiceDecl(StringBuilder& sb) { - sb.AppendFormat("struct Hdf%sService {\n", infName_.string()); - sb.Append(TAB).AppendFormat("struct IDeviceIoService ioservice;\n"); - sb.Append(TAB).Append("void *instance;\n"); + sb.AppendFormat("struct Hdf%sHost {\n", infName_.string()); + sb.Append(g_tab).AppendFormat("struct IDeviceIoService ioservice;\n"); + sb.Append(g_tab).Append("void *instance;\n"); sb.Append("};\n"); } void CServiceDriverCodeEmitter::EmitDriverDispatch(StringBuilder& sb) { - sb.AppendFormat("static int32_t %sServiceDispatch(struct HdfDeviceIoClient *client, int cmdId,\n", + String hostName = infName_.ToLowerCase() + "Host"; + sb.AppendFormat("static int32_t %sDriverDispatch(struct HdfDeviceIoClient *client, int cmdId,\n", infName_.string()); - sb.Append(TAB).Append("struct HdfSBuf *data, struct HdfSBuf *reply)\n"); + sb.Append(g_tab).Append("struct HdfSBuf *data, struct HdfSBuf *reply)\n"); sb.Append("{\n"); - sb.Append(TAB).AppendFormat("struct Hdf%sService *hdf%sService = CONTAINER_OF(\n", - infName_.string(), infName_.string()); - sb.Append(TAB).Append(TAB).AppendFormat("client->device->service, struct Hdf%sService, ioservice);\n", + sb.Append(g_tab).AppendFormat("struct Hdf%sHost *%s = CONTAINER_OF(\n", + infName_.string(), hostName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("client->device->service, struct Hdf%sHost, ioservice);\n", infName_.string()); - sb.Append(TAB).AppendFormat("return %sServiceOnRemoteRequest(hdf%sService->instance, cmdId, data, reply);\n", - infName_.string(), infName_.string()); + sb.Append(g_tab).AppendFormat("return %sServiceOnRemoteRequest(%s->instance, cmdId, data, reply);\n", + infName_.string(), hostName.string()); sb.Append("}\n"); } @@ -103,62 +112,65 @@ void CServiceDriverCodeEmitter::EmitDriverInit(StringBuilder& sb) { sb.AppendFormat("int Hdf%sDriverInit(struct HdfDeviceObject *deviceObject)\n", infName_.string()); sb.Append("{\n"); - sb.Append(TAB).AppendFormat("HDF_LOGI(\"Hdf%sDriverInit enter, new hdi impl.\");\n", infName_.string()); - sb.Append(TAB).Append("return HDF_SUCCESS;\n"); + sb.Append(g_tab).AppendFormat("HDF_LOGI(\"Hdf%sDriverInit enter.\");\n", infName_.string()); + sb.Append(g_tab).Append("return HDF_SUCCESS;\n"); sb.Append("}\n"); } void CServiceDriverCodeEmitter::EmitDriverBind(StringBuilder& sb) { + String hostName = infName_.ToLowerCase() + "Host"; sb.AppendFormat("int Hdf%sDriverBind(struct HdfDeviceObject *deviceObject)\n", infName_.string()); sb.Append("{\n"); - sb.Append(TAB).AppendFormat("HDF_LOGI(\"Hdf%sDriverBind enter.\");\n", infName_.string()); + sb.Append(g_tab).AppendFormat("HDF_LOGI(\"Hdf%sDriverBind enter.\");\n", infName_.string()); sb.Append("\n"); - sb.Append(TAB).AppendFormat("struct Hdf%sService *hdf%sService = (struct Hdf%sService *)OsalMemAlloc(\n", - infName_.string(), infName_.string(), infName_.string()); - sb.Append(TAB).Append(TAB).AppendFormat("sizeof(struct Hdf%sService));\n", infName_.string()); - sb.Append(TAB).AppendFormat("if (hdf%sService == NULL) {\n", infName_.string()); - sb.Append(TAB).Append(TAB).AppendFormat( - "HDF_LOGE(\"Hdf%sDriverBind OsalMemAlloc Hdf%sService failed!\");\n", infName_.string(), infName_.string()); - sb.Append(TAB).Append(TAB).Append("return HDF_FAILURE;\n"); - sb.Append(TAB).Append("}\n"); + sb.Append(g_tab).AppendFormat("struct Hdf%sHost *%s = (struct Hdf%sHost *)OsalMemAlloc(\n", + infName_.string(), hostName.string(), infName_.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("sizeof(struct Hdf%sHost));\n", infName_.string()); + sb.Append(g_tab).AppendFormat("if (%s == NULL) {\n", hostName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat( + "HDF_LOGE(\"Hdf%sDriverBind OsalMemAlloc Hdf%sHost failed!\");\n", infName_.string(), infName_.string()); + sb.Append(g_tab).Append(g_tab).Append("return HDF_FAILURE;\n"); + sb.Append(g_tab).Append("}\n"); sb.Append("\n"); - sb.Append(TAB).AppendFormat("hdf%sService->ioservice.Dispatch = %sServiceDispatch;\n", - infName_.string(), infName_.string()); - sb.Append(TAB).AppendFormat("hdf%sService->ioservice.Open = NULL;\n", infName_.string()); - sb.Append(TAB).AppendFormat("hdf%sService->ioservice.Release = NULL;\n", infName_.string()); - sb.Append(TAB).AppendFormat("hdf%sService->instance = Hdi%sInstance();\n", infName_.string(), infName_.string()); - sb.Append(TAB).AppendFormat("if (hdf%sService->instance == NULL) {\n", infName_.string()); - sb.Append(TAB).Append(TAB).AppendFormat("OsalMemFree(hdf%sService);\n", infName_.string()); - sb.Append(TAB).Append(TAB).Append("return HDF_FAILURE;\n"); - sb.Append(TAB).Append("}\n"); + sb.Append(g_tab).AppendFormat("%s->ioservice.Dispatch = %sDriverDispatch;\n", + hostName.string(), infName_.string()); + sb.Append(g_tab).AppendFormat("%s->ioservice.Open = NULL;\n", hostName.string()); + sb.Append(g_tab).AppendFormat("%s->ioservice.Release = NULL;\n", hostName.string()); + sb.Append(g_tab).AppendFormat("%s->instance = %sStubGetInstance();\n", hostName.string(), infName_.string()); + sb.Append(g_tab).AppendFormat("if (%s->instance == NULL) {\n", hostName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("OsalMemFree(%s);\n", hostName.string()); + sb.Append(g_tab).Append(g_tab).Append("return HDF_FAILURE;\n"); + sb.Append(g_tab).Append("}\n"); sb.Append("\n"); - sb.Append(TAB).AppendFormat("deviceObject->service = &hdf%sService->ioservice;\n", infName_.string()); - sb.Append(TAB).Append("return HDF_SUCCESS;\n"); + sb.Append(g_tab).AppendFormat("deviceObject->service = &%s->ioservice;\n", hostName.string()); + sb.Append(g_tab).Append("return HDF_SUCCESS;\n"); sb.Append("}\n"); } void CServiceDriverCodeEmitter::EmitDriverRelease(StringBuilder& sb) { + String hostName = infName_.ToLowerCase() + "Host"; sb.AppendFormat("void Hdf%sDriverRelease(struct HdfDeviceObject *deviceObject)\n", infName_.string()); sb.Append("{\n"); - sb.Append(TAB).AppendFormat("struct Hdf%sService *hdf%sService = CONTAINER_OF(\n", - infName_.string(), infName_.string()); - sb.Append(TAB).Append(TAB).AppendFormat("deviceObject->service, struct Hdf%sService, ioservice);\n", + sb.Append(g_tab).AppendFormat("HDF_LOGI(\"Hdf%sDriverRelease enter.\");\n", infName_.string()); + sb.Append(g_tab).AppendFormat("struct Hdf%sHost *%s = CONTAINER_OF(", infName_.string(), hostName.string()); + sb.AppendFormat("deviceObject->service, struct Hdf%sHost, ioservice);\n", infName_.string()); - sb.Append(TAB).AppendFormat("Hdi%sRelease(hdf%sService->instance);\n", infName_.string(), infName_.string()); - sb.Append(TAB).AppendFormat("OsalMemFree(hdf%sService);\n", infName_.string()); + sb.Append(g_tab).AppendFormat("%sStubRelease(%s->instance);\n", infName_.string(), hostName.string()); + sb.Append(g_tab).AppendFormat("OsalMemFree(%s);\n", hostName.string()); sb.Append("}\n"); } void CServiceDriverCodeEmitter::EmitDriverEntryDefinition(StringBuilder& sb) { sb.AppendFormat("struct HdfDriverEntry g_%sDriverEntry = {\n", infName_.ToLowerCase().string()); - sb.Append(TAB).Append(".moduleVersion = 1,\n"); - sb.Append(TAB).Append(".moduleName = \"sample\", /* please change the moduleName */\n"); - sb.Append(TAB).AppendFormat(".Bind = Hdf%sDriverBind,\n", infName_.string()); - sb.Append(TAB).AppendFormat(".Init = Hdf%sDriverInit,\n", infName_.string()); - sb.Append(TAB).AppendFormat(".Release = Hdf%sDriverRelease,\n", infName_.string()); + sb.Append(g_tab).Append(".moduleVersion = 1,\n"); + sb.Append(g_tab).AppendFormat(".moduleName = \"%s\",\n", + Options::GetInstance().GetModuleName().string()); + sb.Append(g_tab).AppendFormat(".Bind = Hdf%sDriverBind,\n", infName_.string()); + sb.Append(g_tab).AppendFormat(".Init = Hdf%sDriverInit,\n", infName_.string()); + sb.Append(g_tab).AppendFormat(".Release = Hdf%sDriverRelease,\n", infName_.string()); sb.Append("};\n\n"); sb.AppendFormat("HDF_INIT(g_%sDriverEntry);", infName_.ToLowerCase().string()); } diff --git a/tools/hdi-gen/codegen/c_service_driver_code_emitter.h b/tools/hdi-gen/codegen/c_service_driver_code_emitter.h index 02a0aab74d402f83833921d0dfa671330d76c1d6..94fd227212e36d146fe125f330201ff6794c2831 100755 --- a/tools/hdi-gen/codegen/c_service_driver_code_emitter.h +++ b/tools/hdi-gen/codegen/c_service_driver_code_emitter.h @@ -15,17 +15,20 @@ namespace OHOS { namespace HDI { class CServiceDriverCodeEmitter : public CCodeEmitter { public: - - CServiceDriverCodeEmitter(const AutoPtr& ast, const String& targetDirectory); + CServiceDriverCodeEmitter() : CCodeEmitter() {} virtual ~CServiceDriverCodeEmitter() = default; +private: + bool ResolveDirectory(const String& targetDirectory) override; void EmitCode() override; -private: + void EmitDriverSourceFile(); void EmitDriverIncluions(StringBuilder& sb); + void GetDriverSourceOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); + void EmitDriverServiceDecl(StringBuilder& sb); void EmitDriverDispatch(StringBuilder& sb); diff --git a/tools/hdi-gen/codegen/c_service_impl_code_emitter.cpp b/tools/hdi-gen/codegen/c_service_impl_code_emitter.cpp index ae876957ac18c0bd2dc6a0a03ea2d97725d1f304..e73d3bd93b19f4b6edc127fff83779365db75260 100755 --- a/tools/hdi-gen/codegen/c_service_impl_code_emitter.cpp +++ b/tools/hdi-gen/codegen/c_service_impl_code_emitter.cpp @@ -12,38 +12,40 @@ namespace OHOS { namespace HDI { -CServiceImplCodeEmitter::CServiceImplCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - :CCodeEmitter(ast, targetDirectory) +bool CServiceImplCodeEmitter::ResolveDirectory(const String& targetDirectory) { - String infFullName = String::Format("%sserver.%s", - interface_->GetNamespace()->ToString().string(), infName_.string()); - sourceFileName_ = String::Format("%s_service.c", FileName(infFullName).string()); + if (ast_->GetASTFileType() == ASTFileType::AST_IFACE || + ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) { + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); + } else { + return false; + } + + if (!File::CreateParentDir(directory_)) { + Logger::E("CServiceImplCodeEmitter", "Create '%s' failed!", directory_.string()); + return false; + } + + return true; } void CServiceImplCodeEmitter::EmitCode() { - if (isCallbackInterface()) { - EmitServiceImplHeaderFile(); - } + EmitServiceImplHeaderFile(); EmitServiceImplSourceFile(); } void CServiceImplCodeEmitter::EmitServiceImplHeaderFile() { String filePath = String::Format("%s%s.h", directory_.string(), FileName(infName_ + "Service").string()); - if (!File::CreateParentDir(filePath)) { - Logger::E("CServiceDriverCodeEmitter", "Create '%s' failed!", filePath.string()); - return; - } - File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); - EmitHeadMacro(sb, ImplFullName_); + EmitHeadMacro(sb, implFullName_); sb.Append("\n"); - sb.AppendFormat("#include \"%s.h\"\n", FileName(interfaceName_).string()); + EmitServiceImplHeaderInclusions(sb); sb.Append("\n"); EmitHeadExternC(sb); sb.Append("\n"); @@ -51,7 +53,7 @@ void CServiceImplCodeEmitter::EmitServiceImplHeaderFile() sb.Append("\n"); EmitTailExternC(sb); sb.Append("\n"); - EmitTailMacro(sb, ImplFullName_); + EmitTailMacro(sb, implFullName_); String data = sb.ToString(); file.WriteData(data.string(), data.GetLength()); @@ -59,6 +61,17 @@ void CServiceImplCodeEmitter::EmitServiceImplHeaderFile() file.Close(); } +void CServiceImplCodeEmitter::EmitServiceImplHeaderInclusions(StringBuilder& sb) +{ + HeaderFile::HeaderFileSet headerFiles; + + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_MODULE_HEADER_FILE, FileName(interfaceName_))); + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); + } +} + void CServiceImplCodeEmitter::EmitServiceImplConstructDecl(StringBuilder& sb) { sb.AppendFormat("void %sServiceConstruct(struct %s* service);\n", infName_.string(), interfaceName_.string()); @@ -66,34 +79,16 @@ void CServiceImplCodeEmitter::EmitServiceImplConstructDecl(StringBuilder& sb) void CServiceImplCodeEmitter::EmitServiceImplSourceFile() { - String filePath; - if (!isCallbackInterface()) { - filePath = String::Format("%sserver/%s.c", directory_.string(), FileName(infName_ + "Service").string()); - } else { - filePath = String::Format("%s%s.c", directory_.string(), FileName(infName_ + "Service").string()); - } - - if (!File::CreateParentDir(filePath)) { - Logger::E("CServiceDriverCodeEmitter", "Create '%s' failed!", filePath.string()); - return; - } - + String filePath = String::Format("%s%s.c", directory_.string(), FileName(infName_ + "Service").string()); File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); - EmitServiceImplInclusions(sb); + EmitServiceImplSourceInclusions(sb); sb.Append("\n"); EmitServiceImplMethodImpls(sb, ""); sb.Append("\n"); EmitServiceImplConstruct(sb); - if (!isCallbackInterface()) { - sb.Append("\n"); - EmitServiceImplInstance(sb); - sb.Append("\n"); - EmitServiceImplRelease(sb); - } String data = sb.ToString(); file.WriteData(data.string(), data.GetLength()); @@ -101,13 +96,24 @@ void CServiceImplCodeEmitter::EmitServiceImplSourceFile() file.Close(); } -void CServiceImplCodeEmitter::EmitServiceImplInclusions(StringBuilder& sb) +void CServiceImplCodeEmitter::EmitServiceImplSourceInclusions(StringBuilder& sb) +{ + HeaderFile::HeaderFileSet headerFiles; + + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_HEADER_FILE, FileName(implName_))); + GetSourceOtherLibInclusions(headerFiles); + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); + } +} + +void CServiceImplCodeEmitter::GetSourceOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles) { - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.AppendFormat("#include \"%s.h\"\n", FileName(interfaceName_).string()); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_base")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_log")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "osal_mem")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "securec")); } void CServiceImplCodeEmitter::EmitServiceImplMethodImpls(StringBuilder& sb, const String& prefix) @@ -140,12 +146,12 @@ void CServiceImplCodeEmitter::EmitServiceImplMethodImpl(const AutoPtr } paramStr.Append(")"); - sb.Append(SpecificationParam(paramStr, prefix + TAB)); + sb.Append(SpecificationParam(paramStr, prefix + g_tab)); sb.Append("\n"); } sb.Append(prefix).Append("{\n"); - sb.Append(prefix + TAB).Append("return HDF_SUCCESS;\n"); + sb.Append(prefix + g_tab).Append("return HDF_SUCCESS;\n"); sb.Append(prefix).Append("}\n"); } @@ -157,38 +163,10 @@ void CServiceImplCodeEmitter::EmitServiceImplConstruct(StringBuilder& sb) sb.Append("{\n"); for (size_t i = 0; i < interface_->GetMethodNumber(); i++) { AutoPtr method = interface_->GetMethod(i); - sb.Append(TAB).AppendFormat("%s->%s = %s%s;\n", + sb.Append(g_tab).AppendFormat("%s->%s = %s%s;\n", objName.string(), method->GetName().string(), infName_.string(), method->GetName().string()); } - sb.Append("}\n"); -} - -void CServiceImplCodeEmitter::EmitServiceImplInstance(StringBuilder& sb) -{ - String objName("instance"); - sb.AppendFormat("struct %s *Hdi%sInstance()\n", interfaceName_.string(), infName_.string()); - sb.Append("{\n"); - sb.Append(TAB).AppendFormat("struct %s *%s = (struct %s*)OsalMemAlloc(sizeof(struct %s));\n", - interfaceName_.string(), objName.string(), interfaceName_.string(), interfaceName_.string()); - sb.Append(TAB).AppendFormat("if (%s == NULL) {\n", objName.string()); - sb.Append(TAB).Append(TAB).AppendFormat("HDF_LOGE(\"%%{public}s: OsalMemAlloc struct %s %s failed!\", __func__);\n", - interfaceName_.string(), objName.string()); - sb.Append(TAB).Append(TAB).Append("return NULL;\n"); - sb.Append(TAB).Append("}\n"); - sb.Append(TAB).AppendFormat("%sServiceConstruct(%s);\n", infName_.string(), objName.string()); - sb.Append(TAB).AppendFormat("return %s;\n", objName.string()); - sb.Append("}\n"); -} - -void CServiceImplCodeEmitter::EmitServiceImplRelease(StringBuilder& sb) -{ - sb.AppendFormat("void Hdi%sRelease(struct %s *instance)\n", infName_.string(), interfaceName_.string()); - sb.Append("{\n"); - sb.Append(TAB).Append("if (instance == NULL) {\n"); - sb.Append(TAB).Append(TAB).Append("return;\n"); - sb.Append(TAB).Append("}\n"); - sb.Append(TAB).Append("OsalMemFree(instance);\n"); - sb.Append("}\n"); + sb.Append("}"); } } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/codegen/c_service_impl_code_emitter.h b/tools/hdi-gen/codegen/c_service_impl_code_emitter.h index 99cc5ca1a59824a7f95a9a47610145908bb37ea9..c2bc8420685086a6f3aadd6dbf7265ddf546fa2e 100755 --- a/tools/hdi-gen/codegen/c_service_impl_code_emitter.h +++ b/tools/hdi-gen/codegen/c_service_impl_code_emitter.h @@ -15,19 +15,25 @@ namespace OHOS { namespace HDI { class CServiceImplCodeEmitter : public CCodeEmitter { public: - CServiceImplCodeEmitter(const AutoPtr& ast, const String& targetDirectory); + CServiceImplCodeEmitter() : CCodeEmitter() {} virtual ~CServiceImplCodeEmitter() = default; +private: + bool ResolveDirectory(const String& targetDirectory) override; void EmitCode() override; -private: + void EmitServiceImplHeaderFile(); + void EmitServiceImplHeaderInclusions(StringBuilder& sb); + void EmitServiceImplConstructDecl(StringBuilder& sb); void EmitServiceImplSourceFile(); - void EmitServiceImplInclusions(StringBuilder& sb); + void EmitServiceImplSourceInclusions(StringBuilder& sb); + + void GetSourceOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); void EmitServiceImplMethodImpls(StringBuilder& sb, const String& prefix); diff --git a/tools/hdi-gen/codegen/c_service_stub_code_emitter.cpp b/tools/hdi-gen/codegen/c_service_stub_code_emitter.cpp index e4d7794aa30af2063cac82608a61d9569441d5f5..4ccf0d70820fb4d0852c372612ba41069f91616d 100755 --- a/tools/hdi-gen/codegen/c_service_stub_code_emitter.cpp +++ b/tools/hdi-gen/codegen/c_service_stub_code_emitter.cpp @@ -13,38 +13,40 @@ namespace OHOS { namespace HDI { -CServiceStubCodeEmitter::CServiceStubCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - :CCodeEmitter(ast, targetDirectory) +bool CServiceStubCodeEmitter::ResolveDirectory(const String& targetDirectory) { - String infFullName = String::Format("%sserver.%s", - interface_->GetNamespace()->ToString().string(), infName_.string()); - sourceFileName_ = String::Format("%s_stub.c", FileName(infFullName).string()); + if (ast_->GetASTFileType() == ASTFileType::AST_IFACE || + ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) { + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); + } else { + return false; + } + + if (!File::CreateParentDir(directory_)) { + Logger::E("CServiceStubCodeEmitter", "Create '%s' failed!", directory_.string()); + return false; + } + + return true; } void CServiceStubCodeEmitter::EmitCode() { - if (isCallbackInterface()) { - EmitCbServiceStubHeaderFile(); - } + EmitServiceStubHeaderFile(); EmitServiceStubSourceFile(); } -void CServiceStubCodeEmitter::EmitCbServiceStubHeaderFile() +void CServiceStubCodeEmitter::EmitServiceStubHeaderFile() { String filePath = String::Format("%s%s.h", directory_.string(), FileName(stubName_).string()); - if (!File::CreateParentDir(filePath)) { - Logger::E("CServiceStubCodeEmitter", "Create '%s' failed!", filePath.string()); - return; - } - File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); EmitHeadMacro(sb, stubFullName_); sb.Append("\n"); - sb.AppendFormat("#include \"%s.h\"\n", FileName(interfaceName_).string()); + EmitStubHeaderInclusions(sb); sb.Append("\n"); EmitHeadExternC(sb); sb.Append("\n"); @@ -60,44 +62,65 @@ void CServiceStubCodeEmitter::EmitCbServiceStubHeaderFile() file.Close(); } -void CServiceStubCodeEmitter::EmitCbServiceStubMethodsDcl(StringBuilder& sb) +void CServiceStubCodeEmitter::EmitStubHeaderInclusions(StringBuilder& sb) { - sb.AppendFormat("struct %s* %sStubObtain();\n", interfaceName_.string(), infName_.string()); - sb.Append("\n"); - sb.AppendFormat("void %sStubRelease(struct %s *callback);\n", infName_.string(), interfaceName_.string()); + HeaderFile::HeaderFileSet headerFiles; + + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_MODULE_HEADER_FILE, FileName(interfaceName_))); + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); + } } -void CServiceStubCodeEmitter::EmitServiceStubSourceFile() +void CServiceStubCodeEmitter::EmitCbServiceStubMethodsDcl(StringBuilder& sb) { - String filePath; if (!isCallbackInterface()) { - filePath = String::Format("%sserver/%s.c", directory_.string(), FileName(stubName_).string()); - } else { - filePath = String::Format("%s%s.c", directory_.string(), FileName(stubName_).string()); - } - - if (!File::CreateParentDir(filePath)) { - Logger::E("CServiceStubCodeEmitter", "Create '%s' failed!", filePath.string()); - return; + sb.AppendFormat("int32_t %sServiceOnRemoteRequest(void *service, int cmdId, ", infName_.string()); + sb.Append("struct HdfSBuf *data, struct HdfSBuf *reply);\n"); + sb.Append("\n"); } + sb.AppendFormat("struct %s* %sStubGetInstance(void);\n", interfaceName_.string(), infName_.string()); + sb.Append("\n"); + sb.AppendFormat("void %sStubRelease(struct %s *instance);\n", infName_.string(), interfaceName_.string()); +} +void CServiceStubCodeEmitter::EmitServiceStubSourceFile() +{ + String filePath = String::Format("%s%s.c", directory_.string(), FileName(stubName_).string()); File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); - EmitServiceStubInclusions(sb); + EmitStubSourceInclusions(sb); sb.Append("\n"); - EmitServiceStubMethodImpls(sb, ""); - sb.Append("\n"); - EmitServiceStubOnRequestMethodImpl(sb, ""); - if (isCallbackInterface()) { + + if (!isKernelCode_) { + EmitDriverLibPath(sb); + sb.Append("\n"); + EmitServConstructTypedef(sb); sb.Append("\n"); EmitCbStubDefinitions(sb); sb.Append("\n"); - EmitCbStubObtainImpl(sb); + } + + EmitServiceStubMethodImpls(sb, ""); + sb.Append("\n"); + EmitServiceStubOnRequestMethodImpl(sb, ""); + sb.Append("\n"); + if (isKernelCode_) { + EmitKernelStubGetMethodImpl(sb); + } else { + EmitStubLinkService(sb); sb.Append("\n"); - EmitCbStubReleaseImpl(sb); + EmitStubGetMethodImpl(sb); + } + + sb.Append("\n"); + if (isKernelCode_) { + EmitKernelStubReleaseImpl(sb); + } else { + EmitStubReleaseImpl(sb); } String data = sb.ToString(); @@ -106,36 +129,81 @@ void CServiceStubCodeEmitter::EmitServiceStubSourceFile() file.Close(); } -void CServiceStubCodeEmitter::EmitServiceStubInclusions(StringBuilder& sb) +void CServiceStubCodeEmitter::EmitStubSourceInclusions(StringBuilder& sb) { + HeaderFile::HeaderFileSet headerFiles; if (!isCallbackInterface()) { - EmitServiceStubStdlibInclusions(sb); - sb.AppendFormat("#include \"%s.h\"\n", FileName(interfaceName_).string()); + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_HEADER_FILE, FileName(stubName_))); + if (isKernelCode_) { + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_MODULE_HEADER_FILE, FileName(implName_))); + } else { + for (const auto& importPair : ast_->GetImports()) { + AutoPtr importAst = importPair.second; + if (importAst->GetASTFileType() == ASTFileType::AST_ICALLBACK) { + String fileName = FileName(importAst->GetInterfaceDef()->GetFullName()); + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_MODULE_HEADER_FILE, fileName)); + } + } + } } else { - sb.AppendFormat("#include \"%s.h\"\n", FileName(stubFullName_).string()); - EmitServiceStubStdlibInclusions(sb); - sb.Append("#include \n"); - sb.AppendFormat("#include \"%s.h\"\n", FileName(ImplName_).string()); + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_HEADER_FILE, FileName(stubName_))); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_remote_service")); + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_MODULE_HEADER_FILE, FileName(implName_))); + } + + GetSourceOtherLibInclusions(headerFiles); + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); } } -void CServiceStubCodeEmitter::EmitServiceStubStdlibInclusions(StringBuilder& sb) +void CServiceStubCodeEmitter::GetSourceOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles) { - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.Append("#include \n"); - - const AST::TypeStringMap& types = ast_->GetTypes(); - int i = 0; - for (const auto& pair : types) { - AutoPtr type = pair.second; - if (type->GetTypeKind() == TypeKind::TYPE_UNION) { - sb.Append("#include \n"); - break; + if (!isKernelCode_) { + headerFiles.emplace(HeaderFile(HeaderFileType::SYSTEM_HEADER_FILE, "dlfcn")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "securec")); + } else { + const AST::TypeStringMap& types = ast_->GetTypes(); + for (const auto& pair : types) { + AutoPtr type = pair.second; + if (type->GetTypeKind() == TypeKind::TYPE_UNION) { + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "securec")); + break; + } } } + + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_base")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_device_desc")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_log")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_sbuf")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "osal_mem")); +} + +void CServiceStubCodeEmitter::EmitDriverLibPath(StringBuilder& sb) +{ + sb.Append("#ifdef __ARM64__\n"); + sb.Append("#define DRIVER_PATH \"system/lib64\"\n"); + sb.Append("#else\n"); + sb.Append("#define DRIVER_PATH \"system/lib\"\n"); + sb.Append("#endif\n"); +} + +void CServiceStubCodeEmitter::EmitServConstructTypedef(StringBuilder& sb) +{ + sb.AppendFormat("typedef void (*SERVICE_CONSTRUCT_FUNC)(struct %s *);\n", interfaceName_.string()); +} + +void CServiceStubCodeEmitter::EmitCbStubDefinitions(StringBuilder& sb) +{ + sb.AppendFormat("struct %sStub {\n", infName_.string()); + sb.Append(g_tab).AppendFormat("struct %s service;\n", interfaceName_.string()); + if (isCallbackInterface()) { + sb.Append(g_tab).Append("struct HdfRemoteDispatcher dispatcher;\n"); + } + sb.Append(g_tab).Append("void *dlHandler;\n"); + sb.Append("};\n"); } void CServiceStubCodeEmitter::EmitServiceStubMethodImpls(StringBuilder& sb, const String& prefix) @@ -152,65 +220,57 @@ void CServiceStubCodeEmitter::EmitServiceStubMethodImpls(StringBuilder& sb, cons void CServiceStubCodeEmitter::EmitServiceStubMethodImpl(const AutoPtr& method, StringBuilder& sb, const String& prefix) { + String dataName = "data_"; + String replyName = "reply_"; sb.Append(prefix).AppendFormat( - "static int32_t SerStub%s(struct %s *serviceImpl, struct HdfSBuf *data, struct HdfSBuf *reply)\n", - method->GetName().string(), interfaceName_.string()); + "static int32_t SerStub%s(struct %s *serviceImpl, struct HdfSBuf *%s, struct HdfSBuf *%s)\n", + method->GetName().string(), interfaceName_.string(), dataName.string(), replyName.string()); sb.Append(prefix).Append("{\n"); + sb.Append(prefix + g_tab).Append("int32_t ec = HDF_FAILURE;\n"); - sb.Append(prefix + TAB).Append("int32_t ec = HDF_FAILURE;\n"); + // Local variable definitions must precede all execution statements. + if (isKernelCode_) { + for (size_t i = 0; i < method->GetParameterNumber(); i++) { + AutoPtr param = method->GetParameter(i); + AutoPtr type = param->GetType(); + if (type->GetTypeKind() == TypeKind::TYPE_ARRAY || + type->GetTypeKind() == TypeKind::TYPE_LIST) { + sb.Append(prefix + g_tab).Append("uint32_t i = 0;\n"); + break; + } + } + } + String gotoName = "errors"; if (method->GetParameterNumber() > 0) { for (size_t i = 0; i < method->GetParameterNumber(); i++) { AutoPtr param = method->GetParameter(i); - EmitStubLocalVariable(param, sb, prefix + TAB); + EmitStubLocalVariable(param, sb, prefix + g_tab); } sb.Append("\n"); for (int i = 0; i < method->GetParameterNumber(); i++) { AutoPtr param = method->GetParameter(i); if (param->GetAttribute() == ParamAttr::PARAM_IN) { - EmitReadStubMethodParameter(param, "data", sb, prefix + TAB); + EmitReadStubMethodParameter(param, dataName, sb, prefix + g_tab); sb.Append("\n"); } } } - if (method->GetParameterNumber() == 0) { - sb.Append(prefix + TAB).AppendFormat("ec = serviceImpl->%s(serviceImpl);\n", method->GetName().string()); - } else { - sb.Append(prefix + TAB).AppendFormat("ec = serviceImpl->%s(serviceImpl, ", method->GetName().string()); - for (size_t i = 0; i < method->GetParameterNumber(); i++) { - AutoPtr param = method->GetParameter(i); - EmitCallParameter(sb, param->GetType(), param->GetAttribute(), param->GetName()); - if (i + 1 < method->GetParameterNumber()) { - sb.Append(", "); - } - } - sb.AppendFormat(");\n", method->GetName().string()); - } - - sb.Append(prefix + TAB).Append("if (ec != HDF_SUCCESS) {\n"); - sb.Append(prefix + TAB + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: call %s function failed!\", __func__);\n", method->GetName().string()); - sb.Append(prefix + TAB + TAB).Append("goto errors;\n"); - sb.Append(prefix + TAB).Append("}\n"); + EmitStubCallMethod(method, gotoName, sb, prefix + g_tab); sb.Append("\n"); for (int i = 0; i < method->GetParameterNumber(); i++) { AutoPtr param = method->GetParameter(i); if (param->GetAttribute() == ParamAttr::PARAM_OUT) { - EmitWriteStubMethodParameter(param, "reply", sb, prefix + TAB); + param->EmitCWriteVar(replyName, gotoName, sb, prefix + g_tab); sb.Append("\n"); } } - sb.Append(prefix).Append("errors:\n"); - for (int i = 0; i < method->GetParameterNumber(); i++) { - AutoPtr param = method->GetParameter(i); - EmitError(param, sb, prefix + TAB); - } - - sb.Append(prefix + TAB).Append("return ec;\n"); + EmitErrorHandle(method, gotoName, false, sb, prefix); + sb.Append(prefix + g_tab).Append("return ec;\n"); sb.Append(prefix).Append("}\n"); } @@ -230,17 +290,15 @@ void CServiceStubCodeEmitter::EmitReadStubMethodParameter(const AutoPtr type = param->GetType(); if (type->GetTypeKind() == TypeKind::TYPE_STRING) { - String cloneName = String::Format("%sCp", param->GetName().string()); - type->EmitCStubReadVar(parcelName, cloneName, sb, prefix); - sb.Append(prefix).AppendFormat("%s = strdup(%s);\n", param->GetName().string(), cloneName.string()); + EmitReadCStringStubMethodParameter(param, parcelName, sb, prefix, type); } else if (type->GetTypeKind() == TypeKind::TYPE_INTERFACE) { type->EmitCStubReadVar(parcelName, param->GetName(), sb, prefix); } else if (type->GetTypeKind() == TypeKind::TYPE_STRUCT) { sb.Append(prefix).AppendFormat("%s = (%s*)OsalMemAlloc(sizeof(%s));\n", param->GetName().string(), type->EmitCType(TypeMode::NO_MODE).string(), type->EmitCType(TypeMode::NO_MODE).string()); sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", param->GetName().string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); type->EmitCStubReadVar(parcelName, param->GetName(), sb, prefix); } else if (type->GetTypeKind() == TypeKind::TYPE_UNION) { @@ -249,8 +307,8 @@ void CServiceStubCodeEmitter::EmitReadStubMethodParameter(const AutoPtrGetName().string(), type->EmitCType(TypeMode::NO_MODE).string(), type->EmitCType(TypeMode::NO_MODE).string()); sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", param->GetName().string()); - sb.Append(prefix + TAB).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); - sb.Append(prefix + TAB).Append("goto errors;\n"); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); sb.Append(prefix).Append("}\n"); sb.Append(prefix).AppendFormat("(void)memcpy_s(%s, sizeof(%s), %s, sizeof(%s));\n", param->GetName().string(), type->EmitCType(TypeMode::NO_MODE).string(), cpName.string(), type->EmitCType(TypeMode::NO_MODE).string()); @@ -264,11 +322,53 @@ void CServiceStubCodeEmitter::EmitReadStubMethodParameter(const AutoPtr& param, - const String& parcelName, StringBuilder& sb, const String& prefix) +void CServiceStubCodeEmitter::EmitReadCStringStubMethodParameter(const AutoPtr& param, + const String& parcelName, StringBuilder& sb, const String& prefix, AutoPtr& type) { - AutoPtr type = param->GetType(); - type->EmitCStubWriteVar(parcelName, param->GetName(), sb, prefix); + String cloneName = String::Format("%sCp", param->GetName().string()); + type->EmitCStubReadVar(parcelName, cloneName, sb, prefix); + if (isKernelCode_) { + sb.Append("\n"); + sb.Append(prefix).AppendFormat("%s = (char*)OsalMemCalloc(strlen(%s) + 1);\n", + param->GetName().string(), cloneName.string()); + sb.Append(prefix).AppendFormat("if (%s == NULL) {\n", param->GetName().string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_MALLOC_FAIL;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); + sb.Append(prefix).Append("}\n\n"); + sb.Append(prefix).AppendFormat("if (strcpy_s(%s, (strlen(%s) + 1), %s) != HDF_SUCCESS) {\n", + param->GetName().string(), cloneName.string(), cloneName.string()); + sb.Append(prefix + g_tab).AppendFormat("HDF_LOGE(\"%%{public}s: read %s failed!\", __func__);\n", + param->GetName().string()); + sb.Append(prefix + g_tab).Append("ec = HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab).Append("goto errors;\n"); + sb.Append(prefix).Append("}\n"); + } else { + sb.Append(prefix).AppendFormat("%s = strdup(%s);\n", param->GetName().string(), cloneName.string()); + } +} + +void CServiceStubCodeEmitter::EmitStubCallMethod(const AutoPtr& method, const String& gotoLabel, + StringBuilder& sb, const String& prefix) +{ + if (method->GetParameterNumber() == 0) { + sb.Append(prefix).AppendFormat("ec = serviceImpl->%s(serviceImpl);\n", method->GetName().string()); + } else { + sb.Append(prefix).AppendFormat("ec = serviceImpl->%s(serviceImpl, ", method->GetName().string()); + for (size_t i = 0; i < method->GetParameterNumber(); i++) { + AutoPtr param = method->GetParameter(i); + EmitCallParameter(sb, param->GetType(), param->GetAttribute(), param->GetName()); + if (i + 1 < method->GetParameterNumber()) { + sb.Append(", "); + } + } + sb.AppendFormat(");\n", method->GetName().string()); + } + + sb.Append(prefix).Append("if (ec != HDF_SUCCESS) {\n"); + sb.Append(prefix + g_tab).AppendFormat( + "HDF_LOGE(\"%%{public}s: call %s function failed!\", __func__);\n", method->GetName().string()); + sb.Append(prefix + g_tab).AppendFormat("goto %s;\n", gotoLabel.string()); + sb.Append(prefix).Append("}\n"); } void CServiceStubCodeEmitter::EmitCallParameter(StringBuilder& sb, const AutoPtr& type, ParamAttr attribute, @@ -287,162 +387,161 @@ void CServiceStubCodeEmitter::EmitCallParameter(StringBuilder& sb, const AutoPtr } } - -void CServiceStubCodeEmitter::EmitError(const AutoPtr& param, StringBuilder& sb, const String& prefix) -{ - AutoPtr type = param->GetType(); - switch (type->GetTypeKind()) { - case TypeKind::TYPE_STRING: - case TypeKind::TYPE_UNION: { - sb.Append(prefix).AppendFormat("if (%s != NULL) {\n", param->GetName().string()); - sb.Append(prefix + TAB).AppendFormat("OsalMemFree(%s);\n", param->GetName().string()); - sb.Append(prefix).Append("}\n\n"); - break; - } - case TypeKind::TYPE_ARRAY: { - String lenName = String::Format("%sLen", param->GetName().string()); - sb.Append(prefix).AppendFormat("if (%s > 0 && %s != NULL) {\n", - lenName.string(), param->GetName().string()); - - AutoPtr arrayType = dynamic_cast(type.Get()); - AutoPtr elementType = arrayType->GetElementType(); - - if (elementType->GetTypeKind() == TypeKind::TYPE_STRING - || elementType->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append(prefix + TAB).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); - String elementName = String::Format("%s[i]", param->GetName().string()); - if (elementType->GetTypeKind() == TypeKind::TYPE_STRING) { - sb.Append(prefix + TAB + TAB).AppendFormat("if (%s != NULL) {\n", elementName.string()); - sb.Append(prefix + TAB + TAB + TAB).AppendFormat("OsalMemFree(%s);\n", elementName.string()); - sb.Append(prefix + TAB + TAB).Append("}\n"); - } else if (elementType->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append(prefix + TAB + TAB + TAB).AppendFormat("%sFree(&%s, false);\n", - elementType->GetName().string(), elementName.string()); - } - sb.Append(prefix + TAB).Append("}\n"); - } - sb.Append(prefix + TAB).AppendFormat("OsalMemFree(%s);\n", param->GetName().string()); - sb.Append(prefix).Append("}\n"); - sb.Append("\n"); - break; - } - case TypeKind::TYPE_LIST: { - String lenName = String::Format("%sLen", param->GetName().string()); - sb.Append(prefix).AppendFormat("if (%s > 0 && %s != NULL) {\n", - lenName.string(), param->GetName().string()); - - AutoPtr listType = dynamic_cast(type.Get()); - AutoPtr elementType = listType->GetElementType(); - - if (elementType->GetTypeKind() == TypeKind::TYPE_STRING - || elementType->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append(prefix + TAB).AppendFormat("for (uint32_t i = 0; i < %s; i++) {\n", lenName.string()); - String elementName = String::Format("%s[i]", param->GetName().string()); - if (elementType->GetTypeKind() == TypeKind::TYPE_STRING) { - sb.Append(prefix + TAB + TAB).AppendFormat("if (%s != NULL) {\n", elementName.string()); - sb.Append(prefix + TAB + TAB + TAB).AppendFormat("OsalMemFree(%s);\n", elementName.string()); - sb.Append(prefix + TAB + TAB).Append("}\n"); - } else if (elementType->GetTypeKind() == TypeKind::TYPE_STRUCT) { - sb.Append(prefix + TAB + TAB + TAB).AppendFormat("%sFree(&%s, false);\n", - elementType->GetName().string(), elementName.string()); - } - sb.Append(prefix + TAB).Append("}\n"); - } - sb.Append(prefix + TAB).AppendFormat("OsalMemFree(%s);\n", param->GetName().string()); - sb.Append(prefix).Append("}\n"); - sb.Append("\n"); - break; - } - case TypeKind::TYPE_STRUCT: { - sb.Append(prefix).AppendFormat("if (%s != NULL) {\n", param->GetName().string()); - sb.Append(prefix + TAB).AppendFormat("%sFree(%s, true);\n", - type->GetName().string(), param->GetName().string()); - sb.Append(prefix).Append("}\n\n"); - break; - } - default: - break; - } -} - void CServiceStubCodeEmitter::EmitServiceStubOnRequestMethodImpl(StringBuilder& sb, const String& prefix) { String codeName; if (!isCallbackInterface()) { codeName = "cmdId"; - sb.Append(prefix).AppendFormat("int32_t %sServiceOnRemoteRequest(void *service, int %s,\n", + sb.Append(prefix).AppendFormat("int32_t %sServiceOnRemoteRequest(void *service, int %s, ", infName_.string(), codeName.string()); + sb.Append("struct HdfSBuf *data, struct HdfSBuf *reply)\n"); } else { codeName = "code"; sb.Append(prefix).AppendFormat("int32_t %sServiceOnRemoteRequest(struct HdfRemoteService *service, int %s,\n", infName_.string(), codeName.string()); + sb.Append(prefix + g_tab).Append("struct HdfSBuf *data, struct HdfSBuf *reply)\n"); } - sb.Append(prefix + TAB).Append("struct HdfSBuf *data, struct HdfSBuf *reply)\n"); sb.Append(prefix).Append("{\n"); - sb.Append(prefix + TAB).AppendFormat("struct %s *serviceImpl = (struct %s*)service;\n", + sb.Append(prefix + g_tab).AppendFormat("struct %s *serviceImpl = (struct %s*)service;\n", interfaceName_.string(), interfaceName_.string()); - sb.Append(prefix + TAB).AppendFormat("switch (%s) {\n", codeName.string()); + sb.Append(prefix + g_tab).AppendFormat("switch (%s) {\n", codeName.string()); for (size_t i = 0; i < interface_->GetMethodNumber(); i++) { AutoPtr method = interface_->GetMethod(i); - sb.Append(prefix + TAB + TAB).AppendFormat("case CMD_%s:\n", ConstantName(method->GetName()).string()); - sb.Append(prefix + TAB + TAB + TAB).AppendFormat("return SerStub%s(serviceImpl, data, reply);\n", + sb.Append(prefix + g_tab + g_tab).AppendFormat("case CMD_%s:\n", ConstantName(method->GetName()).string()); + sb.Append(prefix + g_tab + g_tab + g_tab).AppendFormat("return SerStub%s(serviceImpl, data, reply);\n", method->GetName().string()); } - sb.Append(prefix + TAB + TAB).Append("default: {\n"); - sb.Append(prefix + TAB + TAB + TAB).AppendFormat( + sb.Append(prefix + g_tab + g_tab).Append("default: {\n"); + sb.Append(prefix + g_tab + g_tab + g_tab).AppendFormat( "HDF_LOGE(\"%%{public}s: not support cmd %%{public}d\", __func__, %s);\n", codeName.string()); - sb.Append(prefix + TAB + TAB + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB + TAB).Append("}\n"); - sb.Append(prefix + TAB).Append("}\n"); + sb.Append(prefix + g_tab + g_tab + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab + g_tab).Append("}\n"); + sb.Append(prefix + g_tab).Append("}\n"); sb.Append("}\n"); } -void CServiceStubCodeEmitter::EmitCbStubDefinitions(StringBuilder& sb) +void CServiceStubCodeEmitter::EmitStubLinkService(StringBuilder& sb) { - sb.AppendFormat("struct %sStub {\n", infName_.string()); - sb.Append(TAB).AppendFormat("struct %s service;\n", interfaceName_.string()); - sb.Append(TAB).Append("struct HdfRemoteDispatcher dispatcher;\n"); - sb.Append("};\n"); + sb.Append("static void *LoadServiceHandler(const char* libFileName)\n"); + sb.Append("{\n"); + sb.Append(g_tab).Append("char path[PATH_MAX + 1] = {0};\n"); + sb.Append(g_tab).Append("char libPath[PATH_MAX + 1] = {0};\n"); + sb.Append(g_tab).Append("void *handler = NULL;\n"); + sb.Append("\n"); + sb.Append(g_tab).AppendFormat("if (snprintf_s(path, sizeof(path), sizeof(path) - 1, \"%%s/%%s\", "); + sb.Append("DRIVER_PATH, libFileName) < 0) {\n"); + sb.Append(g_tab).Append(g_tab).Append("HDF_LOGE(\"%{public}s: snprintf_s failed\", __func__);\n"); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n"); + sb.Append("\n"); + sb.Append(g_tab).Append("if (realpath(path, libPath) == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).Append("HDF_LOGE(\"%{public}s file name invalid\", __func__);\n"); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n"); + sb.Append("\n"); + sb.Append(g_tab).Append("handler = dlopen(libPath, RTLD_LAZY);\n"); + sb.Append(g_tab).Append("if (handler == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).Append("HDF_LOGE(\"%{public}s: dlopen failed %{public}s\", "); + sb.AppendFormat("__func__, dlerror());\n"); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n"); + sb.Append("\n"); + sb.Append(g_tab).Append("return handler;\n"); + sb.Append("}\n"); } -void CServiceStubCodeEmitter::EmitCbStubObtainImpl(StringBuilder& sb) +void CServiceStubCodeEmitter::EmitStubGetMethodImpl(StringBuilder& sb) { + String libName = String::Format("lib%s.z.so", FileName(implName_).string()); String stubTypeName = String::Format("%sStub", infName_.string()); String objName = "stub"; - sb.AppendFormat("struct %s* %sStubObtain()\n", interfaceName_.string(), infName_.string()); + sb.AppendFormat("struct %s *%sStubGetInstance(void)\n", interfaceName_.string(), infName_.string()); sb.Append("{\n"); - sb.Append(TAB).AppendFormat("struct %s* %s = (struct %s*)OsalMemAlloc(sizeof(struct %s));\n", + sb.Append(g_tab).AppendFormat("SERVICE_CONSTRUCT_FUNC serviceConstructFunc = NULL;\n", libName.string()); + sb.Append(g_tab).AppendFormat("struct %s *%s = (struct %s *)OsalMemAlloc(sizeof(struct %s));\n", stubTypeName.string(), objName.string(), stubTypeName.string(), stubTypeName.string()); - sb.Append(TAB).AppendFormat("if (stub == NULL) {\n", objName.string()); - sb.Append(TAB).Append(TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: OsalMemAlloc %s obj failed!\", __func__);\n", stubTypeName.string()); - sb.Append(TAB).Append(TAB).AppendFormat("return NULL;\n"); - sb.Append(TAB).Append("}\n\n"); - sb.Append(TAB).AppendFormat("%s->dispatcher.Dispatch = %sServiceOnRemoteRequest;\n", + sb.Append(g_tab).AppendFormat("if (%s == NULL) {\n", objName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("HDF_LOGE(\"%%{public}s: OsalMemAlloc obj failed!\", __func__);\n", + stubTypeName.string()); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n\n"); + if (isCallbackInterface()) { + sb.Append(g_tab).AppendFormat("%s->dispatcher.Dispatch = %sServiceOnRemoteRequest;\n", + objName.string(), infName_.string()); + sb.Append(g_tab).AppendFormat( + "%s->service.remote = HdfRemoteServiceObtain((struct HdfObject*)%s, &(%s->dispatcher));\n", + objName.string(), objName.string(), objName.string()); + sb.Append(g_tab).AppendFormat("if (%s->service.remote == NULL) {\n", objName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat( + "HDF_LOGE(\"%%{public}s: %s->service.remote is null\", __func__);\n", objName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("OsalMemFree(%s);\n", objName.string()); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n\n"); + } + sb.Append(g_tab).AppendFormat("%s->dlHandler = LoadServiceHandler(\"lib%s.z.so\");\n", + objName.string(), FileName(implName_).string()); + sb.Append(g_tab).AppendFormat("if (%s->dlHandler == NULL) {\n", objName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("HDF_LOGE(\"%%{public}s: %s->dlHanlder is null\", __func__);\n", + objName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("OsalMemFree(%s);\n", objName.string()); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n\n"); + sb.Append(g_tab).AppendFormat("serviceConstructFunc = "); + sb.AppendFormat("(SERVICE_CONSTRUCT_FUNC)dlsym(%s->dlHandler, \"%sServiceConstruct\");\n", objName.string(), infName_.string()); - sb.Append(TAB).AppendFormat( - "%s->service.remote = HdfRemoteServiceObtain((struct HdfObject*)%s, &(%s->dispatcher));\n", - objName.string(), objName.string(), objName.string()); - sb.Append(TAB).AppendFormat("if (%s->service.remote == NULL) {\n", objName.string()); - sb.Append(TAB).Append(TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: %s->service.remote is null\", __func__);\n", objName.string()); - sb.Append(TAB).Append(TAB).Append("return NULL;\n"); - sb.Append(TAB).Append("}\n\n"); - sb.Append(TAB).AppendFormat("%sServiceConstruct(&%s->service);\n", infName_.string(), objName.string()); - sb.Append(TAB).AppendFormat("return &%s->service;\n", objName.string()); + sb.Append(g_tab).Append("if (serviceConstructFunc == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).Append("HDF_LOGE(\"%{public}s: dlsym failed %{public}s\", __func__, dlerror());\n"); + sb.Append(g_tab).Append(g_tab).AppendFormat("dlclose(%s->dlHandler);\n", objName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("OsalMemFree(%s);\n", objName.string()); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n\n"); + sb.Append(g_tab).AppendFormat("serviceConstructFunc(&%s->service);\n", objName.string()); + sb.Append(g_tab).AppendFormat("return &%s->service;\n", objName.string()); + sb.Append("}\n"); +} + +void CServiceStubCodeEmitter::EmitKernelStubGetMethodImpl(StringBuilder& sb) +{ + String objName("instance"); + sb.AppendFormat("struct %s *%sStubGetInstance(void)\n", interfaceName_.string(), infName_.string()); + sb.Append("{\n"); + sb.Append(g_tab).AppendFormat("struct %s *%s = (struct %s*)OsalMemAlloc(sizeof(struct %s));\n", + interfaceName_.string(), objName.string(), interfaceName_.string(), interfaceName_.string()); + sb.Append(g_tab).AppendFormat("if (%s == NULL) {\n", objName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat( + "HDF_LOGE(\"%%{public}s: OsalMemAlloc struct %s %s failed!\", __func__);\n", + interfaceName_.string(), objName.string()); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n"); + sb.Append(g_tab).AppendFormat("%sServiceConstruct(%s);\n", infName_.string(), objName.string()); + sb.Append(g_tab).AppendFormat("return %s;\n", objName.string()); sb.Append("}\n"); } -void CServiceStubCodeEmitter::EmitCbStubReleaseImpl(StringBuilder& sb) +void CServiceStubCodeEmitter::EmitStubReleaseImpl(StringBuilder& sb) +{ + sb.AppendFormat("void %sStubRelease(struct %s *instance)\n", infName_.string(), interfaceName_.string()); + sb.Append("{\n"); + sb.Append(g_tab).Append("if (instance == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).Append("return;\n"); + sb.Append(g_tab).Append("}\n"); + sb.Append(g_tab).AppendFormat("struct %s *stub = CONTAINER_OF(instance, struct %s, service);\n", + stubName_.string(), stubName_.string()); + sb.Append(g_tab).Append("dlclose(stub->dlHandler);\n"); + sb.Append(g_tab).Append("OsalMemFree(stub);\n"); + sb.Append("}"); +} + +void CServiceStubCodeEmitter::EmitKernelStubReleaseImpl(StringBuilder& sb) { - sb.AppendFormat("void %sStubRelease(struct %s *stub)\n", infName_.string(), interfaceName_.string()); + sb.AppendFormat("void %sStubRelease(struct %s *instance)\n", infName_.string(), interfaceName_.string()); sb.Append("{\n"); - sb.Append(TAB).Append("if (stub == NULL) {\n"); - sb.Append(TAB).Append(TAB).Append("return;\n"); - sb.Append(TAB).Append("}\n"); - sb.Append(TAB).Append("OsalMemFree(stub);\n"); + sb.Append(g_tab).Append("if (instance == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).Append("return;\n"); + sb.Append(g_tab).Append("}\n"); + sb.Append(g_tab).Append("OsalMemFree(instance);\n"); sb.Append("}"); } } // namespace HDI diff --git a/tools/hdi-gen/codegen/c_service_stub_code_emitter.h b/tools/hdi-gen/codegen/c_service_stub_code_emitter.h index 38bad234a28551c2502d9194da0c39b4c9bab294..e888015e551b4096c20c625a1d6de3a736cbd6b2 100755 --- a/tools/hdi-gen/codegen/c_service_stub_code_emitter.h +++ b/tools/hdi-gen/codegen/c_service_stub_code_emitter.h @@ -15,22 +15,29 @@ namespace OHOS { namespace HDI { class CServiceStubCodeEmitter : public CCodeEmitter { public: - CServiceStubCodeEmitter(const AutoPtr& ast, const String& targetDirectory); + CServiceStubCodeEmitter() : CCodeEmitter() {} virtual ~CServiceStubCodeEmitter() = default; +private: + bool ResolveDirectory(const String& targetDirectory) override; void EmitCode() override; -private: - void EmitCbServiceStubHeaderFile(); + void EmitServiceStubHeaderFile(); + + void EmitStubHeaderInclusions(StringBuilder& sb); void EmitCbServiceStubMethodsDcl(StringBuilder& sb); void EmitServiceStubSourceFile(); - void EmitServiceStubInclusions(StringBuilder& sb); + void EmitStubSourceInclusions(StringBuilder& sb); + + void GetSourceOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); + + void EmitDriverLibPath(StringBuilder& sb); - void EmitServiceStubStdlibInclusions(StringBuilder& sb); + void EmitServConstructTypedef(StringBuilder& sb); void EmitServiceStubMethodImpls(StringBuilder& sb, const String& prefix); @@ -41,26 +48,27 @@ private: void EmitReadStubMethodParameter(const AutoPtr& param, const String& parcelName, StringBuilder& sb, const String& prefix); - void EmitReadStubVariable(const String& parcelName, const String& name, const AutoPtr& type, - StringBuilder& sb, const String& prefix); + void EmitReadCStringStubMethodParameter(const AutoPtr& param, const String& parcelName, + StringBuilder& sb, const String& prefix, AutoPtr& type); - void EmitWriteStubMethodParameter(const AutoPtr& param, const String& parcelName, StringBuilder& sb, + void EmitStubCallMethod(const AutoPtr& method, const String& gotoLabel, StringBuilder& sb, const String& prefix); - void EmitWriteStubVariable(const String& parcelName, const String& name, const AutoPtr& type, - StringBuilder& sb, const String& prefix); - void EmitCallParameter(StringBuilder& sb, const AutoPtr& type, ParamAttr attribute, const String& name); - void EmitError(const AutoPtr& param, StringBuilder& sb, const String& prefix); - void EmitServiceStubOnRequestMethodImpl(StringBuilder& sb, const String& prefix); void EmitCbStubDefinitions(StringBuilder& sb); - void EmitCbStubObtainImpl(StringBuilder& sb); + void EmitStubGetMethodImpl(StringBuilder& sb); + + void EmitKernelStubGetMethodImpl(StringBuilder& sb); + + void EmitStubLinkService(StringBuilder& sb); + + void EmitStubReleaseImpl(StringBuilder& sb); - void EmitCbStubReleaseImpl(StringBuilder& sb); + void EmitKernelStubReleaseImpl(StringBuilder& sb); }; } // namespace HDI } // namespace OHOS diff --git a/tools/hdi-gen/codegen/code_emitter.cpp b/tools/hdi-gen/codegen/code_emitter.cpp new file mode 100755 index 0000000000000000000000000000000000000000..e092349fa15074dd15073f884e4430dff0fd55f5 --- /dev/null +++ b/tools/hdi-gen/codegen/code_emitter.cpp @@ -0,0 +1,74 @@ +/* + * Copyright (c) 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 "codegen/code_emitter.h" + +namespace OHOS { +namespace HDI { +bool CodeEmitter::OutPut(const AutoPtr& ast, const String& targetDirectory, bool isKernelCode) +{ + if (!Reset(ast, targetDirectory, isKernelCode)) { + return false; + } + + EmitCode(); + return true; +} + +bool CodeEmitter::Reset(const AutoPtr& ast, const String& targetDirectory, bool isKernelCode) +{ + if (ast == nullptr || targetDirectory.Equals("")) { + return false; + } + + CleanData(); + + isKernelCode_ = isKernelCode; + ast_ = ast; + if (ast_->GetASTFileType() == ASTFileType::AST_IFACE || ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) { + interface_ = ast_->GetInterfaceDef(); + interfaceName_ = interface_->GetName(); + interfaceFullName_ = interface_->GetNamespace()->ToString() + interfaceName_; + infName_ = interfaceName_.StartsWith("I") ? interfaceName_.Substring(1) : interfaceName_; + proxyName_ = infName_ + "Proxy"; + proxyFullName_ = interface_->GetNamespace()->ToString() + proxyName_; + + stubName_ = infName_ + "Stub"; + stubFullName_ = interface_->GetNamespace()->ToString() + stubName_; + + implName_ = infName_ + "Service"; + implFullName_ = interface_->GetNamespace()->ToString() + implName_; + } else if (ast_->GetASTFileType() == ASTFileType::AST_TYPES) { + infName_ = ast_->GetName(); + } + + if (!ResolveDirectory(targetDirectory)) { + return false; + } + + return true; +} + +void CodeEmitter::CleanData() +{ + isKernelCode_ = false; + ast_ = nullptr; + interface_ = nullptr; + directory_ = ""; + interfaceName_ = ""; + interfaceFullName_ = ""; + infName_ = ""; + proxyName_ = ""; + proxyFullName_ = ""; + stubName_ = ""; + stubFullName_ = ""; + implName_ = ""; + implFullName_ = ""; +} +} // namespace HDI +} // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/codegen/code_emitter.h b/tools/hdi-gen/codegen/code_emitter.h new file mode 100755 index 0000000000000000000000000000000000000000..296bce28bfc4d74dcc1ea9da85baa51b77954169 --- /dev/null +++ b/tools/hdi-gen/codegen/code_emitter.h @@ -0,0 +1,100 @@ +/* + * Copyright (c) 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 OHOS_HDI_CODE_EMITTER_H +#define OHOS_HDI_CODE_EMITTER_H + +#include +#include "ast/ast.h" +#include "util/autoptr.h" +#include "util/light_refcount_base.h" +#include "util/string.h" + +namespace OHOS { +namespace HDI { +enum class HeaderFileType { + OWN_HEADER_FILE, + SYSTEM_HEADER_FILE, + C_STD_HEADER_FILE, + CPP_STD_HEADER_FILE, + OTHER_MODULES_HEADER_FILE, + OWN_MODULE_HEADER_FILE, +}; + +struct HeaderFile { + HeaderFile(HeaderFileType type, String fileName) : type_(type), fileName_(fileName) {} + + struct compare { + bool operator()(const HeaderFile& lhs, const HeaderFile& rhs) + { + if (lhs.type_ < rhs.type_) { + return true; + } else if (lhs.type_ > rhs.type_) { + return false; + } + + return lhs.fileName_.Compare(rhs.fileName_) <= 0; + } + }; + + String ToString() const { + switch(type_) { + case HeaderFileType::OWN_HEADER_FILE: + case HeaderFileType::OWN_MODULE_HEADER_FILE: + return String::Format("#include \"%s.h\"", fileName_.string()); + case HeaderFileType::SYSTEM_HEADER_FILE: + case HeaderFileType::C_STD_HEADER_FILE: + case HeaderFileType::OTHER_MODULES_HEADER_FILE: + return String::Format("#include <%s.h>", fileName_.string()); + case HeaderFileType::CPP_STD_HEADER_FILE: + return String::Format("#include <%s>", fileName_.string()); + default: + return String::Format("//"); + } + } + + using HeaderFileSet = std::set; + + HeaderFileType type_; + String fileName_; +}; + +class CodeEmitter : public LightRefCountBase { +public: + virtual ~CodeEmitter() = default; + + bool OutPut(const AutoPtr& ast, const String& targetDirectory, bool isKernelCode = false); + +protected: + bool Reset(const AutoPtr& ast, const String& targetDirectory, bool isKernelCode); + + void CleanData(); + + virtual bool ResolveDirectory(const String& targetDirectory) = 0; + + virtual void EmitCode() = 0; + + bool isKernelCode_ = false; + AutoPtr ast_ = nullptr; + AutoPtr interface_ = nullptr; + String directory_; + + String interfaceName_; + String interfaceFullName_; + String infName_; + String proxyName_; + String proxyFullName_; + String stubName_; + String stubFullName_; + String implName_; + String implFullName_; +}; +} +} + +#endif // OHOS_HDI_CODE_EMITTER_H diff --git a/tools/hdi-gen/codegen/code_generator.cpp b/tools/hdi-gen/codegen/code_generator.cpp new file mode 100755 index 0000000000000000000000000000000000000000..e9c53dfd6b73eeccd60111ef6c4da7c2a5b83ef4 --- /dev/null +++ b/tools/hdi-gen/codegen/code_generator.cpp @@ -0,0 +1,165 @@ +/* + * Copyright (c) 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 "codegen/code_generator.h" +#include "codegen/c_interface_code_emitter.h" +#include "codegen/c_client_proxy_code_emitter.h" +#include "codegen/c_custom_types_code_emitter.h" +#include "codegen/c_service_driver_code_emitter.h" +#include "codegen/c_service_impl_code_emitter.h" +#include "codegen/c_service_stub_code_emitter.h" +#include "codegen/cpp_interface_code_emitter.h" +#include "codegen/cpp_client_proxy_code_emitter.h" +#include "codegen/cpp_custom_types_code_emitter.h" +#include "codegen/cpp_service_driver_code_emitter.h" +#include "codegen/cpp_service_impl_code_emitter.h" +#include "codegen/cpp_service_stub_code_emitter.h" +#include "codegen/java_client_interface_code_emitter.h" +#include "codegen/java_client_proxy_code_emitter.h" +#include "util/options.h" + +namespace OHOS { +namespace HDI { +CodeEmitMap CodeGenerator::cCodeEmitters_ = { + {"types", new CCustomTypesCodeEmitter()}, + {"interface", new CInterfaceCodeEmitter()}, + {"proxy", new CClientProxyCodeEmitter()}, + {"driver", new CServiceDriverCodeEmitter()}, + {"stub", new CServiceStubCodeEmitter()}, + {"impl", new CServiceImplCodeEmitter()}, +}; + +CodeEmitMap CodeGenerator::cppCodeEmitters_ = { + {"types", new CppCustomTypesCodeEmitter()}, + {"interface", new CppInterfaceCodeEmitter()}, + {"proxy", new CppClientProxyCodeEmitter()}, + {"driver", new CppServiceDriverCodeEmitter()}, + {"stub", new CppServiceStubCodeEmitter()}, + {"impl", new CppServiceImplCodeEmitter()}, +}; + +CodeEmitMap CodeGenerator::javaCodeEmitters_ = { + {"clientIface", new JavaClientInterfaceCodeEmitter()}, + {"proxy", new JavaClientProxyCodeEmitter()}, +}; + +bool CodeGenerator::Generate() +{ + const Options& options = Options::GetInstance(); + String dir = options.GetGenerationDirectory(); + String language = options.GetTargetLanguage(); + bool isModeKernel = options.DoGenerateKernelCode(); + String codePart = options.GetCodePart(); + + for (auto& astPair : astModule_->GetAllAsts()) { + AutoPtr ast = astPair.second; + if (language.Equals("c")) { + GenerateCCode(ast, dir, codePart, isModeKernel); + } else if (language.Equals("cpp")) { + GenerateCppCode(ast, dir, codePart); + } else if (language.Equals("java")) { + GenerateJavaCode(ast, dir, codePart); + } + } + + return true; +} + +void CodeGenerator::GenerateCCode(const AutoPtr& ast, const String& outDir, const String& codePart, bool isKernel) +{ + switch (ast->GetASTFileType()) { + case ASTFileType::AST_TYPES: { + cCodeEmitters_["types"]->OutPut(ast, outDir, isKernel); + break; + } + case ASTFileType::AST_IFACE: { + if (codePart.Equals("client")) { + cCodeEmitters_["interface"]->OutPut(ast, outDir, isKernel); + cCodeEmitters_["proxy"]->OutPut(ast, outDir, isKernel); + break; + } else if (codePart.Equals("server")) { + cCodeEmitters_["interface"]->OutPut(ast, outDir, isKernel); + cCodeEmitters_["driver"]->OutPut(ast, outDir, isKernel); + cCodeEmitters_["stub"]->OutPut(ast, outDir, isKernel); + cCodeEmitters_["impl"]->OutPut(ast, outDir, isKernel); + break; + } else { + cCodeEmitters_["interface"]->OutPut(ast, outDir, isKernel); + cCodeEmitters_["proxy"]->OutPut(ast, outDir, isKernel); + cCodeEmitters_["driver"]->OutPut(ast, outDir, isKernel); + cCodeEmitters_["stub"]->OutPut(ast, outDir, isKernel); + cCodeEmitters_["impl"]->OutPut(ast, outDir, isKernel); + } + break; + } + case ASTFileType::AST_ICALLBACK: + // khdf doesn't support callback + cCodeEmitters_["interface"]->OutPut(ast, outDir); + cCodeEmitters_["proxy"]->OutPut(ast, outDir); + cCodeEmitters_["driver"]->OutPut(ast, outDir); + cCodeEmitters_["stub"]->OutPut(ast, outDir); + cCodeEmitters_["impl"]->OutPut(ast, outDir); + break; + default: + break; + } +} + +void CodeGenerator::GenerateCppCode(const AutoPtr& ast, const String& outDir, const String& codePart) +{ + switch (ast->GetASTFileType()) { + case ASTFileType::AST_TYPES: + cppCodeEmitters_["types"]->OutPut(ast, outDir); + break; + case ASTFileType::AST_IFACE: { + if (codePart.Equals("client")) { + cppCodeEmitters_["interface"]->OutPut(ast, outDir); + cppCodeEmitters_["proxy"]->OutPut(ast, outDir); + } else if (codePart.Equals("server")) { + cppCodeEmitters_["interface"]->OutPut(ast, outDir); + cppCodeEmitters_["driver"]->OutPut(ast, outDir); + cppCodeEmitters_["stub"]->OutPut(ast, outDir); + cppCodeEmitters_["impl"]->OutPut(ast, outDir); + } else { + cppCodeEmitters_["interface"]->OutPut(ast, outDir); + cppCodeEmitters_["proxy"]->OutPut(ast, outDir); + cppCodeEmitters_["driver"]->OutPut(ast, outDir); + cppCodeEmitters_["stub"]->OutPut(ast, outDir); + cppCodeEmitters_["impl"]->OutPut(ast, outDir); + } + break; + } + case ASTFileType::AST_ICALLBACK: + cppCodeEmitters_["interface"]->OutPut(ast, outDir); + cppCodeEmitters_["proxy"]->OutPut(ast, outDir); + cppCodeEmitters_["driver"]->OutPut(ast, outDir); + cppCodeEmitters_["stub"]->OutPut(ast, outDir); + cppCodeEmitters_["impl"]->OutPut(ast, outDir); + break; + default: + break; + } +} + +void CodeGenerator::GenerateJavaCode(const AutoPtr& ast, const String& outDir, const String& codePart) +{ + switch (ast->GetASTFileType()) { + case ASTFileType::AST_IFACE: + javaCodeEmitters_["clientIface"]->OutPut(ast, outDir); + javaCodeEmitters_["proxy"]->OutPut(ast, outDir); + break; + case ASTFileType::AST_ICALLBACK: + javaCodeEmitters_["clientIface"]->OutPut(ast, outDir); + javaCodeEmitters_["proxy"]->OutPut(ast, outDir); + break; + default: + break; + } +} +} // namespace HDI +} // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/codegen/code_generator.h b/tools/hdi-gen/codegen/code_generator.h index da57088f2cc684eb5190139c246bea6d02522935..244074b4045bf98f8fb6eb35cad6db79889f1258 100755 --- a/tools/hdi-gen/codegen/code_generator.h +++ b/tools/hdi-gen/codegen/code_generator.h @@ -9,29 +9,31 @@ #ifndef OHOS_HDI_CODEGENERATOR_H #define OHOS_HDI_CODEGENERATOR_H -#include "ast/ast.h" -#include "util/autoptr.h" -#include "util/light_refcount_base.h" -#include "util/string.h" +#include "ast/ast_module.h" +#include "codegen/code_emitter.h" namespace OHOS { namespace HDI { +using CodeEmitMap = std::unordered_map, StringHashFunc, StringEqualFunc>; + class CodeGenerator : public LightRefCountBase { public: - CodeGenerator() : LightRefCountBase(), - targetDirectory_(), - ast_(nullptr) {} - - virtual ~CodeGenerator() = default; + explicit CodeGenerator(const AutoPtr& astModule) + : LightRefCountBase(), astModule_(astModule), targetDirectory_() {} - virtual bool Initializate(const AutoPtr& ast, const String& targetDirectory) = 0; - - virtual bool Generate() const = 0; -protected: - virtual bool ResolveDirectory() = 0; + bool Generate(); +private: + void GenerateCCode(const AutoPtr& ast, const String& outDir, const String& codePart, + bool isKernel); + void GenerateCppCode(const AutoPtr& ast, const String& outDir, const String& codePart); + void GenerateJavaCode(const AutoPtr& ast, const String& outDir, const String& codePart); + AutoPtr astModule_; String targetDirectory_; - AutoPtr ast_; + + static CodeEmitMap cCodeEmitters_; + static CodeEmitMap cppCodeEmitters_; + static CodeEmitMap javaCodeEmitters_; }; } // namespace HDI } // namespace OHOS diff --git a/tools/hdi-gen/codegen/cpp_client_proxy_code_emitter.cpp b/tools/hdi-gen/codegen/cpp_client_proxy_code_emitter.cpp index 5905a351050c566d7d79e4f7005053d6ddcca913..bbb0ad133f3b3b3c7d461cc7cf16359684b181c7 100755 --- a/tools/hdi-gen/codegen/cpp_client_proxy_code_emitter.cpp +++ b/tools/hdi-gen/codegen/cpp_client_proxy_code_emitter.cpp @@ -8,17 +8,26 @@ #include "codegen/cpp_client_proxy_code_emitter.h" #include "util/file.h" - #include "util/logger.h" namespace OHOS { namespace HDI { -CppClientProxyCodeEmitter::CppClientProxyCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - :CppCodeEmitter(ast, targetDirectory) +bool CppClientProxyCodeEmitter::ResolveDirectory(const String& targetDirectory) { - String proxyName = String::Format("%sclient.%s", - interface_->GetNamespace()->ToString().string(), proxyName_.string()); - sourceFileName_ = String::Format("%s.cpp", FileName(proxyName).string()); + if (ast_->GetASTFileType() == ASTFileType::AST_IFACE || + ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) { + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); + } else { + return false; + } + + if (!File::CreateParentDir(directory_)) { + Logger::E("CppClientProxyCodeEmitter", "Create '%s' failed!", directory_.string()); + return false; + } + + return true; } void CppClientProxyCodeEmitter::EmitCode() @@ -29,26 +38,14 @@ void CppClientProxyCodeEmitter::EmitCode() void CppClientProxyCodeEmitter::EmitProxyHeaderFile() { - String filePath; - if (!isCallbackInterface()) { - filePath = String::Format("%sclient/%s.h", directory_.string(), FileName(infName_ + "Proxy").string()); - } else { - filePath = String::Format("%s%s.h", directory_.string(), FileName(infName_ + "Proxy").string()); - } - - if (!File::CreateParentDir(filePath)) { - Logger::E("CppClientProxyCodeEmitter", "Create '%s' failed!", filePath.string()); - return; - } - + String filePath = String::Format("%s%s.h", directory_.string(), FileName(infName_ + "Proxy").string()); File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); EmitHeadMacro(sb, proxyFullName_); sb.Append("\n"); - EmitProxyHeadrInclusions(sb); + EmitProxyHeaderInclusions(sb); sb.Append("\n"); EmitBeginNamespace(sb); sb.Append("\n"); @@ -64,10 +61,21 @@ void CppClientProxyCodeEmitter::EmitProxyHeaderFile() file.Close(); } -void CppClientProxyCodeEmitter::EmitProxyHeadrInclusions(StringBuilder& sb) +void CppClientProxyCodeEmitter::EmitProxyHeaderInclusions(StringBuilder& sb) +{ + HeaderFile::HeaderFileSet headerFiles; + + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_HEADER_FILE, FileName(interfaceName_))); + GetHeaderOtherLibInclusions(headerFiles); + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); + } +} + +void CppClientProxyCodeEmitter::GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles) { - sb.AppendFormat("#include \"%s.h\"\n", FileName(interfaceName_).string()); - sb.Append("#include \n"); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "iremote_proxy")); } void CppClientProxyCodeEmitter::EmitProxyDecl(StringBuilder& sb, const String& prefix) @@ -75,22 +83,19 @@ void CppClientProxyCodeEmitter::EmitProxyDecl(StringBuilder& sb, const String& p sb.AppendFormat("class %s : public IRemoteProxy<%s> {\n", proxyName_.string(), interfaceName_.string()); sb.Append("public:\n"); - EmitProxyConstructor(sb, TAB); + EmitProxyConstructor(sb, g_tab); sb.Append("\n"); - EmitProxyMethodDecls(sb, TAB); + EmitProxyMethodDecls(sb, g_tab); sb.Append("\n"); sb.Append("private:\n"); - EmitProxyConstants(sb, TAB); + EmitProxyConstants(sb, g_tab); sb.Append("};\n"); } void CppClientProxyCodeEmitter::EmitProxyConstructor(StringBuilder& sb, const String& prefix) { - sb.Append(prefix).AppendFormat("explicit %s(\n", proxyName_.string()); - sb.Append(prefix + TAB).Append("const sptr& remote)\n"); - sb.Append(prefix + TAB).AppendFormat(": IRemoteProxy<%s>(remote)\n", interfaceName_.string()); - sb.Append(prefix).Append("{}\n"); - sb.Append("\n"); + sb.Append(prefix).AppendFormat("explicit %s(const sptr& remote)", proxyName_.string()); + sb.AppendFormat(" : IRemoteProxy<%s>(remote) {}\n\n", interfaceName_.string()); sb.Append(prefix).AppendFormat("virtual ~%s() {}\n", proxyName_.string()); } @@ -124,7 +129,7 @@ void CppClientProxyCodeEmitter::EmitProxyMethodDecl(const AutoPtr& me paramStr.Append(") override;"); - sb.Append(SpecificationParam(paramStr, prefix + TAB)); + sb.Append(SpecificationParam(paramStr, prefix + g_tab)); sb.Append("\n"); } } @@ -142,20 +147,8 @@ void CppClientProxyCodeEmitter::EmitProxyMethodParameter(const AutoPtr\n"); - sb.Append("#include \n"); - sb.Append("#include \n"); + if (!isCallbackInterface()) { + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "iservmgr_hdi")); + } + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_base")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_log")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "message_option")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "message_parcel")); const AST::TypeStringMap& types = ast_->GetTypes(); for (const auto& pair : types) { AutoPtr type = pair.second; if (type->GetTypeKind() == TypeKind::TYPE_UNION) { - sb.Append("#include \n"); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "securec")); break; } } @@ -204,23 +208,34 @@ void CppClientProxyCodeEmitter::EmitGetMethodImpl(StringBuilder& sb, const Strin sb.Append(prefix).AppendFormat("sptr<%s> %s::Get()\n", interface_->GetName().string(), interface_->GetName().string()); sb.Append(prefix).Append("{\n"); - sb.Append(prefix + TAB).Append("do {\n"); - sb.Append(prefix + TAB + TAB).Append("using namespace OHOS::HDI::ServiceManager::V1_0;\n"); - sb.Append(prefix + TAB + TAB).Append("auto servMgr = IServiceManager::Get();\n"); - sb.Append(prefix + TAB + TAB).Append("if (servMgr == nullptr) {\n"); - sb.Append(prefix + TAB + TAB + TAB).Append("HDF_LOGE(\"%{public}s:get IServiceManager failed!\", __func__);\n"); - sb.Append(prefix + TAB + TAB + TAB).Append("break;\n"); - sb.Append(prefix + TAB + TAB).Append("}\n\n"); - sb.Append(prefix + TAB + TAB).AppendFormat("sptr remote = servMgr->GetService(\"%sService\");\n", - infName_.string()); - sb.Append(prefix + TAB + TAB).Append("if (remote != nullptr) {\n"); - sb.Append(prefix + TAB + TAB + TAB).AppendFormat("return iface_cast<%s>(remote);\n", + sb.Append(prefix + g_tab).AppendFormat("return %s::GetInstance(\"%s\");\n", + interfaceName_.string(), FileName(implName_).string()); + sb.Append(prefix).Append("}\n"); +} + +void CppClientProxyCodeEmitter::EmitGetInstanceMethodImpl(StringBuilder& sb, const String& prefix) +{ + sb.Append(prefix).AppendFormat("sptr<%s> %s::GetInstance(const std::string& serviceName)\n", + interface_->GetName().string(), interface_->GetName().string()); + sb.Append(prefix).Append("{\n"); + sb.Append(prefix + g_tab).Append("do {\n"); + sb.Append(prefix + g_tab + g_tab).Append("using namespace OHOS::HDI::ServiceManager::V1_0;\n"); + sb.Append(prefix + g_tab + g_tab).Append("auto servMgr = IServiceManager::Get();\n"); + sb.Append(prefix + g_tab + g_tab).Append("if (servMgr == nullptr) {\n"); + sb.Append(prefix + g_tab + g_tab + g_tab).Append( + "HDF_LOGE(\"%{public}s:get IServiceManager failed!\", __func__);\n"); + sb.Append(prefix + g_tab + g_tab + g_tab).Append("break;\n"); + sb.Append(prefix + g_tab + g_tab).Append("}\n\n"); + sb.Append(prefix + g_tab + g_tab).Append("sptr remote = "); + sb.Append("servMgr->GetService(serviceName.c_str());\n"); + sb.Append(prefix + g_tab + g_tab).Append("if (remote != nullptr) {\n"); + sb.Append(prefix + g_tab + g_tab + g_tab).AppendFormat("return iface_cast<%s>(remote);\n", interface_->GetName().string()); - sb.Append(prefix + TAB + TAB).Append("}\n"); - sb.Append(prefix + TAB).Append("} while(false);\n"); - sb.Append(prefix + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s: get %sService failed!\", __func__);\n", infName_.string()); - sb.Append(prefix + TAB).Append("return nullptr;\n"); + sb.Append(prefix + g_tab + g_tab).Append("}\n"); + sb.Append(prefix + g_tab).Append("} while(false);\n"); + sb.Append(prefix + g_tab).AppendFormat( + "HDF_LOGE(\"%%{public}s: get %s failed!\", __func__);\n", FileName(implName_).string()); + sb.Append(prefix + g_tab).Append("return nullptr;\n"); sb.Append(prefix).Append("}\n"); } @@ -254,7 +269,7 @@ void CppClientProxyCodeEmitter::EmitProxyMethodImpl(const AutoPtr& me paramStr.Append(")"); - sb.Append(SpecificationParam(paramStr, prefix + TAB)); + sb.Append(SpecificationParam(paramStr, prefix + g_tab)); sb.Append("\n"); } EmitProxyMethodBody(method, sb, prefix); @@ -263,42 +278,45 @@ void CppClientProxyCodeEmitter::EmitProxyMethodImpl(const AutoPtr& me void CppClientProxyCodeEmitter::EmitProxyMethodBody(const AutoPtr& method, StringBuilder& sb, const String& prefix) { + String dataName = "data_"; + String replyName = "reply_"; + String optionName = "option_"; sb.Append(prefix).Append("{\n"); - sb.Append(prefix + TAB).Append("MessageParcel data;\n"); - sb.Append(prefix + TAB).Append("MessageParcel reply;\n"); - sb.Append(prefix + TAB).Append("MessageOption option(MessageOption::TF_SYNC);\n"); + sb.Append(prefix + g_tab).AppendFormat("MessageParcel %s;\n", dataName.string()); + sb.Append(prefix + g_tab).AppendFormat("MessageParcel %s;\n", replyName.string()); + sb.Append(prefix + g_tab).AppendFormat("MessageOption %s(MessageOption::TF_SYNC);\n", optionName.string()); sb.Append("\n"); if (method->GetParameterNumber() > 0) { for (size_t i = 0; i < method->GetParameterNumber(); i++) { AutoPtr param = method->GetParameter(i); if (param->GetAttribute() == ParamAttr::PARAM_IN) { - EmitWriteMethodParameter(param, "data", sb, prefix + TAB); + EmitWriteMethodParameter(param, dataName, sb, prefix + g_tab); } } sb.Append("\n"); } - sb.Append(prefix + TAB).AppendFormat("int32_t ec = Remote()->SendRequest(CMD_%s, data, reply, option);\n", - ConstantName(method->GetName()).string()); - sb.Append(prefix + TAB).Append("if (ec != HDF_SUCCESS) {\n"); - sb.Append(prefix + TAB + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s failed, error code is %%d\", ec);\n", method->GetName().string()); - sb.Append(prefix + TAB + TAB).Append("return ec;\n"); - sb.Append(prefix + TAB).Append("}\n"); + sb.Append(prefix + g_tab).AppendFormat("int32_t ec = Remote()->SendRequest(CMD_%s, %s, %s, %s);\n", + ConstantName(method->GetName()).string(), dataName.string(), replyName.string(), optionName.string()); + sb.Append(prefix + g_tab).Append("if (ec != HDF_SUCCESS) {\n"); + sb.Append(prefix + g_tab + g_tab).AppendFormat( + "HDF_LOGE(\"%%{public}s failed, error code is %%{public}d\", __func__, ec);\n", method->GetName().string()); + sb.Append(prefix + g_tab + g_tab).Append("return ec;\n"); + sb.Append(prefix + g_tab).Append("}\n"); if (!method->IsOneWay()) { sb.Append("\n"); for (size_t i = 0; i < method->GetParameterNumber(); i++) { AutoPtr param = method->GetParameter(i); if (param->GetAttribute() == ParamAttr::PARAM_OUT) { - EmitReadMethodParameter(param, "reply", false, sb, prefix + TAB); + EmitReadMethodParameter(param, replyName, false, sb, prefix + g_tab); sb.Append("\n"); } } } - sb.Append(prefix + TAB).Append("return HDF_SUCCESS;\n"); + sb.Append(prefix + g_tab).Append("return HDF_SUCCESS;\n"); sb.Append(prefix).Append("}\n"); } } // namespace HDI diff --git a/tools/hdi-gen/codegen/cpp_client_proxy_code_emitter.h b/tools/hdi-gen/codegen/cpp_client_proxy_code_emitter.h index 9e97982e7b0e3fcaf43b8e1bdc37f4ebaf08abb2..dcf10b67ad8af94f7a30799fa6259fd07b566d2b 100755 --- a/tools/hdi-gen/codegen/cpp_client_proxy_code_emitter.h +++ b/tools/hdi-gen/codegen/cpp_client_proxy_code_emitter.h @@ -15,15 +15,19 @@ namespace OHOS { namespace HDI { class CppClientProxyCodeEmitter : public CppCodeEmitter { public: - CppClientProxyCodeEmitter(const AutoPtr& ast, const String& targetDirectory); + CppClientProxyCodeEmitter() : CppCodeEmitter() {} virtual ~CppClientProxyCodeEmitter() = default; +private: + bool ResolveDirectory(const String& targetDirectory) override; void EmitCode() override; -private: + void EmitProxyHeaderFile(); - void EmitProxyHeadrInclusions(StringBuilder& sb); + void EmitProxyHeaderInclusions(StringBuilder& sb); + + void GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); void EmitProxyDecl(StringBuilder& sb, const String& prefix); @@ -41,10 +45,12 @@ private: void EmitProxySourceInclusions(StringBuilder& sb); - void EmitProxySourceStdlibInclusions(StringBuilder& sb); + void GetSourceOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); void EmitGetMethodImpl(StringBuilder& sb, const String& prefix); + void EmitGetInstanceMethodImpl(StringBuilder& sb, const String& prefix); + void EmitProxyMethodImpls(StringBuilder& sb, const String& prefix); void EmitProxyMethodImpl(const AutoPtr& method, StringBuilder& sb, const String& prefix); diff --git a/tools/hdi-gen/codegen/cpp_code_emitter.cpp b/tools/hdi-gen/codegen/cpp_code_emitter.cpp index 9b79a26ca3f4f6699996a8c44c184b215e6228a1..4a791c6e46fbfab4567e8d097d9a859e2f47ef4c 100755 --- a/tools/hdi-gen/codegen/cpp_code_emitter.cpp +++ b/tools/hdi-gen/codegen/cpp_code_emitter.cpp @@ -14,32 +14,6 @@ namespace OHOS { namespace HDI { -const char* CppCodeEmitter::TAB = " "; - -CppCodeEmitter::CppCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - : LightRefCountBase(), ast_(ast), directory_(targetDirectory) -{ - if (ast_->GetASTFileType() == ASTFileType::AST_IFACE || ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) { - interface_ = ast_->GetInterfaceDef(); - } - - if (interface_ != nullptr) { - interfaceName_ = interface_->GetName(); - interfaceFullName_ = interface_->GetNamespace()->ToString() + interfaceName_; - infName_ = interfaceName_.StartsWith("I") ? interfaceName_.Substring(1) : interfaceName_; - proxyName_ = infName_ + "Proxy"; - proxyFullName_ = interface_->GetNamespace()->ToString() + proxyName_; - - stubName_ = infName_ + "Stub"; - stubFullName_ = interface_->GetNamespace()->ToString() + stubName_; - - ImplName_ = infName_ + "Service"; - ImplFullName_ = interface_->GetNamespace()->ToString() + ImplName_; - } else { - infName_ = ast_->GetName(); - } -} - String CppCodeEmitter::FileName(const String& name) { if (name.IsEmpty()) { @@ -69,11 +43,58 @@ void CppCodeEmitter::EmitInterfaceMethodCommands(StringBuilder& sb, const String sb.Append(prefix).Append("enum {\n"); for (size_t i = 0; i < interface_->GetMethodNumber(); i++) { AutoPtr method = interface_->GetMethod(i); - sb.Append(TAB).AppendFormat("CMD_%s,\n", ConstantName(method->GetName()).string()); + sb.Append(g_tab).AppendFormat("CMD_%s,\n", ConstantName(method->GetName()).string()); } sb.Append(prefix).Append("};\n"); } +void CppCodeEmitter::GetStdlibInclusions(HeaderFile::HeaderFileSet& headerFiles) +{ + bool includeString = false; + bool includeList = false; + bool includeMap = false; + + const AST::TypeStringMap& types = ast_->GetTypes(); + for (const auto& pair : types) { + AutoPtr type = pair.second; + switch (type->GetTypeKind()) { + case TypeKind::TYPE_STRING: { + if (!includeString) { + headerFiles.emplace(HeaderFile(HeaderFileType::CPP_STD_HEADER_FILE, "string")); + includeString = true; + } + break; + } + case TypeKind::TYPE_ARRAY: + case TypeKind::TYPE_LIST: { + if (!includeList) { + headerFiles.emplace(HeaderFile(HeaderFileType::CPP_STD_HEADER_FILE, "vector")); + includeList = true; + } + break; + } + case TypeKind::TYPE_MAP: { + if (!includeMap) { + headerFiles.emplace(HeaderFile(HeaderFileType::CPP_STD_HEADER_FILE, "map")); + includeMap = true; + } + break; + } + default: + break; + } + } +} + +void CppCodeEmitter::GetImportInclusions(HeaderFile::HeaderFileSet& headerFiles) +{ + for (const auto& importPair : ast_->GetImports()) { + AutoPtr importAst = importPair.second; + String fileName = FileName(importAst->GetFullName()); + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_MODULE_HEADER_FILE, FileName(importAst->GetFullName()))); + } +} + void CppCodeEmitter::EmitInterfaceMethodParameter(const AutoPtr& param, StringBuilder& sb, const String& prefix) { @@ -101,6 +122,20 @@ void CppCodeEmitter::EmitTailMacro(StringBuilder& sb, const String& fullName) sb.Append("#endif // ").Append(macroName).Append("\n\n"); } +void CppCodeEmitter::EmitHeadExternC(StringBuilder& sb) +{ + sb.Append("#ifdef __cplusplus\n"); + sb.Append("extern \"C\" {\n"); + sb.Append("#endif /* __cplusplus */\n"); +} + +void CppCodeEmitter::EmitTailExternC(StringBuilder& sb) +{ + sb.Append("#ifdef __cplusplus\n"); + sb.Append("}\n"); + sb.Append("#endif /* __cplusplus */\n"); +} + void CppCodeEmitter::EmitBeginNamespace(StringBuilder& sb) { String nspace = interface_->GetNamespace()->ToString(); diff --git a/tools/hdi-gen/codegen/cpp_code_emitter.h b/tools/hdi-gen/codegen/cpp_code_emitter.h index a519a6deff2f3fb184686de7220b263d9b8f961a..1ce214c298d8bd1183cba564fa40c86351d19aee 100755 --- a/tools/hdi-gen/codegen/cpp_code_emitter.h +++ b/tools/hdi-gen/codegen/cpp_code_emitter.h @@ -10,36 +10,27 @@ #define OHOS_HDI_CPP_CODE_EMITTER_H #include "ast/ast.h" +#include "codegen/code_emitter.h" #include "util/autoptr.h" -#include "util/light_refcount_base.h" #include "util/string.h" #include "util/string_builder.h" namespace OHOS { namespace HDI { -class CppCodeEmitter : public LightRefCountBase { +class CppCodeEmitter : public CodeEmitter { public: - CppCodeEmitter(const AutoPtr& ast, const String& targetDirectory); - virtual ~CppCodeEmitter() = default; - virtual void EmitCode() = 0; - - inline String GetSourceFile() - { - return sourceFileName_; - } - - inline bool isInvaildDir() - { - return directory_.Equals(""); - } + bool OutPut(const AutoPtr& ast, const String& targetDirectory); static String FileName(const String& name); protected: - void EmitInterfaceMethodCommands(StringBuilder& sb, const String& prefix); + void GetStdlibInclusions(HeaderFile::HeaderFileSet& headerFiles); + + void GetImportInclusions(HeaderFile::HeaderFileSet& headerFiles); + void EmitInterfaceMethodParameter(const AutoPtr& param, StringBuilder& sb, const String& prefix); void EmitLicense(StringBuilder& sb); @@ -48,6 +39,10 @@ protected: void EmitTailMacro(StringBuilder& sb, const String& fullName); + void EmitHeadExternC(StringBuilder& sb); + + void EmitTailExternC(StringBuilder& sb); + virtual void EmitBeginNamespace(StringBuilder& sb); virtual void EmitEndNamespace(StringBuilder& sb); @@ -82,24 +77,6 @@ protected: } String SpecificationParam(StringBuilder& sb, const String& prefix); - - static const char* TAB; - - AutoPtr ast_; - AutoPtr interface_; - - String directory_; - String sourceFileName_; - - String interfaceName_; - String interfaceFullName_; - String infName_; - String proxyName_; - String proxyFullName_; - String stubName_; - String stubFullName_; - String ImplName_; - String ImplFullName_; }; } // namespace HDI } // namespace OHOS diff --git a/tools/hdi-gen/codegen/cpp_code_generator.cpp b/tools/hdi-gen/codegen/cpp_code_generator.cpp deleted file mode 100755 index 01452799b6d989598d48868bbb0a2751e4bd3c34..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/codegen/cpp_code_generator.cpp +++ /dev/null @@ -1,84 +0,0 @@ -/* - * Copyright (c) 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 "cpp_code_generator.h" -#include -#include -#include -#include "codegen/cpp_client_interface_code_emitter.h" -#include "codegen/cpp_client_proxy_code_emitter.h" -#include "codegen/cpp_custom_types_code_emitter.h" -#include "codegen/cpp_service_driver_code_emitter.h" -#include "codegen/cpp_service_impl_code_emitter.h" -#include "codegen/cpp_service_interface_code_emitter.h" -#include "codegen/cpp_service_stub_code_emitter.h" -#include "util/file.h" -#include "util/logger.h" - -namespace OHOS { -namespace HDI { -const char* CppCodeGenerator::TAG = "CppCodeGenerator"; - -bool CppCodeGenerator::Initializate(const AutoPtr& ast, const String& targetDirectory) -{ - ast_ = ast; - targetDirectory_ = targetDirectory; - - if (!ResolveDirectory()) { - return false; - } - - if (ast_->GetASTFileType() == ASTFileType::AST_TYPES) { - AutoPtr customTypesCodeEmitter = new CppCustomTypesCodeEmitter(ast_, targetDirectory_); - emitters_.push_back(customTypesCodeEmitter); - return true; - } - - AutoPtr clientInterfaceCodeEmitter = new CppClientInterfaceCodeEmitter(ast_, targetDirectory_); - AutoPtr clientProxyCodeEmitter = new CppClientProxyCodeEmitter(ast_, targetDirectory_); - - AutoPtr serviceInterfaceCodeEmitter = new CppServiceInterfaceCodeEmitter(ast_, targetDirectory_); - AutoPtr serviceDriverCodeEmitter = new CppServiceDriverCodeEmitter(ast_, targetDirectory_); - AutoPtr serviceStubCodeEmitter = new CppServiceStubCodeEmitter(ast_, targetDirectory_); - AutoPtr serviceImplCodeEmitter = new CppServiceImplCodeEmitter(ast_, targetDirectory_); - - emitters_.push_back(clientInterfaceCodeEmitter); - emitters_.push_back(clientProxyCodeEmitter); - emitters_.push_back(serviceInterfaceCodeEmitter); - emitters_.push_back(serviceDriverCodeEmitter); - emitters_.push_back(serviceStubCodeEmitter); - emitters_.push_back(serviceImplCodeEmitter); - - return true; -} - -bool CppCodeGenerator::Generate() const -{ - for (auto emitter : emitters_) { - if (!emitter->isInvaildDir()) { - emitter->EmitCode(); - } - } - - return true; -} - -bool CppCodeGenerator::ResolveDirectory() -{ - String packageFilePath = String::Format("%s/%s/", - targetDirectory_.string(), CppCodeEmitter::FileName(ast_->GetPackageName()).string()); - targetDirectory_ = packageFilePath; - - if (!File::CreateParentDir(targetDirectory_)) { - Logger::E(TAG, "create '%s' directory failed!", targetDirectory_); - return false; - } - return true; -} -} // namespace HDI -} // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/codegen/cpp_code_generator.h b/tools/hdi-gen/codegen/cpp_code_generator.h deleted file mode 100755 index 3a36abf3bdee49f6100488291782f915fb372301..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/codegen/cpp_code_generator.h +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright (c) 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 OHOS_HDI_CPP_CODE_GENERATOR_H -#define OHOS_HDI_CPP_CODE_GENERATOR_H - -#include "codegen/code_generator.h" -#include "codegen/cpp_code_emitter.h" - -namespace OHOS { -namespace HDI { -class CppCodeGenerator : public CodeGenerator { -public: - CppCodeGenerator() : CodeGenerator(), - emitters_() {} - - ~CppCodeGenerator() override {}; - - bool Initializate(const AutoPtr& ast, const String& targetDirectory) override; - bool Generate() const override; -private: - bool ResolveDirectory() override; - - static const char* TAG; - std::vector> emitters_; -}; -} // namespace HDI -} // namespace OHOS - -#endif // OHOS_HDI_CPP_CODE_GENERATOR_H \ No newline at end of file diff --git a/tools/hdi-gen/codegen/cpp_custom_types_code_emitter.cpp b/tools/hdi-gen/codegen/cpp_custom_types_code_emitter.cpp index 0ed77382bd8d6d513e19e1deb34f2bc80a57f0f8..ee6ef60779dde551631287156c4ac3a3b9fab336 100755 --- a/tools/hdi-gen/codegen/cpp_custom_types_code_emitter.cpp +++ b/tools/hdi-gen/codegen/cpp_custom_types_code_emitter.cpp @@ -12,6 +12,22 @@ namespace OHOS { namespace HDI { +bool CppCustomTypesCodeEmitter::ResolveDirectory(const String& targetDirectory) +{ + if (ast_->GetASTFileType() != ASTFileType::AST_TYPES) { + return false; + } + + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); + if (!File::CreateParentDir(directory_)) { + Logger::E("CppCustomTypesCodeEmitter", "Create '%s' failed!", directory_.string()); + return false; + } + + return true; +} + void CppCustomTypesCodeEmitter::EmitCode() { EmitCustomTypesHeaderFile(); @@ -23,7 +39,6 @@ void CppCustomTypesCodeEmitter::EmitCustomTypesHeaderFile() String filePath = String::Format("%s%s.h", directory_.string(), FileName(infName_).string()); File file(filePath, File::WRITE); String marcoName = String::Format("%s.%s", ast_->GetPackageName().string(), infName_.string()); - StringBuilder sb; EmitLicense(sb); @@ -51,56 +66,20 @@ void CppCustomTypesCodeEmitter::EmitCustomTypesHeaderFile() void CppCustomTypesCodeEmitter::EmitHeaderFileInclusions(StringBuilder& sb) { - EmitCustomTypesStdlibInclusions(sb); - sb.Append("#include \n"); - EmitImportInclusions(sb); -} + HeaderFile::HeaderFileSet headerFiles; -void CppCustomTypesCodeEmitter::EmitCustomTypesStdlibInclusions(StringBuilder& sb) -{ - bool includeString = false; - bool includeList = false; - bool includeMap = false; + GetStdlibInclusions(headerFiles); + GetImportInclusions(headerFiles); + GetHeaderOtherLibInclusions(headerFiles); - const AST::TypeStringMap& types = ast_->GetTypes(); - for (const auto& pair : types) { - AutoPtr type = pair.second; - switch (type->GetTypeKind()) { - case TypeKind::TYPE_STRING: { - if (!includeString) { - sb.Append("#include \n"); - includeString = true; - } - break; - } - case TypeKind::TYPE_ARRAY: - case TypeKind::TYPE_LIST: { - if (!includeList) { - sb.Append("#include \n"); - includeList = true; - } - break; - } - case TypeKind::TYPE_MAP: { - if (!includeMap) { - sb.Append("#include \n"); - includeMap = true; - } - break; - } - default: - break; - } + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); } } -void CppCustomTypesCodeEmitter::EmitImportInclusions(StringBuilder& sb) +void CppCustomTypesCodeEmitter::GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles) { - for (const auto& importPair : ast_->GetImports()) { - AutoPtr importAst = importPair.second; - String fileName = FileName(importAst->GetFullName()); - sb.Append("#include ").AppendFormat("\"%s.h\"\n", fileName.string()); - } + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "message_parcel")); } void CppCustomTypesCodeEmitter::EmitCustomTypeDecls(StringBuilder& sb) @@ -171,7 +150,6 @@ void CppCustomTypesCodeEmitter::EmitCustomTypesSourceFile() { String filePath = String::Format("%s%s.cpp", directory_.string(), FileName(infName_).string()); File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); @@ -191,18 +169,24 @@ void CppCustomTypesCodeEmitter::EmitCustomTypesSourceFile() void CppCustomTypesCodeEmitter::EmitSourceFileInclusions(StringBuilder& sb) { - sb.AppendFormat("#include \"%s.h\"\n", FileName(infName_).string()); - EmitSourceStdlibInclusions(sb); + HeaderFile::HeaderFileSet headerFiles; + + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_HEADER_FILE, FileName(infName_))); + GetSourceOtherLibInclusions(headerFiles); + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); + } } -void CppCustomTypesCodeEmitter::EmitSourceStdlibInclusions(StringBuilder& sb) +void CppCustomTypesCodeEmitter::GetSourceOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles) { - sb.Append("#include \n"); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_log")); const AST::TypeStringMap& types = ast_->GetTypes(); for (const auto& pair : types) { AutoPtr type = pair.second; if (type->GetTypeKind() == TypeKind::TYPE_STRUCT || type->GetTypeKind() == TypeKind::TYPE_UNION) { - sb.Append("#include \n"); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "securec")); break; } } @@ -236,13 +220,13 @@ void CppCustomTypesCodeEmitter::EmitCustomTypeMarshallingImpl(StringBuilder& sb, String memberName = type->GetMemberName(i); String name = String::Format("%s.%s", objName.string(), memberName.string()); - memberType->EmitCppMarshalling("data", name, sb, TAB); + memberType->EmitCppMarshalling("data", name, sb, g_tab); if (i + 1 < type->GetMemberNumber()) { sb.Append("\n"); } } - sb.Append(TAB).Append("return true;\n"); + sb.Append(g_tab).Append("return true;\n"); sb.Append("}\n"); } @@ -269,15 +253,15 @@ void CppCustomTypesCodeEmitter::EmitCustomTypeUnmarshallingImpl(StringBuilder& s if (memberType->GetTypeKind() == TypeKind::TYPE_UNION) { String cpName = String::Format("%sCp", memberName.string()); - memberType->EmitCppUnMarshalling("data", cpName, sb, TAB, false); - sb.Append(TAB).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", name.string(), + memberType->EmitCppUnMarshalling("data", cpName, sb, g_tab, false); + sb.Append(g_tab).AppendFormat("(void)memcpy_s(&%s, sizeof(%s), %s, sizeof(%s));\n", name.string(), memberType->EmitCppType().string(), cpName.string(), memberType->EmitCppType().string()); } else { - memberType->EmitCppUnMarshalling("data", name, sb, TAB, false); + memberType->EmitCppUnMarshalling("data", name, sb, g_tab, false); } } - sb.Append(TAB).AppendFormat("return true;\n", objName.string()); + sb.Append(g_tab).AppendFormat("return true;\n", objName.string()); sb.Append("}\n"); } diff --git a/tools/hdi-gen/codegen/cpp_custom_types_code_emitter.h b/tools/hdi-gen/codegen/cpp_custom_types_code_emitter.h index d8e3be78faae63cc07e74b5422ee60ca7fa3ba03..2dae423a39f1d6cde2f7e193014b4b922e9ec871 100755 --- a/tools/hdi-gen/codegen/cpp_custom_types_code_emitter.h +++ b/tools/hdi-gen/codegen/cpp_custom_types_code_emitter.h @@ -15,20 +15,19 @@ namespace OHOS { namespace HDI { class CppCustomTypesCodeEmitter : public CppCodeEmitter { public: - CppCustomTypesCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - : CppCodeEmitter(ast, targetDirectory) {} + CppCustomTypesCodeEmitter() : CppCodeEmitter() {} virtual ~CppCustomTypesCodeEmitter() = default; +private: + bool ResolveDirectory(const String& targetDirectory) override; void EmitCode() override; -private: + void EmitCustomTypesHeaderFile(); void EmitHeaderFileInclusions(StringBuilder& sb); - void EmitCustomTypesStdlibInclusions(StringBuilder& sb); - - void EmitImportInclusions(StringBuilder& sb); + void GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); void EmitCustomTypeDecls(StringBuilder& sb); @@ -44,7 +43,7 @@ private: void EmitSourceFileInclusions(StringBuilder& sb); - void EmitSourceStdlibInclusions(StringBuilder& sb); + void GetSourceOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); void EmitCustomTypeDataProcess(StringBuilder& sb); diff --git a/tools/hdi-gen/codegen/cpp_client_interface_code_emitter.cpp b/tools/hdi-gen/codegen/cpp_interface_code_emitter.cpp similarity index 32% rename from tools/hdi-gen/codegen/cpp_client_interface_code_emitter.cpp rename to tools/hdi-gen/codegen/cpp_interface_code_emitter.cpp index 82f75824b55dae33c3e6217dc6c28827e829d050..71f96a6523cebf63749b1f837190f3b51db9a13d 100755 --- a/tools/hdi-gen/codegen/cpp_client_interface_code_emitter.cpp +++ b/tools/hdi-gen/codegen/cpp_interface_code_emitter.cpp @@ -6,37 +6,43 @@ * See the LICENSE file in the root of this repository for complete details. */ -#include "codegen/cpp_client_interface_code_emitter.h" +#include "codegen/cpp_interface_code_emitter.h" #include "util/file.h" #include "util/logger.h" namespace OHOS { namespace HDI { -void CppClientInterfaceCodeEmitter::EmitCode() +bool CppInterfaceCodeEmitter::ResolveDirectory(const String& targetDirectory) { - EmitInterfaceHeaderFile(); -} - -void CppClientInterfaceCodeEmitter::EmitInterfaceHeaderFile() -{ - String filePath; - if (!isCallbackInterface()) { - filePath = String::Format("%sclient/%s.h", directory_.string(), FileName(interfaceName_).string()); + if (ast_->GetASTFileType() == ASTFileType::AST_IFACE || + ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) { + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); } else { - filePath = String::Format("%s%s.h", directory_.string(), FileName(interfaceName_).string()); + return false; } - if (!File::CreateParentDir(filePath)) { - Logger::E("CppClientInterfaceCodeEmitter", "Create '%s' failed!", filePath.string()); - return; + if (!File::CreateParentDir(directory_)) { + Logger::E("CppInterfaceCodeEmitter", "Create '%s' failed!", directory_.string()); + return false; } - File file(filePath, File::WRITE); + return true; +} + +void CppInterfaceCodeEmitter::EmitCode() +{ + EmitInterfaceHeaderFile(); +} +void CppInterfaceCodeEmitter::EmitInterfaceHeaderFile() +{ + String filePath = String::Format("%s/%s.h", directory_.string(), FileName(interfaceName_).string()); + File file(filePath, File::WRITE); StringBuilder sb; EmitLicense(sb); - EmitClientInfHeadMacro(sb); + EmitHeadMacro(sb, interfaceFullName_); sb.Append("\n"); EmitInterfaceInclusions(sb); sb.Append("\n"); @@ -46,11 +52,11 @@ void CppClientInterfaceCodeEmitter::EmitInterfaceHeaderFile() sb.Append("\n"); EmitInterfaceMethodCommands(sb, ""); sb.Append("\n"); - EmitInterfaceDecl(sb); + EmitInterfaceDefinition(sb); sb.Append("\n"); EmitEndNamespace(sb); sb.Append("\n"); - EmitClientInfTailMacro(sb); + EmitTailMacro(sb, interfaceFullName_); String data = sb.ToString(); file.WriteData(data.string(), data.GetLength()); @@ -58,126 +64,80 @@ void CppClientInterfaceCodeEmitter::EmitInterfaceHeaderFile() file.Close(); } -void CppClientInterfaceCodeEmitter::EmitClientInfHeadMacro(StringBuilder& sb) +void CppInterfaceCodeEmitter::EmitInterfaceInclusions(StringBuilder& sb) { - String clientMacroName(interfaceFullName_); - if (!isCallbackInterface()) { - clientMacroName += ".client"; - } - EmitHeadMacro(sb, clientMacroName); -} + HeaderFile::HeaderFileSet headerFiles; -void CppClientInterfaceCodeEmitter::EmitClientInfTailMacro(StringBuilder& sb) -{ - String clientMacroName(interfaceFullName_); - if (!isCallbackInterface()) { - clientMacroName += ".client"; + GetStdlibInclusions(headerFiles); + GetImportInclusions(headerFiles); + GetHeaderOtherLibInclusions(headerFiles); + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); } - EmitTailMacro(sb, clientMacroName); } -void CppClientInterfaceCodeEmitter::EmitInterfaceInclusions(StringBuilder& sb) +void CppInterfaceCodeEmitter::GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles) { - EmitInterfaceStdlibInclusions(sb); - EmitInterfaceDBinderInclusions(sb); - EmitInterfaceSelfDefinedTypeInclusions(sb); + headerFiles.emplace(HeaderFile(HeaderFileType::C_STD_HEADER_FILE, "stdint")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "iremote_broker")); } -void CppClientInterfaceCodeEmitter::EmitInterfaceStdlibInclusions(StringBuilder& sb) +void CppInterfaceCodeEmitter::EmitInterfaceDefinition(StringBuilder& sb) { - bool includeString = false; - bool includeList = false; - bool includeMap = false; - - const AST::TypeStringMap& types = ast_->GetTypes(); - for (const auto& pair : types) { - AutoPtr type = pair.second; - switch (type->GetTypeKind()) { - case TypeKind::TYPE_STRING: { - if (!includeString) { - sb.Append("#include \n"); - includeString = true; - } - break; - } - case TypeKind::TYPE_ARRAY: - case TypeKind::TYPE_LIST: { - if (!includeList) { - sb.Append("#include \n"); - includeList = true; - } - break; - } - case TypeKind::TYPE_MAP: { - if (!includeMap) { - sb.Append("#include \n"); - includeMap = true; - } - break; - } - default: - break; - } - } -} + if (!isCallbackInterface()) { + sb.Append("#ifndef __HDI_SERVER__\n"); + sb.AppendFormat("class %s : public IRemoteBroker {\n", interfaceName_.string()); + sb.Append("public:\n"); + EmitInterfaceDescriptor(sb, g_tab); + sb.Append("\n"); + EmitGetMethodDecl(sb, g_tab); + sb.Append("\n"); + EmitGetInstanceMethodDecl(sb, g_tab); + sb.Append("#else\n"); + sb.AppendFormat("class %s {\n", interfaceName_.string()); + sb.Append("public:\n"); + sb.Append("#endif\n"); -void CppClientInterfaceCodeEmitter::EmitInterfaceDBinderInclusions(StringBuilder& sb) -{ - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.Append("#include \n"); -} -void CppClientInterfaceCodeEmitter::EmitInterfaceSelfDefinedTypeInclusions(StringBuilder& sb) -{ - for (const auto& importPair : ast_->GetImports()) { - AutoPtr importAst = importPair.second; - - String fileName; - if (importAst->GetASTFileType() == ASTFileType::AST_ICALLBACK && importAst->GetInterfaceDef() != nullptr) { - String ifaceName = importAst->GetInterfaceDef()->GetName(); - String name = ifaceName.StartsWith("I") ? ifaceName.Substring(1) : ifaceName; - String stubName = name + "Service"; - fileName = FileName(importAst->GetInterfaceDef()->GetNamespace()->ToString() + stubName); - } else { - fileName = FileName(importAst->GetFullName()); - } - sb.Append("#include ").AppendFormat("\"%s.h\"\n", fileName.string()); + EmitInterfaceDestruction(sb, g_tab); + sb.Append("\n"); + EmitInterfaceMethodsDecl(sb, g_tab); + sb.Append("};\n\n"); + } else { + sb.AppendFormat("class %s : public IRemoteBroker {\n", interfaceName_.string()); + sb.Append("public:\n"); + EmitInterfaceDescriptor(sb, g_tab); + sb.Append("\n"); + EmitInterfaceDestruction(sb, g_tab); + sb.Append("\n"); + EmitInterfaceMethodsDecl(sb, g_tab); + sb.Append("};\n\n"); } } -void CppClientInterfaceCodeEmitter::EmitInterfaceDecl(StringBuilder& sb) +void CppInterfaceCodeEmitter::EmitInterfaceDescriptor(StringBuilder& sb, const String& prefix) { - sb.AppendFormat("class %s : public IRemoteBroker {\n", interface_->GetName().string()); - sb.Append("public:\n"); - EmitInterfaceBody(sb, TAB); - sb.Append("};\n\n"); + sb.Append(g_tab).AppendFormat("DECLARE_INTERFACE_DESCRIPTOR(u\"%s\");\n", interfaceFullName_.string()); } -void CppClientInterfaceCodeEmitter::EmitInterfaceBody(StringBuilder& sb, const String& prefix) +void CppInterfaceCodeEmitter::EmitGetMethodDecl(StringBuilder& sb, const String& prefix) { - sb.Append(TAB).AppendFormat("DECLARE_INTERFACE_DESCRIPTOR(u\"%s\");\n", interfaceFullName_.string()); - sb.Append("\n"); - EmitInterfaceDestruction(sb, TAB); - sb.Append("\n"); - if (!isCallbackInterface()) { - EmitInterfaceGetMethodDecl(sb, TAB); - sb.Append("\n"); - } - EmitInterfaceMethodsDecl(sb, TAB); + sb.Append(prefix).AppendFormat("static sptr<%s> Get();\n", interface_->GetName().string()); } -void CppClientInterfaceCodeEmitter::EmitInterfaceDestruction(StringBuilder& sb, const String& prefix) +void CppInterfaceCodeEmitter::EmitGetInstanceMethodDecl(StringBuilder& sb, const String& prefix) { - sb.Append(prefix).AppendFormat("virtual ~%s() = default;\n", interface_->GetName().string()); + sb.Append(prefix).AppendFormat("static sptr<%s> GetInstance(const std::string& serviceName);\n", + interface_->GetName().string()); } -void CppClientInterfaceCodeEmitter::EmitInterfaceGetMethodDecl(StringBuilder& sb, const String& prefix) +void CppInterfaceCodeEmitter::EmitInterfaceDestruction(StringBuilder& sb, const String& prefix) { - sb.Append(prefix).AppendFormat("static sptr<%s> Get();\n", interface_->GetName().string()); + sb.Append(prefix).AppendFormat("virtual ~%s() = default;\n", interface_->GetName().string()); } -void CppClientInterfaceCodeEmitter::EmitInterfaceMethodsDecl(StringBuilder& sb, const String& prefix) +void CppInterfaceCodeEmitter::EmitInterfaceMethodsDecl(StringBuilder& sb, const String& prefix) { for (size_t i = 0; i < interface_->GetMethodNumber(); i++) { AutoPtr method = interface_->GetMethod(i); @@ -188,7 +148,7 @@ void CppClientInterfaceCodeEmitter::EmitInterfaceMethodsDecl(StringBuilder& sb, } } -void CppClientInterfaceCodeEmitter::EmitInterfaceMethodDecl(const AutoPtr& method, StringBuilder& sb, +void CppInterfaceCodeEmitter::EmitInterfaceMethodDecl(const AutoPtr& method, StringBuilder& sb, const String& prefix) { if (method->GetParameterNumber() == 0) { @@ -205,12 +165,12 @@ void CppClientInterfaceCodeEmitter::EmitInterfaceMethodDecl(const AutoPtr& param, StringBuilder& sb, +void CppInterfaceCodeEmitter::EmitInterfaceMethodParameter(const AutoPtr& param, StringBuilder& sb, const String& prefix) { sb.Append(prefix).Append(param->EmitCppParameter()); diff --git a/tools/hdi-gen/codegen/cpp_client_interface_code_emitter.h b/tools/hdi-gen/codegen/cpp_interface_code_emitter.h similarity index 48% rename from tools/hdi-gen/codegen/cpp_client_interface_code_emitter.h rename to tools/hdi-gen/codegen/cpp_interface_code_emitter.h index 27e5662dec789e1cae15d084600cd18649b836b6..d4eddb594a6879e5e051fef1114d10b9a9fff285 100755 --- a/tools/hdi-gen/codegen/cpp_client_interface_code_emitter.h +++ b/tools/hdi-gen/codegen/cpp_interface_code_emitter.h @@ -6,51 +6,48 @@ * See the LICENSE file in the root of this repository for complete details. */ -#ifndef OHOS_HDI_CPP_CLIENT_INTERFACE_CODE_EMITTER_H -#define OHOS_HDI_CPP_CLIENT_INTERFACE_CODE_EMITTER_H +#ifndef OHOS_HDI_CPP_INTERFACE_CODE_EMITTER_H +#define OHOS_HDI_CPP_INTERFACE_CODE_EMITTER_H #include "codegen/cpp_code_emitter.h" namespace OHOS { namespace HDI { -class CppClientInterfaceCodeEmitter : public CppCodeEmitter { -public: - CppClientInterfaceCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - : CppCodeEmitter(ast, targetDirectory) {} - virtual ~CppClientInterfaceCodeEmitter() = default; +class CppInterfaceCodeEmitter : public CppCodeEmitter { +public: + CppInterfaceCodeEmitter() : CppCodeEmitter() {} - void EmitCode() override; + virtual ~CppInterfaceCodeEmitter() = default; private: - void EmitInterfaceHeaderFile(); + bool ResolveDirectory(const String& targetDirectory) override; - void EmitClientInfHeadMacro(StringBuilder& sb); + void EmitCode() override; - void EmitClientInfTailMacro(StringBuilder& sb); + void EmitInterfaceHeaderFile(); void EmitInterfaceInclusions(StringBuilder& sb); - void EmitInterfaceStdlibInclusions(StringBuilder& sb); + void GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); - void EmitInterfaceDBinderInclusions(StringBuilder& sb); + void EmitInterfaceDefinition(StringBuilder& sb); - void EmitInterfaceSelfDefinedTypeInclusions(StringBuilder& sb); + void EmitInterfaceDescriptor(StringBuilder& sb, const String& prefix); - void EmitInterfaceDecl(StringBuilder& sb); + void EmitGetMethodDecl(StringBuilder& sb, const String& prefix); - void EmitInterfaceBody(StringBuilder& sb, const String& prefix); + void EmitGetInstanceMethodDecl(StringBuilder& sb, const String& prefix); void EmitInterfaceDestruction(StringBuilder& sb, const String& prefix); - void EmitInterfaceGetMethodDecl(StringBuilder& sb, const String& prefix); - void EmitInterfaceMethodsDecl(StringBuilder& sb, const String& prefix); void EmitInterfaceMethodDecl(const AutoPtr& method, StringBuilder& sb, const String& prefix); void EmitInterfaceMethodParameter(const AutoPtr& param, StringBuilder& sb, const String& prefix); }; + } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_CPP_CLIENT_INTERFACE_CODE_EMITTER_H \ No newline at end of file +#endif // OHOS_HDI_CPP_INTERFACE_CODE_EMITTER_H \ No newline at end of file diff --git a/tools/hdi-gen/codegen/cpp_service_driver_code_emitter.cpp b/tools/hdi-gen/codegen/cpp_service_driver_code_emitter.cpp index 24425526430a76a1d302d7d294f14222ea59d38d..736f665b4a753476184a14bd3668f8fecf50b4e5 100755 --- a/tools/hdi-gen/codegen/cpp_service_driver_code_emitter.cpp +++ b/tools/hdi-gen/codegen/cpp_service_driver_code_emitter.cpp @@ -9,15 +9,24 @@ #include "codegen/cpp_service_driver_code_emitter.h" #include "util/file.h" #include "util/logger.h" +#include "util/options.h" namespace OHOS { namespace HDI { -CppServiceDriverCodeEmitter::CppServiceDriverCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - :CppCodeEmitter(ast, targetDirectory) +bool CppServiceDriverCodeEmitter::ResolveDirectory(const String& targetDirectory) { - String infFullName = String::Format("%sserver.%s", - interface_->GetNamespace()->ToString().string(), infName_.string()); - sourceFileName_ = String::Format("%s_driver.cpp", FileName(infFullName).string()); + if (ast_->GetASTFileType() != ASTFileType::AST_IFACE) { + return false; + } + + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); + if (!File::CreateParentDir(directory_)) { + Logger::E("CppServiceDriverCodeEmitter", "Create '%s' failed!", directory_.string()); + return false; + } + + return true; } void CppServiceDriverCodeEmitter::EmitCode() @@ -30,14 +39,8 @@ void CppServiceDriverCodeEmitter::EmitCode() void CppServiceDriverCodeEmitter::EmitDriverSourceFile() { - String filePath = String::Format("%sserver/%s.cpp", directory_.string(), FileName(infName_ + "Driver").string()); - if (!File::CreateParentDir(filePath)) { - Logger::E("CppServiceDriverCodeEmitter", "Create '%s' failed!", filePath.string()); - return; - } - + String filePath = String::Format("%s%s.cpp", directory_.string(), FileName(infName_ + "Driver").string()); File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); @@ -86,23 +89,23 @@ void CppServiceDriverCodeEmitter::EmitDriverUsings(StringBuilder& sb) void CppServiceDriverCodeEmitter::EmitDriverServiceDecl(StringBuilder& sb) { - sb.AppendFormat("struct Hdf%s%s {\n", infName_.string(), "Service"); - sb.Append(TAB).Append("struct IDeviceIoService ioservice;\n"); - sb.Append(TAB).Append("void *instance;\n"); + sb.AppendFormat("struct Hdf%sHost {\n", infName_.string()); + sb.Append(g_tab).Append("struct IDeviceIoService ioservice;\n"); + sb.Append(g_tab).Append("void *instance;\n"); sb.Append("};\n"); } void CppServiceDriverCodeEmitter::EmitDriverDispatch(StringBuilder& sb) { - sb.AppendFormat("static int32_t %sServiceDispatch(struct HdfDeviceIoClient *client, int cmdId,\n", + sb.AppendFormat("static int32_t %sDriverDispatch(struct HdfDeviceIoClient *client, int cmdId,\n", infName_.string()); - sb.Append(TAB).Append("struct HdfSBuf *data, struct HdfSBuf *reply)\n"); + sb.Append(g_tab).Append("struct HdfSBuf *data, struct HdfSBuf *reply)\n"); sb.Append("{\n"); - sb.Append(TAB).AppendFormat("struct Hdf%sService *hdf%sService = CONTAINER_OF(\n", + sb.Append(g_tab).AppendFormat("struct Hdf%sHost *hdf%sHost = CONTAINER_OF(\n", infName_.string(), infName_.string()); - sb.Append(TAB).Append(TAB).AppendFormat("client->device->service, struct Hdf%sService, ioservice);\n", + sb.Append(g_tab).Append(g_tab).AppendFormat("client->device->service, struct Hdf%sHost, ioservice);\n", infName_.string()); - sb.Append(TAB).AppendFormat("return %sServiceOnRemoteRequest(hdf%sService->instance, cmdId, data, reply);\n", + sb.Append(g_tab).AppendFormat("return %sServiceOnRemoteRequest(hdf%sHost->instance, cmdId, data, reply);\n", infName_.string(), infName_.string()); sb.Append("}\n"); } @@ -111,8 +114,8 @@ void CppServiceDriverCodeEmitter::EmitDriverInit(StringBuilder& sb) { sb.AppendFormat("int Hdf%sDriverInit(struct HdfDeviceObject *deviceObject)\n", infName_.string()); sb.Append("{\n"); - sb.Append(TAB).AppendFormat("HDF_LOGI(\"Hdf%sDriverInit enter, new hdi impl.\");\n", infName_.string()); - sb.Append(TAB).Append("return HDF_SUCCESS;\n"); + sb.Append(g_tab).AppendFormat("HDF_LOGI(\"Hdf%sDriverInit enter\");\n", infName_.string()); + sb.Append(g_tab).Append("return HDF_SUCCESS;\n"); sb.Append("}\n"); } @@ -120,25 +123,25 @@ void CppServiceDriverCodeEmitter::EmitDriverBind(StringBuilder& sb) { sb.AppendFormat("int Hdf%sDriverBind(struct HdfDeviceObject *deviceObject)\n", infName_.string()); sb.Append("{\n"); - sb.Append(TAB).AppendFormat("HDF_LOGI(\"Hdf%sDriverBind enter.\");\n", infName_.string()); + sb.Append(g_tab).AppendFormat("HDF_LOGI(\"Hdf%sDriverBind enter\");\n", infName_.string()); sb.Append("\n"); - sb.Append(TAB).AppendFormat("struct Hdf%sService *hdf%sService = (struct Hdf%sService *)OsalMemAlloc(\n", + sb.Append(g_tab).AppendFormat("struct Hdf%sHost *hdf%sHost = (struct Hdf%sHost *)OsalMemAlloc(\n", infName_.string(), infName_.string(), infName_.string()); - sb.Append(TAB).Append(TAB).AppendFormat("sizeof(struct Hdf%sService));\n", infName_.string()); - sb.Append(TAB).AppendFormat("if (hdf%sService == nullptr) {\n", infName_.string()); - sb.Append(TAB).Append(TAB).AppendFormat("HDF_LOGE(\"Hdf%sDriverBind OsalMemAlloc Hdf%sService failed!\");\n", + sb.Append(g_tab).Append(g_tab).AppendFormat("sizeof(struct Hdf%sHost));\n", infName_.string()); + sb.Append(g_tab).AppendFormat("if (hdf%sHost == nullptr) {\n", infName_.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("HDF_LOGE(\"Hdf%sDriverBind OsalMemAlloc Hdf%sHost failed!\");\n", infName_.string(), infName_.string()); - sb.Append(TAB).Append(TAB).Append("return HDF_FAILURE;\n"); - sb.Append(TAB).Append("}\n"); + sb.Append(g_tab).Append(g_tab).Append("return HDF_FAILURE;\n"); + sb.Append(g_tab).Append("}\n"); sb.Append("\n"); - sb.Append(TAB).AppendFormat("hdf%sService->ioservice.Dispatch = %sServiceDispatch;\n", + sb.Append(g_tab).AppendFormat("hdf%sHost->ioservice.Dispatch = %sDriverDispatch;\n", infName_.string(), infName_.string()); - sb.Append(TAB).AppendFormat("hdf%sService->ioservice.Open = NULL;\n", infName_.string()); - sb.Append(TAB).AppendFormat("hdf%sService->ioservice.Release = NULL;\n", infName_.string()); - sb.Append(TAB).AppendFormat("hdf%sService->instance = %sStubInstance();\n", infName_.string(), infName_.string()); + sb.Append(g_tab).AppendFormat("hdf%sHost->ioservice.Open = NULL;\n", infName_.string()); + sb.Append(g_tab).AppendFormat("hdf%sHost->ioservice.Release = NULL;\n", infName_.string()); + sb.Append(g_tab).AppendFormat("hdf%sHost->instance = %sStubInstance();\n", infName_.string(), infName_.string()); sb.Append("\n"); - sb.Append(TAB).AppendFormat("deviceObject->service = &hdf%sService->ioservice;\n", infName_.string()); - sb.Append(TAB).Append("return HDF_SUCCESS;\n"); + sb.Append(g_tab).AppendFormat("deviceObject->service = &hdf%sHost->ioservice;\n", infName_.string()); + sb.Append(g_tab).Append("return HDF_SUCCESS;\n"); sb.Append("}\n"); } @@ -146,18 +149,23 @@ void CppServiceDriverCodeEmitter::EmitDriverRelease(StringBuilder& sb) { sb.AppendFormat("void Hdf%sDriverRelease(struct HdfDeviceObject *deviceObject)", infName_.string()); sb.Append("{\n"); - sb.Append(TAB).AppendFormat("HDF_LOGI(\"Hdf%sDriverRelease enter.\");\n", interfaceName_.string()); + sb.Append(g_tab).AppendFormat("HDF_LOGI(\"Hdf%sDriverRelease enter\");\n\n", infName_.string()); + sb.Append(g_tab).AppendFormat("struct Hdf%sHost *hdf%sHost = CONTAINER_OF(", infName_.string(), infName_.string()); + sb.AppendFormat("deviceObject->service, struct Hdf%sHost, ioservice);\n", infName_.string()); + sb.Append(g_tab).AppendFormat("%sStubRelease(hdf%sHost->instance);\n", infName_.string(), infName_.string()); + sb.Append(g_tab).AppendFormat("OsalMemFree(hdf%sHost);\n", infName_.string()); sb.Append("}\n"); } void CppServiceDriverCodeEmitter::EmitDriverEntryDefinition(StringBuilder& sb) { sb.AppendFormat("struct HdfDriverEntry g_%sDriverEntry = {\n", infName_.ToLowerCase().string()); - sb.Append(TAB).Append(".moduleVersion = 1,\n"); - sb.Append(TAB).AppendFormat(".moduleName = \"%s\",\n", infName_.ToLowerCase().string()); - sb.Append(TAB).AppendFormat(".Bind = Hdf%sDriverBind,\n", infName_.string()); - sb.Append(TAB).AppendFormat(".Init = Hdf%sDriverInit,\n", infName_.string()); - sb.Append(TAB).AppendFormat(".Release = Hdf%sDriverRelease,\n", infName_.string()); + sb.Append(g_tab).Append(".moduleVersion = 1,\n"); + sb.Append(g_tab).AppendFormat(".moduleName = \"%s\",\n", + Options::GetInstance().GetModuleName().string()); + sb.Append(g_tab).AppendFormat(".Bind = Hdf%sDriverBind,\n", infName_.string()); + sb.Append(g_tab).AppendFormat(".Init = Hdf%sDriverInit,\n", infName_.string()); + sb.Append(g_tab).AppendFormat(".Release = Hdf%sDriverRelease,\n", infName_.string()); sb.Append("};\n"); sb.Append("\n"); sb.Append("#ifndef __cplusplus\n"); diff --git a/tools/hdi-gen/codegen/cpp_service_driver_code_emitter.h b/tools/hdi-gen/codegen/cpp_service_driver_code_emitter.h index 2d67cbf271a04c4c209c46a223d77f6c3aeafccc..f552b32c44f8bb8262eebdbfb0e27a126127198c 100755 --- a/tools/hdi-gen/codegen/cpp_service_driver_code_emitter.h +++ b/tools/hdi-gen/codegen/cpp_service_driver_code_emitter.h @@ -15,12 +15,14 @@ namespace OHOS { namespace HDI { class CppServiceDriverCodeEmitter : public CppCodeEmitter { public: - CppServiceDriverCodeEmitter(const AutoPtr& ast, const String& targetDirectory); + CppServiceDriverCodeEmitter() : CppCodeEmitter() {} virtual ~CppServiceDriverCodeEmitter() = default; +private: + bool ResolveDirectory(const String& targetDirectory) override; void EmitCode() override; -private: + void EmitDriverSourceFile(); void EmitDriverIncluions(StringBuilder& sb); diff --git a/tools/hdi-gen/codegen/cpp_service_impl_code_emitter.cpp b/tools/hdi-gen/codegen/cpp_service_impl_code_emitter.cpp index 486c5fe096bbdb4837db7c0201757a3b9571e000..873ba68de6474ec114d2ad5202d0cd2af6fb5116 100755 --- a/tools/hdi-gen/codegen/cpp_service_impl_code_emitter.cpp +++ b/tools/hdi-gen/codegen/cpp_service_impl_code_emitter.cpp @@ -12,12 +12,22 @@ namespace OHOS { namespace HDI { -CppServiceImplCodeEmitter::CppServiceImplCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - :CppCodeEmitter(ast, targetDirectory) +bool CppServiceImplCodeEmitter::ResolveDirectory(const String& targetDirectory) { - String ImplFullName = String::Format("%sserver.%s", - interface_->GetNamespace()->ToString().string(), ImplName_.string()); - sourceFileName_ = String::Format("%s.cpp", FileName(ImplFullName).string()); + if (ast_->GetASTFileType() == ASTFileType::AST_IFACE || + ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) { + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); + } else { + return false; + } + + if (!File::CreateParentDir(directory_)) { + Logger::E("CppServiceImplCodeEmitter", "Create '%s' failed!", directory_.string()); + return false; + } + + return true; } void CppServiceImplCodeEmitter::EmitCode() @@ -28,30 +38,30 @@ void CppServiceImplCodeEmitter::EmitCode() void CppServiceImplCodeEmitter::EmitImplHeaderFile() { - String filePath; - if (!isCallbackInterface()) { - filePath = String::Format("%sserver/%s.h", directory_.string(), FileName(infName_ + "Service").string()); - } else { - filePath = String::Format("%s%s.h", directory_.string(), FileName(infName_ + "Service").string()); - } - - if (!File::CreateParentDir(filePath)) { - Logger::E("CppServiceImplCodeEmitter", "Create '%s' failed!", filePath.string()); - return; - } - + String filePath = String::Format("%s%s.h", directory_.string(), FileName(infName_ + "Service").string()); File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); - EmitHeadMacro(sb, ImplFullName_); + EmitHeadMacro(sb, implFullName_); sb.Append("\n"); EmitServiceImplInclusions(sb); sb.Append("\n"); EmitServiceImplDecl(sb); + + if (!isCallbackInterface()) { + sb.Append("\n"); + EmitHeadExternC(sb); + sb.Append("\n"); + EmitExternalGetMethodDecl(sb); + sb.Append("\n"); + EmitExternalReleaseMethodDecl(sb); + sb.Append("\n"); + EmitTailExternC(sb); + } + sb.Append("\n"); - EmitTailMacro(sb, ImplFullName_); + EmitTailMacro(sb, implFullName_); String data = sb.ToString(); file.WriteData(data.string(), data.GetLength()); @@ -61,12 +71,16 @@ void CppServiceImplCodeEmitter::EmitImplHeaderFile() void CppServiceImplCodeEmitter::EmitServiceImplInclusions(StringBuilder& sb) { + HeaderFile::HeaderFileSet headerFiles; if (!isCallbackInterface()) { - sb.AppendFormat("#include \"%s.h\"\n", FileName(interfaceName_).string()); + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_MODULE_HEADER_FILE, FileName(interfaceName_))); } else { - sb.AppendFormat("#include \"%s.h\"\n", FileName(stubName_).string()); + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_HEADER_FILE, FileName(stubName_))); + } + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); } - sb.Append("#include \n"); } void CppServiceImplCodeEmitter::EmitServiceImplDecl(StringBuilder& sb) @@ -79,7 +93,7 @@ void CppServiceImplCodeEmitter::EmitServiceImplDecl(StringBuilder& sb) sb.AppendFormat("class %sService : public %s {\n", infName_.string(), stubName_.string()); } sb.Append("public:\n"); - EmitServiceImplBody(sb, TAB); + EmitServiceImplBody(sb, g_tab); sb.Append("};\n"); sb.Append("\n"); @@ -88,9 +102,9 @@ void CppServiceImplCodeEmitter::EmitServiceImplDecl(StringBuilder& sb) void CppServiceImplCodeEmitter::EmitServiceImplBody(StringBuilder& sb, const String& prefix) { - EmitServiceImplDestruction(sb, TAB); + EmitServiceImplDestruction(sb, g_tab); sb.Append("\n"); - EmitServiceImplMethodDecls(sb, TAB); + EmitServiceImplMethodDecls(sb, g_tab); } void CppServiceImplCodeEmitter::EmitServiceImplDestruction(StringBuilder& sb, const String& prefix) @@ -127,37 +141,41 @@ void CppServiceImplCodeEmitter::EmitServiceImplMethodDecl(const AutoPtrGetMethodNumber(); i++) { @@ -194,13 +228,33 @@ void CppServiceImplCodeEmitter::EmitServiceImplMethodImpl(const AutoPtr& ast, const String& targetDirectory); + CppServiceImplCodeEmitter() : CppCodeEmitter() {} virtual ~CppServiceImplCodeEmitter() = default; +private: + bool ResolveDirectory(const String& targetDirectory) override; void EmitCode() override; -private: + void EmitImplHeaderFile(); void EmitServiceImplInclusions(StringBuilder& sb); @@ -35,11 +37,23 @@ private: void EmitServiceImplMethodDecl(const AutoPtr& method, StringBuilder& sb, const String& prefix); + void EmitExternalGetMethodDecl(StringBuilder& sb); + + void EmitExternalReleaseMethodDecl(StringBuilder& sb); + void EmitImplSourceFile(); + void EmitImplSourceInclusions(StringBuilder& sb); + + void GetSourceOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); + void EmitServiceImplMethodImpls(StringBuilder& sb, const String& prefix); void EmitServiceImplMethodImpl(const AutoPtr& method, StringBuilder& sb, const String& prefix); + + void EmitExternalGetMethodImpl(StringBuilder& sb); + + void EmitExternalReleaseMethodImpl(StringBuilder& sb); }; } // namespace HDI } // namespace OHOS diff --git a/tools/hdi-gen/codegen/cpp_service_interface_code_emitter.cpp b/tools/hdi-gen/codegen/cpp_service_interface_code_emitter.cpp deleted file mode 100755 index 289d0e782830a446abb23077c51fb05491dabb75..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/codegen/cpp_service_interface_code_emitter.cpp +++ /dev/null @@ -1,207 +0,0 @@ -/* - * Copyright (c) 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 "codegen/cpp_service_interface_code_emitter.h" -#include "util/file.h" -#include "util/logger.h" - -namespace OHOS { -namespace HDI { -void CppServiceInterfaceCodeEmitter::EmitCode() -{ - if (!isCallbackInterface()) { - EmitInterfaceHeaderFile(); - } -} - -void CppServiceInterfaceCodeEmitter::EmitInterfaceHeaderFile() -{ - String filePath; - if (!isCallbackInterface()) { - filePath = String::Format("%sserver/%s.h", directory_.string(), FileName(interfaceName_).string()); - } else { - filePath = String::Format("%s%s.h", directory_.string(), FileName(interfaceName_).string()); - } - - if (!File::CreateParentDir(filePath)) { - Logger::E("CppServiceInterfaceCodeEmitter", "Create '%s' failed!", filePath.string()); - return; - } - - File file(filePath, File::WRITE); - - StringBuilder sb; - - EmitLicense(sb); - EmitServiceInfHeadMacro(sb); - sb.Append("\n"); - EmitInterfaceInclusions(sb); - sb.Append("\n"); - EmitBeginNamespace(sb); - sb.Append("\n"); - EmitUsingNamespace(sb); - sb.Append("\n"); - EmitInterfaceDecl(sb); - sb.Append("\n"); - EmitEndNamespace(sb); - sb.Append("\n"); - EmitServiceInfTailMacro(sb); - - String data = sb.ToString(); - file.WriteData(data.string(), data.GetLength()); - file.Flush(); - file.Close(); -} - -void CppServiceInterfaceCodeEmitter::EmitServiceInfHeadMacro(StringBuilder& sb) -{ - String serviceMacroName(interfaceFullName_); - if (!isCallbackInterface()) { - serviceMacroName += ".service"; - } - EmitHeadMacro(sb, serviceMacroName); -} - -void CppServiceInterfaceCodeEmitter::EmitServiceInfTailMacro(StringBuilder& sb) -{ - String serviceMacroName(interfaceFullName_); - if (!isCallbackInterface()) { - serviceMacroName += ".service"; - } - EmitTailMacro(sb, serviceMacroName); -} - -void CppServiceInterfaceCodeEmitter::EmitInterfaceInclusions(StringBuilder& sb) -{ - EmitInterfaceStdlibInclusions(sb); - EmitInterfaceDBinderInclusions(sb); - EmitInterfaceSelfDefinedTypeInclusions(sb); -} - -void CppServiceInterfaceCodeEmitter::EmitInterfaceStdlibInclusions(StringBuilder& sb) -{ - bool includeString = false; - bool includeList = false; - bool includeMap = false; - - const AST::TypeStringMap& types = ast_->GetTypes(); - for (const auto& pair : types) { - AutoPtr type = pair.second; - switch (type->GetTypeKind()) { - case TypeKind::TYPE_STRING: { - if (!includeString) { - sb.Append("#include \n"); - includeString = true; - } - break; - } - case TypeKind::TYPE_ARRAY: - case TypeKind::TYPE_LIST: { - if (!includeList) { - sb.Append("#include \n"); - includeList = true; - } - break; - } - case TypeKind::TYPE_MAP: { - if (!includeMap) { - sb.Append("#include \n"); - includeMap = true; - } - break; - } - default: - break; - } - } -} - -void CppServiceInterfaceCodeEmitter::EmitInterfaceDBinderInclusions(StringBuilder& sb) -{ - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.Append("#include \n"); -} - -void CppServiceInterfaceCodeEmitter::EmitInterfaceSelfDefinedTypeInclusions(StringBuilder& sb) -{ - for (const auto& importPair : ast_->GetImports()) { - AutoPtr importAst = importPair.second; - - String fileName; - if (importAst->GetASTFileType() == ASTFileType::AST_ICALLBACK && importAst->GetInterfaceDef() != nullptr) { - String ifaceName = importAst->GetInterfaceDef()->GetName(); - String name = ifaceName.StartsWith("I") ? ifaceName.Substring(1) : ifaceName; - String stubName = name + "Proxy"; - fileName = FileName(importAst->GetInterfaceDef()->GetNamespace()->ToString() + stubName); - } else { - fileName = FileName(importAst->GetFullName()); - } - sb.Append("#include ").AppendFormat("\"%s.h\"\n", fileName.string()); - } -} - -void CppServiceInterfaceCodeEmitter::EmitInterfaceDecl(StringBuilder& sb) -{ - EmitInterfaceMethodCommands(sb, ""); - sb.Append("\n"); - - sb.AppendFormat("class %s {\n", interface_->GetName().string()); - sb.Append("public:\n"); - EmitInterfaceBody(sb, TAB); - sb.Append("};\n"); -} - -void CppServiceInterfaceCodeEmitter::EmitInterfaceBody(StringBuilder& sb, const String& prefix) -{ - EmitInterfaceDestruction(sb, TAB); - sb.Append("\n"); - EmitInterfaceMethods(sb, TAB); -} - -void CppServiceInterfaceCodeEmitter::EmitInterfaceDestruction(StringBuilder& sb, const String& prefix) -{ - sb.Append(prefix).AppendFormat("virtual ~%s() {}\n", interface_->GetName().string()); -} - -void CppServiceInterfaceCodeEmitter::EmitInterfaceMethods(StringBuilder& sb, const String& prefix) -{ - for (size_t i = 0; i < interface_->GetMethodNumber(); i++) { - AutoPtr method = interface_->GetMethod(i); - EmitInterfaceMethod(method, sb, prefix); - if (i + 1 < interface_->GetMethodNumber()) { - sb.Append("\n"); - } - } -} - -void CppServiceInterfaceCodeEmitter::EmitInterfaceMethod(const AutoPtr& method, StringBuilder& sb, - const String& prefix) -{ - if (method->GetParameterNumber() == 0) { - sb.Append(prefix).AppendFormat("virtual int32_t %s() = 0;\n", method->GetName().string()); - } else { - StringBuilder paramStr; - paramStr.Append(prefix).AppendFormat("virtual int32_t %s(", method->GetName().string()); - - for (size_t i = 0; i < method->GetParameterNumber(); i++) { - AutoPtr param = method->GetParameter(i); - EmitInterfaceMethodParameter(param, paramStr, ""); - if (i + 1 < method->GetParameterNumber()) { - paramStr.Append(", "); - } - } - - paramStr.Append(") = 0;"); - - sb.Append(SpecificationParam(paramStr, prefix + TAB)); - sb.Append("\n"); - } -} -} // namespace HDI -} // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/codegen/cpp_service_interface_code_emitter.h b/tools/hdi-gen/codegen/cpp_service_interface_code_emitter.h deleted file mode 100755 index 7e648887e6b4e119890091b50886748a8589e1f4..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/codegen/cpp_service_interface_code_emitter.h +++ /dev/null @@ -1,56 +0,0 @@ -/* - * Copyright (c) 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 OHOS_HDI_CPP_SERVICE_INTERFACE_CODE_EMITTER_H -#define OHOS_HDI_CPP_SERVICE_INTERFACE_CODE_EMITTER_H - -#include "codegen/cpp_code_emitter.h" - -namespace OHOS { -namespace HDI { -class CppServiceInterfaceCodeEmitter : public CppCodeEmitter { -public: - CppServiceInterfaceCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - : CppCodeEmitter(ast, targetDirectory) {} - - virtual ~CppServiceInterfaceCodeEmitter() = default; - - void EmitCode() override; -private: - void EmitInterfaceHeaderFile(); - - void EmitServiceInfHeadMacro(StringBuilder& sb); - - void EmitServiceInfTailMacro(StringBuilder& sb); - - void EmitInterfaceInclusions(StringBuilder& sb); - - void EmitInterfaceStdlibInclusions(StringBuilder& sb); - - void EmitInterfaceDBinderInclusions(StringBuilder& sb); - - void EmitInterfaceSelfDefinedTypeInclusions(StringBuilder& sb); - - void EmitInterfaceUsings(StringBuilder& sb); - - void EmitInterfaceSelfDefinedTypeUsings(StringBuilder& sb); - - void EmitInterfaceDecl(StringBuilder& sb); - - void EmitInterfaceBody(StringBuilder& sb, const String& prefix); - - void EmitInterfaceDestruction(StringBuilder& sb, const String& prefix); - - void EmitInterfaceMethods(StringBuilder& sb, const String& prefix); - - void EmitInterfaceMethod(const AutoPtr& method, StringBuilder& sb, const String& prefix); -}; -} // namespace HDI -} // namespace OHOS - -#endif // OHOS_HDI_CPP_SERVICE_INTERFACE_CODE_EMITTER_H \ No newline at end of file diff --git a/tools/hdi-gen/codegen/cpp_service_stub_code_emitter.cpp b/tools/hdi-gen/codegen/cpp_service_stub_code_emitter.cpp index 57218965653eb47be265be5f60edec266307162e..e90a0eec8cb622da69bae1af4554440ac7a65be0 100755 --- a/tools/hdi-gen/codegen/cpp_service_stub_code_emitter.cpp +++ b/tools/hdi-gen/codegen/cpp_service_stub_code_emitter.cpp @@ -12,12 +12,22 @@ namespace OHOS { namespace HDI { -CppServiceStubCodeEmitter::CppServiceStubCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - :CppCodeEmitter(ast, targetDirectory) +bool CppServiceStubCodeEmitter::ResolveDirectory(const String& targetDirectory) { - String stubFullName = String::Format("%sserver.%s", - interface_->GetNamespace()->ToString().string(), stubName_.string()); - sourceFileName_ = String::Format("%s.cpp", FileName(stubFullName).string()); + if (ast_->GetASTFileType() == ASTFileType::AST_IFACE || + ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) { + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); + } else { + return false; + } + + if (!File::CreateParentDir(directory_)) { + Logger::E("CppServiceStubCodeEmitter", "Create '%s' failed!", directory_.string()); + return false; + } + + return true; } void CppServiceStubCodeEmitter::EmitCode() @@ -28,20 +38,8 @@ void CppServiceStubCodeEmitter::EmitCode() void CppServiceStubCodeEmitter::EmitStubHeaderFile() { - String filePath; - if (!isCallbackInterface()) { - filePath = String::Format("%sserver/%s.h", directory_.string(), FileName(infName_ + "Stub").string()); - } else { - filePath = String::Format("%s%s.h", directory_.string(), FileName(infName_ + "Stub").string()); - } - - if (!File::CreateParentDir(filePath)) { - Logger::E("CppServiceStubCodeEmitter", "Create '%s' failed!", filePath.string()); - return; - } - + String filePath = String::Format("%s%s.h", directory_.string(), FileName(stubName_).string()); File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); @@ -66,14 +64,22 @@ void CppServiceStubCodeEmitter::EmitStubHeaderFile() void CppServiceStubCodeEmitter::EmitStubHeaderInclusions(StringBuilder& sb) { - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.Append("#include \n"); - if (!isCallbackInterface()) { - sb.AppendFormat("#include \"%s_service.h\"\n", FileName(infName_).string()); - } else { - sb.Append("#include \n"); - sb.AppendFormat("#include \"%s.h\"\n", FileName(interfaceName_).string()); + HeaderFile::HeaderFileSet headerFiles; + + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_MODULE_HEADER_FILE, FileName(interfaceName_))); + GetHeaderOtherLibInclusions(headerFiles); + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); + } +} + +void CppServiceStubCodeEmitter::GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles) +{ + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "message_parcel")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "message_option")); + if (isCallbackInterface()) { + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "iremote_stub")); } } @@ -84,8 +90,7 @@ void CppServiceStubCodeEmitter::EmitStubDecl(StringBuilder& sb) EmitStubUsingNamespace(sb); sb.Append("\n"); sb.AppendFormat("class %s {\n", stubName_.string()); - sb.Append("public:\n"); - EmitStubBody(sb, TAB); + EmitStubBody(sb, g_tab); sb.Append("};\n"); sb.Append("\n"); @@ -102,7 +107,7 @@ void CppServiceStubCodeEmitter::EmitCbStubDecl(StringBuilder& sb) EmitStubUsingNamespace(sb); sb.Append("\n"); sb.AppendFormat("class %s : public IRemoteStub<%s> {\n", stubName_.string(), interfaceName_.string()); - EmitCbStubBody(sb, TAB); + EmitCbStubBody(sb, g_tab); sb.Append("};\n"); sb.Append("\n"); EmitEndNamespace(sb); @@ -143,7 +148,7 @@ void CppServiceStubCodeEmitter::EmitStubDestruction(StringBuilder& sb, const Str void CppServiceStubCodeEmitter::EmitCbStubOnRequestDecl(StringBuilder& sb, const String& prefix) { sb.Append(prefix).Append("int32_t OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply,\n"); - sb.Append(prefix + TAB).Append("MessageOption &option) override;\n"); + sb.Append(prefix + g_tab).Append("MessageOption &option) override;\n"); } void CppServiceStubCodeEmitter::EmitStubMethodDecls(StringBuilder& sb, const String& prefix) @@ -166,21 +171,24 @@ void CppServiceStubCodeEmitter::EmitStubMethodDecls(StringBuilder& sb, const Str void CppServiceStubCodeEmitter::EmitStubMethodDecl(const AutoPtr& method, StringBuilder& sb, const String& prefix) { - sb.Append(prefix).AppendFormat("int32_t %s%s(MessageParcel& data, MessageParcel& reply, MessageOption& option);\n", - stubName_.string(), method->GetName().string()); + String dataName = "data_"; + String replyName = "reply_"; + String optionName = "option_"; + sb.Append(prefix).AppendFormat("int32_t %s%s(MessageParcel& %s, MessageParcel& %s, MessageOption& %s);\n", + stubName_.string(), method->GetName().string(), dataName.string(), replyName.string(), optionName.string()); } void CppServiceStubCodeEmitter::EmitStubOnRequestMethodDecl(StringBuilder& sb, const String& prefix) { sb.Append(prefix).AppendFormat("int32_t %sOnRemoteRequest(int cmdId, MessageParcel& data, MessageParcel& reply,\n", stubName_.string()); - sb.Append(prefix).Append(TAB).Append("MessageOption& option);\n"); + sb.Append(prefix).Append(g_tab).Append("MessageOption& option);\n"); } void CppServiceStubCodeEmitter::EmitStubMembers(StringBuilder& sb, const String& prefix) { - sb.Append("private:\n"); - sb.Append(prefix).AppendFormat("%sService service;\n", infName_.string()); + sb.Append(prefix).Append("void *dlHandler;\n"); + sb.Append(prefix).AppendFormat("%s *service;\n", interfaceName_.string()); } void CppServiceStubCodeEmitter::EmitStubExternalsMethodsDel(StringBuilder& sb) @@ -196,24 +204,24 @@ void CppServiceStubCodeEmitter::EmitStubExternalsMethodsDel(StringBuilder& sb) void CppServiceStubCodeEmitter::EmitStubSourceFile() { - String filePath; - if (!isCallbackInterface()) { - filePath = String::Format("%sserver/%s.cpp", directory_.string(), FileName(infName_ + "Stub").string()); - } else { - filePath = String::Format("%s%s.cpp", directory_.string(), FileName(infName_ + "Stub").string()); - } - - if (!File::CreateParentDir(filePath)) { - Logger::E("CppServiceStubCodeEmitter", "Create '%s' failed!", filePath.string()); - return; - } - + String filePath = String::Format("%s%s.cpp", directory_.string(), FileName(stubName_).string()); File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); EmitStubSourceInclusions(sb); + + if (!isCallbackInterface()) { + sb.Append("\n"); + EmitDriverLibPath(sb); + sb.Append("\n"); + EmitHeadExternC(sb); + sb.Append("\n"); + EmitLibFuncTypeDef(sb); + sb.Append("\n"); + EmitTailExternC(sb); + } + sb.Append("\n"); EmitBeginNamespace(sb); sb.Append("\n"); @@ -240,24 +248,50 @@ void CppServiceStubCodeEmitter::EmitStubSourceFile() void CppServiceStubCodeEmitter::EmitStubSourceInclusions(StringBuilder& sb) { - sb.AppendFormat("#include \"%s.h\"\n", FileName(stubName_).string()); - EmitStubSourceStdlibInclusions(sb); + HeaderFile::HeaderFileSet headerFiles; + headerFiles.emplace(HeaderFile(HeaderFileType::OWN_HEADER_FILE, FileName(stubName_))); + GetSourceOtherLibInclusions(headerFiles); + + for (const auto& file : headerFiles) { + sb.AppendFormat("%s\n", file.ToString().string()); + } } -void CppServiceStubCodeEmitter::EmitStubSourceStdlibInclusions(StringBuilder& sb) +void CppServiceStubCodeEmitter::GetSourceOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles) { - sb.Append("#include \n"); - sb.Append("#include \n"); - sb.Append("#include \n"); - - const AST::TypeStringMap& types = ast_->GetTypes(); - for (const auto& pair : types) { - AutoPtr type = pair.second; - if (type->GetTypeKind() == TypeKind::TYPE_UNION) { - sb.Append("#include \n"); - break; + if (!isCallbackInterface()) { + headerFiles.emplace(HeaderFile(HeaderFileType::SYSTEM_HEADER_FILE, "dlfcn")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_sbuf_ipc")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "securec")); + } else { + const AST::TypeStringMap& types = ast_->GetTypes(); + for (const auto& pair : types) { + AutoPtr type = pair.second; + if (type->GetTypeKind() == TypeKind::TYPE_UNION) { + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "securec")); + break; + } } } + + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_base")); + headerFiles.emplace(HeaderFile(HeaderFileType::OTHER_MODULES_HEADER_FILE, "hdf_log")); +} + +void CppServiceStubCodeEmitter::EmitDriverLibPath(StringBuilder& sb) +{ + sb.Append("#ifdef __ARM64__\n"); + sb.Append("#define DRIVER_PATH \"system/lib64\"\n"); + sb.Append("#else\n"); + sb.Append("#define DRIVER_PATH \"system/lib\"\n"); + sb.Append("#endif\n"); +} + +void CppServiceStubCodeEmitter::EmitLibFuncTypeDef(StringBuilder& sb) +{ + sb.AppendFormat("typedef %s* (*SERVICE_CONSTRUCT_FUNC)();\n", CppFullName(interface_->GetFullName()).string()); + sb.AppendFormat("typedef void (*SERVICE_RELEASE_FUNC)(%s *obj);\n", + CppFullName(interface_->GetFullName()).string()); } void CppServiceStubCodeEmitter::EmitStubMethodImpls(StringBuilder& sb, const String& prefix) @@ -274,167 +308,253 @@ void CppServiceStubCodeEmitter::EmitStubMethodImpls(StringBuilder& sb, const Str void CppServiceStubCodeEmitter::EmitStubMethodImpl(const AutoPtr& method, StringBuilder& sb, const String& prefix) { + String dataName = "data_"; + String replyName = "reply_"; + String optionName = "option_"; sb.Append(prefix).AppendFormat( - "int32_t %s::%s%s(MessageParcel& data, MessageParcel& reply, MessageOption& option)\n", - stubName_.string(), stubName_.string(), method->GetName().string()); + "int32_t %s::%s%s(MessageParcel& %s, MessageParcel& %s, MessageOption& %s)\n", + stubName_.string(), stubName_.string(), method->GetName().string(), + dataName.string(), replyName.string(), optionName.string()); sb.Append(prefix).Append("{\n"); for (size_t i = 0; i < method->GetParameterNumber(); i++) { AutoPtr param = method->GetParameter(i); if (param->GetAttribute() == ParamAttr::PARAM_IN) { - EmitReadMethodParameter(param, "data", true, sb, prefix + TAB); + EmitReadMethodParameter(param, dataName, true, sb, prefix + g_tab); sb.Append("\n"); } else { - EmitLocalVariable(param, sb, prefix + TAB); + EmitLocalVariable(param, sb, prefix + g_tab); sb.Append("\n"); } } - if (method->GetParameterNumber() == 0) { - if (!isCallbackInterface()) { - sb.Append(prefix + TAB).AppendFormat("int32_t ec = service.%s();\n", method->GetName().string()); - } else { - sb.Append(prefix + TAB).AppendFormat("int32_t ec = %s();\n", method->GetName().string()); - } - } else { - if (!isCallbackInterface()) { - sb.Append(prefix + TAB).AppendFormat("int32_t ec = service.%s(", method->GetName().string()); - } else { - sb.Append(prefix + TAB).AppendFormat("int32_t ec = %s(", method->GetName().string()); - } - - for (size_t i = 0; i < method->GetParameterNumber(); i++) { - AutoPtr param = method->GetParameter(i); - sb.Append(param->GetName()); - if (i + 1 < method->GetParameterNumber()) { - sb.Append(", "); - } - } - sb.Append(");\n"); - } - - sb.Append(prefix + TAB).Append("if (ec != HDF_SUCCESS) {\n"); - sb.Append(prefix + TAB + TAB).AppendFormat( - "HDF_LOGE(\"%%{public}s failed, error code is %%d\", ec);\n", method->GetName().string()); - sb.Append(prefix + TAB + TAB).Append("return ec;\n"); - sb.Append(prefix + TAB).Append("}\n\n"); + EmitStubCallMethod(method, sb, prefix + g_tab); + sb.Append("\n"); if (!method->IsOneWay()) { for (size_t i = 0; i < method->GetParameterNumber(); i++) { AutoPtr param = method->GetParameter(i); if (param->GetAttribute() == ParamAttr::PARAM_OUT) { - EmitWriteMethodParameter(param, "reply", sb, prefix + TAB); + EmitWriteMethodParameter(param, replyName, sb, prefix + g_tab); sb.Append("\n"); } } } - sb.Append(prefix + TAB).Append("return HDF_SUCCESS;\n"); + sb.Append(prefix + g_tab).Append("return HDF_SUCCESS;\n"); sb.Append("}\n"); } +void CppServiceStubCodeEmitter::EmitStubCallMethod(const AutoPtr& method, StringBuilder& sb, + const String& prefix) +{ + if (!isCallbackInterface()) { + sb.Append(prefix).AppendFormat("int32_t ec = service->%s(", method->GetName().string()); + } else { + sb.Append(prefix).AppendFormat("int32_t ec = %s(", method->GetName().string()); + } + for (size_t i = 0; i < method->GetParameterNumber(); i++) { + AutoPtr param = method->GetParameter(i); + sb.Append(param->GetName()); + if (i + 1 < method->GetParameterNumber()) { + sb.Append(", "); + } + } + sb.Append(");\n"); + + sb.Append(prefix).Append("if (ec != HDF_SUCCESS) {\n"); + sb.Append(prefix + g_tab).AppendFormat( + "HDF_LOGE(\"%%{public}s failed, error code is %%d\", __func__, ec);\n", method->GetName().string()); + sb.Append(prefix + g_tab).Append("return ec;\n"); + sb.Append(prefix).Append("}\n"); +} + void CppServiceStubCodeEmitter::EmitStubOnRequestMethodImpl(StringBuilder& sb, const String& prefix) { sb.Append(prefix).AppendFormat("int32_t %s::%sOnRemoteRequest(int cmdId,\n", stubName_.string(), stubName_.string()); - sb.Append(prefix + TAB).Append("MessageParcel& data, MessageParcel& reply, MessageOption& option)\n"); + sb.Append(prefix + g_tab).Append("MessageParcel& data, MessageParcel& reply, MessageOption& option)\n"); sb.Append(prefix).Append("{\n"); - sb.Append(prefix + TAB).Append("switch (cmdId) {\n"); + sb.Append(prefix + g_tab).Append("switch (cmdId) {\n"); for (size_t i = 0; i < interface_->GetMethodNumber(); i++) { AutoPtr method = interface_->GetMethod(i); - sb.Append(prefix + TAB + TAB).AppendFormat("case CMD_%s:\n", ConstantName(method->GetName()).string()); - sb.Append(prefix + TAB + TAB + TAB).AppendFormat("return %sStub%s(data, reply, option);\n", + sb.Append(prefix + g_tab + g_tab).AppendFormat("case CMD_%s:\n", ConstantName(method->GetName()).string()); + sb.Append(prefix + g_tab + g_tab + g_tab).AppendFormat("return %sStub%s(data, reply, option);\n", infName_.string(), method->GetName().string()); } - sb.Append(prefix + TAB + TAB).Append("default: {\n"); - sb.Append(prefix + TAB + TAB + TAB).Append( + sb.Append(prefix + g_tab + g_tab).Append("default: {\n"); + sb.Append(prefix + g_tab + g_tab + g_tab).Append( "HDF_LOGE(\"%{public}s: not support cmd %{public}d\", __func__, cmdId);\n"); - sb.Append(prefix + TAB + TAB + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB + TAB).Append("}\n"); - sb.Append(prefix + TAB).Append("}\n"); + sb.Append(prefix + g_tab + g_tab + g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(prefix + g_tab + g_tab).Append("}\n"); + sb.Append(prefix + g_tab).Append("}\n"); sb.Append("}\n"); } void CppServiceStubCodeEmitter::EmitCbStubOnRequestMethodImpl(StringBuilder& sb, const String& prefix) { sb.Append(prefix).AppendFormat("int32_t %s::OnRemoteRequest(uint32_t code,\n", stubName_.string()); - sb.Append(prefix + TAB).Append("MessageParcel& data, MessageParcel& reply, MessageOption& option)\n"); + sb.Append(prefix + g_tab).Append("MessageParcel& data, MessageParcel& reply, MessageOption& option)\n"); sb.Append(prefix).Append("{\n"); - sb.Append(prefix + TAB).Append("switch (code) {\n"); + sb.Append(prefix + g_tab).Append("switch (code) {\n"); for (size_t i = 0; i < interface_->GetMethodNumber(); i++) { AutoPtr method = interface_->GetMethod(i); - sb.Append(prefix + TAB + TAB).AppendFormat("case CMD_%s:\n", ConstantName(method->GetName()).string()); - sb.Append(prefix + TAB + TAB + TAB).AppendFormat("return %sStub%s(data, reply, option);\n", + sb.Append(prefix + g_tab + g_tab).AppendFormat("case CMD_%s:\n", ConstantName(method->GetName()).string()); + sb.Append(prefix + g_tab + g_tab + g_tab).AppendFormat("return %sStub%s(data, reply, option);\n", infName_.string(), method->GetName().string()); } - sb.Append(prefix + TAB + TAB).Append("default: {\n"); - sb.Append(prefix + TAB + TAB + TAB).Append( + sb.Append(prefix + g_tab + g_tab).Append("default: {\n"); + sb.Append(prefix + g_tab + g_tab + g_tab).Append( "HDF_LOGE(\"%{public}s: not support cmd %{public}d\", __func__, code);\n"); - sb.Append(prefix + TAB + TAB + TAB).Append("return IPCObjectStub::OnRemoteRequest(code, data, reply, option);\n"); - sb.Append(prefix + TAB + TAB).Append("}\n"); - sb.Append(prefix + TAB).Append("}\n"); + sb.Append(prefix + g_tab + g_tab + g_tab).Append( + "return IPCObjectStub::OnRemoteRequest(code, data, reply, option);\n"); + sb.Append(prefix + g_tab + g_tab).Append("}\n"); + sb.Append(prefix + g_tab).Append("}\n"); sb.Append("}\n"); } void CppServiceStubCodeEmitter::EmitStubExternalsMethodsImpl(StringBuilder& sb, const String& prefix) { - EmitStubInstanceMethodImpl(sb, prefix); + EmitStubLinkService(sb); + sb.Append("\n"); + EmitStubInstanceMethodImpl(sb); sb.Append("\n"); - EmitStubReleaseMethodImpl(sb, prefix); + EmitStubReleaseMethodImpl(sb); sb.Append("\n"); - EmitServiceOnRemoteRequest(sb, prefix); + EmitServiceOnRemoteRequest(sb); } -void CppServiceStubCodeEmitter::EmitStubInstanceMethodImpl(StringBuilder& sb, const String& prefix) +void CppServiceStubCodeEmitter::EmitStubLinkService(StringBuilder& sb) { - sb.Append(prefix).AppendFormat("void *%sInstance()\n", stubName_.string()); - sb.Append(prefix).Append("{\n"); - sb.Append(prefix + TAB).AppendFormat("using namespace %s;\n", + sb.Append("static void *LoadServiceHandler(const char* libFileName)\n"); + sb.Append("{\n"); + sb.Append(g_tab).Append("char path[PATH_MAX + 1] = {0};\n"); + sb.Append(g_tab).Append("char libPath[PATH_MAX + 1] = {0};\n"); + sb.Append(g_tab).Append("void *handler = NULL;\n"); + sb.Append("\n"); + sb.Append(g_tab).AppendFormat("if (snprintf_s(path, sizeof(path), sizeof(path) - 1, \"%%s/%%s\", "); + sb.Append("DRIVER_PATH, libFileName) < 0) {\n"); + sb.Append(g_tab).Append(g_tab).Append("HDF_LOGE(\"%{public}s: snprintf_s failed\", __func__);\n"); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n"); + sb.Append("\n"); + sb.Append(g_tab).Append("if (realpath(path, libPath) == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).Append("HDF_LOGE(\"%{public}s file name invalid\", __func__);\n"); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n"); + sb.Append("\n"); + sb.Append(g_tab).Append("handler = dlopen(libPath, RTLD_LAZY);\n"); + sb.Append(g_tab).Append("if (handler == NULL) {\n"); + sb.Append(g_tab).Append(g_tab).Append("HDF_LOGE(\"%{public}s: dlopen failed %{public}s\", "); + sb.AppendFormat("__func__, dlerror());\n"); + sb.Append(g_tab).Append(g_tab).Append("return NULL;\n"); + sb.Append(g_tab).Append("}\n"); + sb.Append("\n"); + sb.Append(g_tab).Append("return handler;\n"); + sb.Append("}\n"); +} + +void CppServiceStubCodeEmitter::EmitStubInstanceMethodImpl(StringBuilder& sb) +{ + String objName = "stub"; + String libName = String::Format("lib%s.z.so", FileName(implName_).string()); + sb.AppendFormat("void *%sInstance()\n", stubName_.string()); + sb.Append("{\n"); + sb.Append(g_tab).AppendFormat("using namespace %s;\n", EmitStubServiceUsings(interface_->GetNamespace()->ToString()).string()); - sb.Append(prefix + TAB).AppendFormat("return reinterpret_cast(new %s());\n", stubName_.string()); - sb.Append(prefix).Append("}\n"); + sb.Append(g_tab).Append("SERVICE_CONSTRUCT_FUNC serviceConstructFunc = nullptr;\n"); + sb.Append(g_tab).AppendFormat("%sStub *%s = new %sStub();\n", infName_.string(), objName.string(), + infName_.string()); + sb.Append(g_tab).AppendFormat("if (%s == nullptr) {\n", objName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("HDF_LOGE(\"%%{public}s: OsalMemAlloc %s failed!\", __func__);\n", + objName.string()); + sb.Append(g_tab).Append(g_tab).Append("return nullptr;\n"); + sb.Append(g_tab).Append("}\n\n"); + sb.Append(g_tab).AppendFormat("%s->dlHandler = LoadServiceHandler(\"%s\");\n", objName.string(), libName.string()); + sb.Append(g_tab).AppendFormat("if (%s->dlHandler == nullptr) {\n", objName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("HDF_LOGE(\"%%{public}s: %s->dlHanlder is null\", __func__);\n", + objName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("delete %s;\n", objName.string()); + sb.Append(g_tab).Append(g_tab).Append("return nullptr;\n"); + sb.Append(g_tab).Append("}\n\n"); + sb.Append(g_tab).AppendFormat("serviceConstructFunc = "); + sb.AppendFormat("(SERVICE_CONSTRUCT_FUNC)dlsym(%s->dlHandler, \"%sServiceConstruct\");\n", + objName.string(), infName_.string()); + sb.Append(g_tab).Append("if (serviceConstructFunc == nullptr) {\n"); + sb.Append(g_tab).Append(g_tab).Append("HDF_LOGE(\"%{public}s: dlsym failed %{public}s\", __func__, dlerror());\n"); + sb.Append(g_tab).Append(g_tab).AppendFormat("dlclose(%s->dlHandler);\n", objName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("delete %s;\n", objName.string()); + sb.Append(g_tab).Append(g_tab).Append("return nullptr;\n"); + sb.Append(g_tab).Append("}\n\n"); + sb.Append(g_tab).AppendFormat("%s->service = serviceConstructFunc();\n", objName.string()); + sb.Append(g_tab).AppendFormat("if (%s->service == nullptr) {\n", objName.string()); + sb.Append(g_tab).Append(g_tab).Append("HDF_LOGE(\"%{public}s: get service failed %{public}s\", "); + sb.Append("__func__, dlerror());\n"); + sb.Append(g_tab).Append(g_tab).AppendFormat("dlclose(%s->dlHandler);\n", objName.string()); + sb.Append(g_tab).Append(g_tab).AppendFormat("delete %s;\n", objName.string()); + sb.Append(g_tab).Append(g_tab).Append("return nullptr;\n"); + sb.Append(g_tab).Append("}\n\n"); + sb.Append(g_tab).Append("return reinterpret_cast(stub);\n"); + sb.Append("}\n"); } -void CppServiceStubCodeEmitter::EmitStubReleaseMethodImpl(StringBuilder& sb, const String& prefix) +void CppServiceStubCodeEmitter::EmitStubReleaseMethodImpl(StringBuilder& sb) { - sb.Append(prefix).AppendFormat("void %sRelease(void *obj)\n", stubName_.string()); - sb.Append(prefix).Append("{\n"); - sb.Append(prefix + TAB).AppendFormat("using namespace %s;\n", + String objName = "stub"; + sb.AppendFormat("void %sRelease(void *obj)\n", stubName_.string()); + sb.Append("{\n"); + sb.Append(g_tab).AppendFormat("using namespace %s;\n", EmitStubServiceUsings(interface_->GetNamespace()->ToString()).string()); - sb.Append(prefix + TAB).AppendFormat("delete reinterpret_cast<%s *>(obj);\n", stubName_.string()); - sb.Append(prefix).Append("}\n"); + sb.Append(g_tab).Append("if (obj == nullptr) {\n"); + sb.Append(g_tab).Append(g_tab).Append("return;\n"); + sb.Append(g_tab).Append("}\n\n"); + sb.Append(g_tab).AppendFormat("%sStub *%s = reinterpret_cast<%sStub *>(obj);\n", infName_.string(), + objName.string(), infName_.string()); + sb.Append(g_tab).AppendFormat("if (%s == nullptr) {\n", objName.string()); + sb.Append(g_tab).Append(g_tab).Append("return;\n"); + sb.Append(g_tab).Append("}\n\n"); + sb.Append(g_tab).Append("SERVICE_RELEASE_FUNC serviceReleaseFunc = "); + sb.AppendFormat("(SERVICE_RELEASE_FUNC)dlsym(%s->dlHandler, \"SampleServiceRelease\");\n", objName.string()); + sb.Append(g_tab).Append("if (serviceReleaseFunc == nullptr) {\n"); + sb.Append(g_tab).Append(g_tab).Append("HDF_LOGE(\"%{public}s: dlsym failed %{public}s\", __func__, dlerror());\n"); + sb.Append(g_tab).Append("} else {\n"); + sb.Append(g_tab).Append(g_tab).AppendFormat("serviceReleaseFunc(%s->service);\n", objName.string()); + sb.Append(g_tab).Append("}\n\n"); + sb.Append(g_tab).AppendFormat("dlclose(%s->dlHandler);\n", objName.string()); + sb.Append(g_tab).AppendFormat("delete %s;\n", objName.string()); + sb.Append("}\n"); } -void CppServiceStubCodeEmitter::EmitServiceOnRemoteRequest(StringBuilder& sb, const String& prefix) +void CppServiceStubCodeEmitter::EmitServiceOnRemoteRequest(StringBuilder& sb) { String stubObjName = String::Format("%sStub", infName_.ToLowerCase().string()); - sb.Append(prefix).AppendFormat( + sb.AppendFormat( "int32_t %sServiceOnRemoteRequest(void *stub, int cmdId, struct HdfSBuf *data, struct HdfSBuf *reply)\n", infName_.string()); - sb.Append(prefix).Append("{\n"); - sb.Append(prefix + TAB).AppendFormat("using namespace %s;\n", + sb.Append("{\n"); + sb.Append(g_tab).AppendFormat("using namespace %s;\n", EmitStubServiceUsings(interface_->GetNamespace()->ToString()).string()); - sb.Append(prefix + TAB).AppendFormat("%s *%s = reinterpret_cast<%s *>(stub);\n", + sb.Append(g_tab).AppendFormat("%s *%s = reinterpret_cast<%s *>(stub);\n", stubName_.string(), stubObjName.string(), stubName_.string()); - sb.Append(prefix + TAB).Append("OHOS::MessageParcel *dataParcel = nullptr;\n"); - sb.Append(prefix + TAB).Append("OHOS::MessageParcel *replyParcel = nullptr;\n"); + sb.Append(g_tab).Append("OHOS::MessageParcel *dataParcel = nullptr;\n"); + sb.Append(g_tab).Append("OHOS::MessageParcel *replyParcel = nullptr;\n"); sb.Append("\n"); - sb.Append(prefix + TAB).Append("(void)SbufToParcel(reply, &replyParcel);\n"); - sb.Append(prefix + TAB).Append("if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) {\n"); - sb.Append(prefix + TAB + TAB).Append( - "HDF_LOGE(\"%{public}s:invalid data sbuf object to dispatch\", __func__);\n"); - sb.Append(prefix + TAB + TAB).Append("return HDF_ERR_INVALID_PARAM;\n"); - sb.Append(prefix + TAB).Append("}\n\n"); - sb.Append(prefix + TAB).Append("OHOS::MessageOption option;\n"); - sb.Append(prefix + TAB).AppendFormat("return %s->%sOnRemoteRequest(cmdId, *dataParcel, *replyParcel, option);\n", + sb.Append(g_tab).Append("(void)SbufToParcel(reply, &replyParcel);\n"); + sb.Append(g_tab).Append("if (SbufToParcel(data, &dataParcel) != HDF_SUCCESS) {\n"); + sb.Append(g_tab).Append(g_tab).Append("HDF_LOGE(\"%{public}s:invalid data sbuf object to dispatch\","); + sb.Append(" __func__);\n"); + sb.Append(g_tab).Append(g_tab).Append("return HDF_ERR_INVALID_PARAM;\n"); + sb.Append(g_tab).Append("}\n\n"); + sb.Append(g_tab).Append("OHOS::MessageOption option;\n"); + sb.Append(g_tab).AppendFormat("return %s->%sOnRemoteRequest(cmdId, *dataParcel, *replyParcel, option);\n", stubObjName.string(), stubName_.string()); - sb.Append(prefix).Append("}\n"); + sb.Append("}\n"); } String CppServiceStubCodeEmitter::EmitStubServiceUsings(String nameSpace) diff --git a/tools/hdi-gen/codegen/cpp_service_stub_code_emitter.h b/tools/hdi-gen/codegen/cpp_service_stub_code_emitter.h index 12f7ce1afd87bb8aa2ec0a96658a337ce08d424c..c0dd1fd4ab73b5b37e815f8601a9e192781be1f7 100755 --- a/tools/hdi-gen/codegen/cpp_service_stub_code_emitter.h +++ b/tools/hdi-gen/codegen/cpp_service_stub_code_emitter.h @@ -15,18 +15,21 @@ namespace OHOS { namespace HDI { class CppServiceStubCodeEmitter : public CppCodeEmitter { public: - CppServiceStubCodeEmitter(const AutoPtr& ast, const String& targetDirectory); + CppServiceStubCodeEmitter() : CppCodeEmitter() {} virtual ~CppServiceStubCodeEmitter() = default; +private: + bool ResolveDirectory(const String& targetDirectory) override; void EmitCode() override; -private: // ISample.idl -> sample_service_stub.h void EmitStubHeaderFile(); void EmitStubHeaderInclusions(StringBuilder& sb); + void GetHeaderOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); + void EmitStubUsingNamespace(StringBuilder& sb); void EmitStubDecl(StringBuilder& sb); @@ -56,23 +59,31 @@ private: void EmitStubSourceInclusions(StringBuilder& sb); - void EmitStubSourceStdlibInclusions(StringBuilder& sb); + void GetSourceOtherLibInclusions(HeaderFile::HeaderFileSet& headerFiles); + + void EmitDriverLibPath(StringBuilder& sb); + + void EmitLibFuncTypeDef(StringBuilder& sb); void EmitStubMethodImpls(StringBuilder& sb, const String& prefix); void EmitStubMethodImpl(const AutoPtr& method, StringBuilder& sb, const String& prefix); + void EmitStubCallMethod(const AutoPtr& method, StringBuilder& sb, const String& prefix); + void EmitStubOnRequestMethodImpl(StringBuilder& sb, const String& prefix); void EmitCbStubOnRequestMethodImpl(StringBuilder& sb, const String& prefix); void EmitStubExternalsMethodsImpl(StringBuilder& sb, const String& prefix); - void EmitStubInstanceMethodImpl(StringBuilder& sb, const String& prefix); + void EmitStubLinkService(StringBuilder& sb); + + void EmitStubInstanceMethodImpl(StringBuilder& sb); - void EmitStubReleaseMethodImpl(StringBuilder& sb, const String& prefix); + void EmitStubReleaseMethodImpl(StringBuilder& sb); - void EmitServiceOnRemoteRequest(StringBuilder& sb, const String& prefix); + void EmitServiceOnRemoteRequest(StringBuilder& sb); String EmitStubServiceUsings(String nameSpace); }; diff --git a/tools/hdi-gen/codegen/generator_factory.cpp b/tools/hdi-gen/codegen/generator_factory.cpp deleted file mode 100755 index 73418e738a6fb4ef8335e0dd87a4e09544e583a5..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/codegen/generator_factory.cpp +++ /dev/null @@ -1,29 +0,0 @@ -/* - * Copyright (c) 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 "codegen/generator_factory.h" -#include "codegen/c_code_generator.h" -#include "codegen/cpp_code_generator.h" -#include "codegen/java_code_generator.h" - -namespace OHOS { -namespace HDI { -AutoPtr GeneratorFactory::GetCodeGenerator(const String& targetLanuage) -{ - if (targetLanuage.Equals("c")) { - return new CCodeGenerator(); - } else if (targetLanuage.Equals("cpp")) { - return new CppCodeGenerator(); - } else if (targetLanuage.Equals("java")) { - return new JavaCodeGenerator(); - } - - return nullptr; -} -} // namespace HDI -} // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/codegen/java_client_interface_code_emitter.cpp b/tools/hdi-gen/codegen/java_client_interface_code_emitter.cpp index abbe81f127d9dfc2253a36f905922dc4bf408230..14b56a2eda4e1c3761e02b1840a629b952168358 100755 --- a/tools/hdi-gen/codegen/java_client_interface_code_emitter.cpp +++ b/tools/hdi-gen/codegen/java_client_interface_code_emitter.cpp @@ -13,6 +13,26 @@ namespace OHOS { namespace HDI { +bool JavaClientInterfaceCodeEmitter::ResolveDirectory(const String& targetDirectory) +{ + if (ast_->GetASTFileType() == ASTFileType::AST_IFACE) { + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); + } else if (ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) { + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); + } else { + return false; + } + + if (!File::CreateParentDir(directory_)) { + Logger::E("JavaClientInterfaceCodeEmitter", "Create '%s' failed!", directory_.string()); + return false; + } + + return true; +} + void JavaClientInterfaceCodeEmitter::EmitCode() { EmitInterfaceFile(); @@ -20,13 +40,8 @@ void JavaClientInterfaceCodeEmitter::EmitCode() void JavaClientInterfaceCodeEmitter::EmitInterfaceFile() { - String filePath = String::Format("%s/%s.java", directory_.string(), FileName(interfaceName_).string()); - if (!File::CreateParentDir(filePath)) { - Logger::E("JavaClientInterfaceCodeEmitter", "Create '%s' failed!", filePath.string()); - return; - } + String filePath = String::Format("%s%s.java", directory_.string(), FileName(interfaceName_).string()); File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); @@ -96,7 +111,7 @@ void JavaClientInterfaceCodeEmitter::EmitInterfaceSelfDefinedTypeImports(StringB void JavaClientInterfaceCodeEmitter::EmitInterfaceDefinition(StringBuilder& sb) { sb.AppendFormat("public interface %s extends IRemoteBroker {\n", interface_->GetName().string()); - EmitInterfaceMethods(sb, TAB); + EmitInterfaceMethods(sb, g_tab); sb.Append("}"); } @@ -128,7 +143,7 @@ void JavaClientInterfaceCodeEmitter::EmitInterfaceMethod(const AutoPtr& ast, const String& targetDirectory) - : JavaCodeEmitter(ast, targetDirectory) {} + JavaClientInterfaceCodeEmitter() : JavaCodeEmitter() {} virtual ~JavaClientInterfaceCodeEmitter() = default; +private: + bool ResolveDirectory(const String& targetDirectory) override; void EmitCode() override; -private: void EmitInterfaceFile(); diff --git a/tools/hdi-gen/codegen/java_client_proxy_code_emitter.cpp b/tools/hdi-gen/codegen/java_client_proxy_code_emitter.cpp index 798be2741bf8c71d6ca50d218b0e7523ea348e53..3e3689bb8a6991ed72cfca5c0145a83eada3cf95 100755 --- a/tools/hdi-gen/codegen/java_client_proxy_code_emitter.cpp +++ b/tools/hdi-gen/codegen/java_client_proxy_code_emitter.cpp @@ -11,6 +11,26 @@ namespace OHOS { namespace HDI { +bool JavaClientProxyCodeEmitter::ResolveDirectory(const String& targetDirectory) +{ + if (ast_->GetASTFileType() == ASTFileType::AST_IFACE) { + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); + } else if (ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) { + directory_ = File::AdapterPath(String::Format("%s/%s/", targetDirectory.string(), + FileName(ast_->GetPackageName()).string())); + } else { + return false; + } + + if (!File::CreateParentDir(directory_)) { + Logger::E("CppClientInterfaceCodeEmitter", "Create '%s' failed!", directory_.string()); + return false; + } + + return true; +} + void JavaClientProxyCodeEmitter::EmitCode() { EmitProxyFile(); @@ -18,14 +38,8 @@ void JavaClientProxyCodeEmitter::EmitCode() void JavaClientProxyCodeEmitter::EmitProxyFile() { - String filePath = String::Format("%s/%s.java", directory_.string(), FileName(proxyName_).string()); - if (!File::CreateParentDir(filePath)) { - Logger::E("CppClientInterfaceCodeEmitter", "Create '%s' failed!", filePath.string()); - return; - } - + String filePath = String::Format("%s%s.java", directory_.string(), FileName(proxyName_).string()); File file(filePath, File::WRITE); - StringBuilder sb; EmitLicense(sb); @@ -98,17 +112,17 @@ void JavaClientProxyCodeEmitter::EmitProxyDBinderImports(StringBuilder& sb) void JavaClientProxyCodeEmitter::EmitProxyImpl(StringBuilder& sb) { sb.AppendFormat("public class %s implements %s {\n", proxyName_.string(), interfaceName_.string()); - EmitProxyConstants(sb, TAB); + EmitProxyConstants(sb, g_tab); sb.Append("\n"); - sb.Append(TAB).AppendFormat( + sb.Append(g_tab).AppendFormat( "private static final HiLogLabel TAG = new HiLogLabel(HiLog.LOG_CORE, 0xD001510, \"%s\");\n", interfaceFullName_.string()); - sb.Append(TAB).Append("private final IRemoteObject remote;\n"); - sb.Append(TAB).Append("private static final int ERR_OK = 0;\n"); + sb.Append(g_tab).Append("private final IRemoteObject remote;\n"); + sb.Append(g_tab).Append("private static final int ERR_OK = 0;\n"); sb.Append("\n"); - EmitProxyConstructor(sb, TAB); + EmitProxyConstructor(sb, g_tab); sb.Append("\n"); - EmitProxyMethodImpls(sb, TAB); + EmitProxyMethodImpls(sb, g_tab); sb.Append("};"); } @@ -122,12 +136,12 @@ void JavaClientProxyCodeEmitter::EmitProxyConstants(StringBuilder& sb, const Str void JavaClientProxyCodeEmitter::EmitProxyConstructor(StringBuilder& sb, const String& prefix) { sb.Append(prefix).AppendFormat("public %s(IRemoteObject remote) {\n", proxyName_.string()); - sb.Append(prefix + TAB).Append("this.remote = remote;\n"); + sb.Append(prefix + g_tab).Append("this.remote = remote;\n"); sb.Append(prefix).Append("}\n"); sb.Append("\n"); sb.Append(prefix).AppendFormat("@Override\n"); sb.Append(prefix).Append("public IRemoteObject asObject() {\n"); - sb.Append(prefix + TAB).Append("return remote;\n"); + sb.Append(prefix + g_tab).Append("return remote;\n"); sb.Append(prefix).Append("}\n"); } @@ -161,7 +175,7 @@ void JavaClientProxyCodeEmitter::EmitProxyMethodImpl(const AutoPtr& m } paramStr.Append(") throws RemoteException"); - sb.Append(SpecificationParam(paramStr, prefix + TAB)); + sb.Append(SpecificationParam(paramStr, prefix + g_tab)); sb.Append("\n"); } EmitProxyMethodBody(method, sb, prefix); @@ -177,467 +191,37 @@ void JavaClientProxyCodeEmitter::EmitProxyMethodBody(const AutoPtr& m const String& prefix) { sb.Append(prefix).Append("{\n"); - sb.Append(prefix + TAB).Append("MessageParcel data = MessageParcel.obtain();\n"); - sb.Append(prefix + TAB).Append("MessageParcel reply = MessageParcel.obtain();\n"); - sb.Append(prefix + TAB).AppendFormat("MessageOption option = new MessageOption(MessageOption.TF_SYNC);\n"); + sb.Append(prefix + g_tab).Append("MessageParcel data = MessageParcel.obtain();\n"); + sb.Append(prefix + g_tab).Append("MessageParcel reply = MessageParcel.obtain();\n"); + sb.Append(prefix + g_tab).AppendFormat("MessageOption option = new MessageOption(MessageOption.TF_SYNC);\n"); sb.Append("\n"); sb.Append(prefix).AppendFormat(" data.writeInterfaceToken(DESCRIPTOR);\n"); - bool needBlankLine = false; for (size_t i = 0; i < method->GetParameterNumber(); i++) { AutoPtr param = method->GetParameter(i); - if (param->GetAttribute() == ParamAttr::PARAM_IN) { - EmitWriteMethodParameter(param, "data", sb, prefix + TAB); - needBlankLine = true; - } else { - AutoPtr type = param->GetType(); - if (type->GetTypeKind() == TypeKind::TYPE_ARRAY) { - EmitWriteOutArrayVariable("data", param->GetName(), type, sb, prefix + TAB); - } - } - } - if (needBlankLine) { - sb.Append("\n"); + param->EmitJavaWriteVar("data", sb, prefix + g_tab); } + sb.Append("\n"); - sb.Append(prefix + TAB).Append("try {\n"); - sb.Append(prefix + TAB + TAB).AppendFormat("if (remote.sendRequest(COMMAND_%s, data, reply, option)) {\n", + sb.Append(prefix + g_tab).Append("try {\n"); + sb.Append(prefix + g_tab + g_tab).AppendFormat("if (remote.sendRequest(COMMAND_%s, data, reply, option)) {\n", ConstantName(method->GetName()).string()); - sb.Append(prefix + TAB + TAB + TAB).Append("return 1;\n"); - sb.Append(prefix + TAB + TAB).Append("}\n"); - sb.Append(prefix + TAB).Append(" reply.readException();\n"); + sb.Append(prefix + g_tab + g_tab + g_tab).Append("return 1;\n"); + sb.Append(prefix + g_tab + g_tab).Append("}\n"); + sb.Append(prefix + g_tab).Append(" reply.readException();\n"); for (size_t i = 0; i < method->GetParameterNumber(); i++) { AutoPtr param = method->GetParameter(i); - if (param->GetAttribute() == ParamAttr::PARAM_OUT) { - EmitReadMethodParameter(param, "reply", sb, prefix + TAB + TAB); - } - } - - sb.Append(prefix + TAB).Append("} finally {\n"); - sb.Append(prefix + TAB + TAB).Append("data.reclaim();\n"); - sb.Append(prefix + TAB + TAB).Append("reply.reclaim();\n"); - sb.Append(prefix + TAB).Append("}\n"); - sb.Append(prefix + TAB).Append("return 0;\n"); - sb.Append(prefix).Append("}\n"); -} - -void JavaClientProxyCodeEmitter::EmitWriteMethodParameter(const AutoPtr& param, const String& parcelName, - StringBuilder& sb, const String& prefix) -{ - AutoPtr type = param->GetType(); - EmitWriteVariable(parcelName, param->GetName(), type, sb, prefix); -} - -void JavaClientProxyCodeEmitter::EmitReadMethodParameter(const AutoPtr& param, const String& parcelName, - StringBuilder& sb, const String& prefix) -{ - AutoPtr type = param->GetType(); - EmitReadOutVariable(parcelName, param->GetName(), type, sb, prefix); -} - -void JavaClientProxyCodeEmitter::EmitWriteVariable(const String& parcelName, const String& name, - const AutoPtr& type, StringBuilder& sb, const String& prefix) -{ - switch (type->GetTypeKind()) { - case TypeKind::TYPE_BOOLEAN: - sb.Append(prefix).AppendFormat("%s.writeBoolean(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_BYTE: - sb.Append(prefix).AppendFormat("%s.writeByte(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_SHORT: - sb.Append(prefix).AppendFormat("%s.writeShort(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_INT: - case TypeKind::TYPE_FILEDESCRIPTOR: - sb.Append(prefix).AppendFormat("%s.writeInt(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_LONG: - sb.Append(prefix).AppendFormat("%s.writeLong(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_FLOAT: - sb.Append(prefix).AppendFormat("%s.writeFloat(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_DOUBLE: - sb.Append(prefix).AppendFormat("%s.writeDouble(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_STRING: - sb.Append(prefix).AppendFormat("%s.writeString(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_SEQUENCEABLE: - if (type->EmitJavaType(TypeMode::NO_MODE).Equals("IRemoteObject")) { - sb.Append(prefix).AppendFormat("%s.writeRemoteObject(%s);\n", parcelName.string(), name.string()); - break; - } - sb.Append(prefix).AppendFormat("%s.writeSequenceable(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_INTERFACE: - sb.Append(prefix).AppendFormat("%s.writeRemoteObject(%s.asObject());\n", parcelName.string(), - name.string()); - break; - case TypeKind::TYPE_LIST: { - AutoPtr listType = dynamic_cast(type.Get()); - AutoPtr elementType = listType->GetElementType(); - - sb.Append(prefix).AppendFormat("%s.writeInt(%s.size());\n", parcelName.string(), name.string()); - sb.Append(prefix).AppendFormat("for (%s element : %s) {\n", - elementType->EmitJavaType(TypeMode::NO_MODE).string(), name.string()); - EmitWriteVariable(parcelName, "element", elementType, sb, prefix + TAB); - sb.Append(prefix).Append("}\n"); - break; - } - case TypeKind::TYPE_MAP: { - AutoPtr mapType = dynamic_cast(type.Get()); - AutoPtr keyType = mapType->GetKeyType(); - AutoPtr valueType = mapType->GetValueType(); - - sb.Append(prefix).AppendFormat("%s.writeInt(%s.size());\n", parcelName.string(), name.string()); - sb.Append(prefix).AppendFormat("for (Map.Entry<%s, %s> entry : %s.entrySet()) {\n", - keyType->EmitJavaType(TypeMode::NO_MODE, true).string(), - valueType->EmitJavaType(TypeMode::NO_MODE, true).string(), name.string()); - EmitWriteVariable(parcelName, "entry.getKey()", keyType, sb, prefix + TAB); - EmitWriteVariable(parcelName, "entry.getValue()", valueType, sb, prefix + TAB); - sb.Append(prefix).Append("}\n"); - break; - } - case TypeKind::TYPE_ARRAY: { - AutoPtr arrayType = dynamic_cast(type.Get()); - AutoPtr elementType = arrayType->GetElementType(); - - sb.Append(prefix).AppendFormat("if (%s == null) {\n", name.string()); - sb.Append(prefix).AppendFormat(" %s.writeInt(-1);\n", parcelName.string()); - sb.Append(prefix).Append("} else { \n"); - EmitWriteArrayVariable(parcelName, name, elementType, sb, prefix + TAB); - sb.Append(prefix).Append("}\n"); - break; - } - default: - break; - } -} - -void JavaClientProxyCodeEmitter::EmitWriteArrayVariable(const String& parcelName, const String& name, - const AutoPtr& type, StringBuilder& sb, const String& prefix) -{ - switch (type->GetTypeKind()) { - case TypeKind::TYPE_BOOLEAN: - sb.Append(prefix).AppendFormat("%s.writeBooleanArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_BYTE: - sb.Append(prefix).AppendFormat("%s.writeByteArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_SHORT: - sb.Append(prefix).AppendFormat("%s.writeShortArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_INT: - case TypeKind::TYPE_FILEDESCRIPTOR: - sb.Append(prefix).AppendFormat("%s.writeIntArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_LONG: - sb.Append(prefix).AppendFormat("%s.writeLongArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_FLOAT: - sb.Append(prefix).AppendFormat("%s.writeFloatArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_DOUBLE: - sb.Append(prefix).AppendFormat("%s.writeDoubleArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_STRING: - sb.Append(prefix).AppendFormat("%s.writeStringArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_SEQUENCEABLE: - sb.Append(prefix).AppendFormat("%s.writeSequenceableArray(%s);\n", parcelName.string(), name.string()); - break; - default: - break; + param->EmitJavaReadVar("reply", sb, prefix + g_tab + g_tab); } -} -void JavaClientProxyCodeEmitter::EmitWriteOutArrayVariable(const String& parcelName, const String& name, - const AutoPtr& type, StringBuilder& sb, const String& prefix) -{ - sb.Append(prefix).AppendFormat("if (%s == null) {\n", name.string()); - sb.Append(prefix).AppendFormat(" %s.writeInt(-1);\n", parcelName.string()); - sb.Append(prefix).Append("} else {\n"); - sb.Append(prefix).AppendFormat(" %s.writeInt(%s.length);\n", parcelName.string(), name.string()); + sb.Append(prefix + g_tab).Append("} finally {\n"); + sb.Append(prefix + g_tab + g_tab).Append("data.reclaim();\n"); + sb.Append(prefix + g_tab + g_tab).Append("reply.reclaim();\n"); + sb.Append(prefix + g_tab).Append("}\n"); + sb.Append(prefix + g_tab).Append("return 0;\n"); sb.Append(prefix).Append("}\n"); } -void JavaClientProxyCodeEmitter::EmitReadVariable(const String& parcelName, const String& name, - const AutoPtr& type, ParamAttr attribute, StringBuilder& sb, const String& prefix) -{ - switch (type->GetTypeKind()) { - case TypeKind::TYPE_BOOLEAN: - sb.Append(prefix).AppendFormat("%s %s = %s.readBoolean();\n", - type->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_BYTE: - sb.Append(prefix).AppendFormat("%s %s = %s.readByte();\n", - type->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_SHORT: - sb.Append(prefix).AppendFormat("%s %s = %s.readShort();\n", - type->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_INT: - case TypeKind::TYPE_FILEDESCRIPTOR: - sb.Append(prefix).AppendFormat("%s %s = %s.readInt();\n", - type->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_LONG: - sb.Append(prefix).AppendFormat("%s %s = %s.readLong();\n", - type->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_FLOAT: - sb.Append(prefix).AppendFormat("%s %s = %s.readFloat();\n", - type->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_DOUBLE: - sb.Append(prefix).AppendFormat("%s %s = %s.readDouble();\n", - type->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_STRING: - sb.Append(prefix).AppendFormat("%s %s = %s.readString();\n", - type->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_SEQUENCEABLE: - if (attribute == ParamAttr::PARAM_OUT && type->EmitJavaType(TypeMode::NO_MODE).Equals("IRemoteObject")) { - sb.Append(prefix).AppendFormat("IRemoteObject %s = %s.readRemoteObject();\n", - name.string(), parcelName.string()); - break; - } - if (attribute == ParamAttr::PARAM_OUT) { - sb.Append(prefix).AppendFormat("%s %s = new %s();\n", - type->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), - type->EmitJavaType(TypeMode::NO_MODE).string()); - } - sb.Append(prefix).AppendFormat("%s.readSequenceable(%s);\n", parcelName.string(), name.string()); - - break; - case TypeKind::TYPE_INTERFACE: - sb.Append(prefix).AppendFormat("%s %s = %s.asInterface(%s.readRemoteObject());\n", - type->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), - StubName(type->EmitJavaType(TypeMode::NO_MODE)).string(), parcelName.string()); - break; - case TypeKind::TYPE_LIST: { - sb.Append(prefix).AppendFormat("%s %s = new Array%s();\n", - type->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), - type->EmitJavaType(TypeMode::NO_MODE).string()); - sb.Append(prefix).AppendFormat("int %sSize = %s.readInt();\n", name.string(), parcelName.string()); - sb.Append(prefix).AppendFormat("for (int i = 0; i < %sSize; ++i) {\n", name.string()); - AutoPtr listType = dynamic_cast(type.Get()); - AutoPtr elementType = listType->GetElementType(); - EmitReadVariable(parcelName, "value", elementType, ParamAttr::PARAM_IN, sb, prefix + TAB); - sb.Append(prefix + TAB).AppendFormat("%s.add(value);\n", name.string()); - sb.Append(prefix).Append("}\n"); - break; - } - case TypeKind::TYPE_MAP: { - sb.Append(prefix).AppendFormat("%s %s = new Hash%s();\n", - type->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), - type->EmitJavaType(TypeMode::NO_MODE).string()); - sb.Append(prefix).AppendFormat("int %sSize = %s.readInt();\n", name.string(), parcelName.string()); - sb.Append(prefix).AppendFormat("for (int i = 0; i < %sSize; ++i) {\n", name.string()); - - AutoPtr mapType = dynamic_cast(type.Get()); - AutoPtr keyType = mapType->GetKeyType(); - AutoPtr valueType = mapType->GetValueType(); - - EmitReadVariable(parcelName, "key", keyType, ParamAttr::PARAM_IN, sb, prefix + TAB); - EmitReadVariable(parcelName, "value", valueType, ParamAttr::PARAM_IN, sb, prefix + TAB); - sb.Append(prefix + TAB).AppendFormat("%s.put(key, value);\n", name.string()); - sb.Append(prefix).Append("}\n"); - break; - } - case TypeKind::TYPE_ARRAY: { - AutoPtr arrayType = dynamic_cast(type.Get()); - if (attribute == ParamAttr::PARAM_OUT) { - EmitReadOutArrayVariable(parcelName, name, arrayType, sb, prefix); - } else { - EmitReadArrayVariable(parcelName, name, arrayType, attribute, sb, prefix); - } - break; - } - default: - break; - } -} - -void JavaClientProxyCodeEmitter::EmitReadArrayVariable(const String& parcelName, const String& name, - const AutoPtr& arrayType, ParamAttr attribute, StringBuilder& sb, const String& prefix) -{ - AutoPtr elementType = arrayType->GetElementType(); - switch (elementType->GetTypeKind()) { - case TypeKind::TYPE_BOOLEAN: - sb.Append(prefix).AppendFormat("%s[] %s = %s.readBooleanArray();\n", - elementType->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_BYTE: - sb.Append(prefix).AppendFormat("%s[] %s = %s.readByteArray();\n", - elementType->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_SHORT: - sb.Append(prefix).AppendFormat("%s[] %s = %s.readShortArray();\n", - elementType->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_INT: - case TypeKind::TYPE_FILEDESCRIPTOR: - sb.Append(prefix).AppendFormat("%s[] %s = %s.readIntArray();\n", - elementType->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_LONG: - sb.Append(prefix).AppendFormat("%s[] %s = %s.readLongArray();\n", - elementType->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_FLOAT: - sb.Append(prefix).AppendFormat("%s[] %s = %s.readFloatArray();\n", - elementType->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_DOUBLE: - sb.Append(prefix).AppendFormat("%s[] %s = %s.readDoubleArray();\n", - elementType->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_STRING: - sb.Append(prefix).AppendFormat("%s[] %s = %s.readStringArray();\n", - elementType->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), parcelName.string()); - break; - case TypeKind::TYPE_SEQUENCEABLE: - sb.Append(prefix).AppendFormat("int size = %s.readInt();\n", parcelName.string()); - sb.Append(prefix).AppendFormat("%s %s = new %s[size];\n", - elementType->EmitJavaType(TypeMode::NO_MODE).string(), name.string(), - elementType->EmitJavaType(TypeMode::NO_MODE).string()); - sb.Append(prefix).AppendFormat("for (int i = 0; i < size; ++i) {\n"); - EmitReadVariable(parcelName, "value", elementType, ParamAttr::PARAM_IN, sb, prefix + TAB); - sb.Append(prefix + TAB).AppendFormat("%s[i] = value;\n", name.string()); - sb.Append(prefix).Append("}\n"); - break; - default: - break; - } -} - -void JavaClientProxyCodeEmitter::EmitReadOutArrayVariable(const String& parcelName, const String& name, - const AutoPtr& arrayType, StringBuilder& sb, const String& prefix) -{ - AutoPtr elementType = arrayType->GetElementType(); - switch (elementType->GetTypeKind()) { - case TypeKind::TYPE_BOOLEAN: - sb.Append(prefix).AppendFormat("%s.readBooleanArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_BYTE: - sb.Append(prefix).AppendFormat("%s.readByteArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_SHORT: - sb.Append(prefix).AppendFormat("%s.readShortArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_INT: - case TypeKind::TYPE_FILEDESCRIPTOR: - sb.Append(prefix).AppendFormat("%s.readIntArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_LONG: - sb.Append(prefix).AppendFormat("%s.readLongArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_FLOAT: - sb.Append(prefix).AppendFormat("%s.readFloatArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_DOUBLE: - sb.Append(prefix).AppendFormat("%s.readDoubleArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_STRING: - sb.Append(prefix).AppendFormat("%s.readStringArray(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_SEQUENCEABLE: - sb.Append(prefix).AppendFormat("%s.readSequenceableArray(%s);\n", parcelName.string(), name.string()); - break; - default: - break; - } -} - -void JavaClientProxyCodeEmitter::EmitReadOutVariable(const String& parcelName, const String& name, - const AutoPtr& type, StringBuilder& sb, const String& prefix) -{ - switch (type->GetTypeKind()) { - case TypeKind::TYPE_BOOLEAN: - sb.Append(prefix).AppendFormat("%s = %s.readBoolean();\n", - name.string(), parcelName.string()); - break; - case TypeKind::TYPE_BYTE: - sb.Append(prefix).AppendFormat("%s = %s.readByte();\n", - name.string(), parcelName.string()); - break; - case TypeKind::TYPE_SHORT: - sb.Append(prefix).AppendFormat("%s = %s.readShort();\n", - name.string(), parcelName.string()); - break; - case TypeKind::TYPE_INT: - case TypeKind::TYPE_FILEDESCRIPTOR: - sb.Append(prefix).AppendFormat("%s = %s.readInt();\n", - name.string(), parcelName.string()); - break; - case TypeKind::TYPE_LONG: - sb.Append(prefix).AppendFormat("%s = %s.readLong();\n", - name.string(), parcelName.string()); - break; - case TypeKind::TYPE_FLOAT: - sb.Append(prefix).AppendFormat("%s = %s.readFloat();\n", - name.string(), parcelName.string()); - break; - case TypeKind::TYPE_DOUBLE: - sb.Append(prefix).AppendFormat("%s = %s.readDouble();\n", - name.string(), parcelName.string()); - break; - case TypeKind::TYPE_STRING: - sb.Append(prefix).AppendFormat("%s = %s.readString();\n", - name.string(), parcelName.string()); - break; - case TypeKind::TYPE_SEQUENCEABLE: - if (type->EmitJavaType(TypeMode::NO_MODE).Equals("IRemoteObject")) { - sb.Append(prefix).AppendFormat("%s = %s.readRemoteObject();\n", name.string(), parcelName.string()); - break; - } - sb.Append(prefix).AppendFormat("%s.readSequenceable(%s);\n", parcelName.string(), name.string()); - break; - case TypeKind::TYPE_INTERFACE: - sb.Append(prefix).AppendFormat("%s = %s.asInterface(%s.readRemoteObject());\n", name.string(), - StubName(type->EmitJavaType(TypeMode::NO_MODE)).string(), parcelName.string()); - break; - case TypeKind::TYPE_LIST: { - sb.Append(prefix).AppendFormat("int %sSize = %s.readInt();\n", name.string(), parcelName.string()); - sb.Append(prefix).AppendFormat("for (int i = 0; i < %sSize; ++i) {\n", name.string()); - - AutoPtr listType = dynamic_cast(type.Get()); - AutoPtr elementType = listType->GetElementType(); - - EmitReadVariable(parcelName, "value", elementType, ParamAttr::PARAM_OUT, sb, prefix + TAB); - sb.Append(prefix + TAB).AppendFormat("%s.add(value);\n", name.string()); - sb.Append(prefix).Append("}\n"); - break; - } - case TypeKind::TYPE_MAP: { - sb.Append(prefix).AppendFormat("int %sSize = %s.readInt();\n", name.string(), parcelName.string()); - sb.Append(prefix).AppendFormat("for (int i = 0; i < %sSize; ++i) {\n", name.string()); - - AutoPtr mapType = dynamic_cast(type.Get()); - AutoPtr keyType = mapType->GetKeyType(); - AutoPtr valueType = mapType->GetValueType(); - - EmitReadVariable(parcelName, "key", keyType, ParamAttr::PARAM_OUT, sb, prefix + TAB); - EmitReadVariable(parcelName, "value", valueType, ParamAttr::PARAM_OUT, sb, prefix + TAB); - sb.Append(prefix + TAB).AppendFormat("%s.put(key, value);\n", name.string()); - sb.Append(prefix).Append("}\n"); - break; - } - case TypeKind::TYPE_ARRAY: { - AutoPtr arrayType = dynamic_cast(type.Get()); - EmitReadOutArrayVariable(parcelName, name, arrayType, sb, prefix); - break; - } - default: - break; - } -} - void JavaClientProxyCodeEmitter::EmitLocalVariable(const AutoPtr& param, StringBuilder& sb, const String& prefix) { @@ -659,10 +243,5 @@ void JavaClientProxyCodeEmitter::EmitLocalVariable(const AutoPtr& param->GetName().string()); } } - -String JavaClientProxyCodeEmitter::StubName(const String& name) -{ - return name.StartsWith("I") ? (name.Substring(1) + "Stub") : (name + "Stub"); -} } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/codegen/java_client_proxy_code_emitter.h b/tools/hdi-gen/codegen/java_client_proxy_code_emitter.h index bc077cb3b1c8d8eef2e28d4d70a9d487efac2b5c..c304db6aa1faa9bb63a020e2692a36af5b58486b 100755 --- a/tools/hdi-gen/codegen/java_client_proxy_code_emitter.h +++ b/tools/hdi-gen/codegen/java_client_proxy_code_emitter.h @@ -16,13 +16,14 @@ namespace OHOS { namespace HDI { class JavaClientProxyCodeEmitter : public JavaCodeEmitter { public: - JavaClientProxyCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - : JavaCodeEmitter(ast, targetDirectory) {} + JavaClientProxyCodeEmitter() : JavaCodeEmitter() {} virtual ~JavaClientProxyCodeEmitter() = default; +private: + bool ResolveDirectory(const String& targetDirectory) override; void EmitCode() override; -private: + void EmitProxyFile(); void EmitProxyImports(StringBuilder& sb); @@ -47,21 +48,9 @@ private: void EmitProxyMethodBody(const AutoPtr& method, StringBuilder& sb, const String& prefix); - void EmitWriteMethodParameter(const AutoPtr& param, const String& parcelName, StringBuilder& sb, - const String& prefix); - void EmitReadMethodParameter(const AutoPtr& param, const String& parcelName, StringBuilder& sb, const String& prefix); - void EmitWriteVariable(const String& parcelName, const String& name, const AutoPtr& type, - StringBuilder& sb, const String& prefix); - - void EmitWriteArrayVariable(const String& parcelName, const String& name, const AutoPtr& type, - StringBuilder& sb, const String& prefix); - - void EmitWriteOutArrayVariable(const String& parcelName, const String& name, const AutoPtr& type, - StringBuilder& sb, const String& prefix); - void EmitReadVariable(const String& parcelName, const String& name, const AutoPtr& type, ParamAttr attribute, StringBuilder& sb, const String& prefix); @@ -75,8 +64,6 @@ private: StringBuilder& sb, const String& prefix); void EmitLocalVariable(const AutoPtr& param, StringBuilder& sb, const String& prefix); - - String StubName(const String& name); }; } // namespace HDI } // namespace OHOS diff --git a/tools/hdi-gen/codegen/java_code_emitter.cpp b/tools/hdi-gen/codegen/java_code_emitter.cpp index cc9adc685601053aa1738c7a0fed9229f54a4e13..69716cdb22bbaf3ab418c5e3766ccd5a05b679fb 100755 --- a/tools/hdi-gen/codegen/java_code_emitter.cpp +++ b/tools/hdi-gen/codegen/java_code_emitter.cpp @@ -13,26 +13,6 @@ namespace OHOS { namespace HDI { -const char* JavaCodeEmitter::TAB = " "; - -JavaCodeEmitter::JavaCodeEmitter(const AutoPtr& ast, const String& targetDirectory) - :LightRefCountBase(), ast_(ast), directory_(targetDirectory) -{ - if (ast_->GetASTFileType() == ASTFileType::AST_IFACE || ast_->GetASTFileType() == ASTFileType::AST_ICALLBACK) { - interface_ = ast_->GetInterfaceDef(); - } - - if (interface_ != nullptr) { - interfaceName_ = interface_->GetName(); - interfaceFullName_ = interface_->GetNamespace()->ToString() + interfaceName_; - infName_ = interfaceName_.StartsWith("I") ? interfaceName_.Substring(1) : interfaceName_; - proxyName_ = infName_ + "Proxy"; - proxyFullName_ = interface_->GetNamespace()->ToString() + proxyName_; - } else { - infName_ = ast_->GetName(); - } -} - String JavaCodeEmitter::FileName(const String& name) { if (name.IsEmpty()) { diff --git a/tools/hdi-gen/codegen/java_code_emitter.h b/tools/hdi-gen/codegen/java_code_emitter.h index 5dc400034741e301e9d9a89f3254b9c7a302c286..d8b2360a13227404d5d16b0b0e3369f482874b76 100755 --- a/tools/hdi-gen/codegen/java_code_emitter.h +++ b/tools/hdi-gen/codegen/java_code_emitter.h @@ -10,6 +10,7 @@ #define OHOS_HDI_JAVA_CODE_EMITTER_H #include "ast/ast.h" +#include "codegen/code_emitter.h" #include "util/autoptr.h" #include "util/light_refcount_base.h" #include "util/string.h" @@ -17,27 +18,12 @@ namespace OHOS { namespace HDI { -class JavaCodeEmitter : public LightRefCountBase { +class JavaCodeEmitter : public CodeEmitter { public: - JavaCodeEmitter(const AutoPtr& ast, const String& targetDirectory); - virtual ~JavaCodeEmitter() = default; - virtual void EmitCode() = 0; - - inline String GetSourceFile() - { - return sourceFileName_; - } - - inline bool isInvaildDir() - { - return directory_.Equals(""); - } - static String FileName(const String& name); protected: - bool CreateDirectory(); void EmitLicense(StringBuilder& sb); @@ -51,20 +37,6 @@ protected: String ConstantName(const String& name); String SpecificationParam(StringBuilder& paramSb, const String& prefix); - - static const char* TAB; - - AutoPtr ast_; - AutoPtr interface_; - - String directory_; - String sourceFileName_; - - String interfaceName_; - String interfaceFullName_; - String infName_; - String proxyName_; - String proxyFullName_; }; } // namespace HDI } // namespace OHOS diff --git a/tools/hdi-gen/codegen/java_code_generator.cpp b/tools/hdi-gen/codegen/java_code_generator.cpp deleted file mode 100755 index 853aee68d265820fa3ce716974b410b9840d096a..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/codegen/java_code_generator.cpp +++ /dev/null @@ -1,68 +0,0 @@ -/* - * Copyright (c) 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 "java_code_generator.h" -#include -#include -#include -#include "codegen/java_client_interface_code_emitter.h" -#include "codegen/java_client_proxy_code_emitter.h" -#include "util/file.h" -#include "util/logger.h" - -namespace OHOS { -namespace HDI { -const char* JavaCodeGenerator::TAG = "JavaCodeGenerator"; - -bool JavaCodeGenerator::Initializate(const AutoPtr& ast, const String& targetDirectory) -{ - if (ast->GetASTFileType() == ASTFileType::AST_TYPES) { - Logger::E(TAG, "java has no types idl."); - return false; - } - - ast_ = ast; - targetDirectory_ = targetDirectory; - - if (!ResolveDirectory()) { - return false; - } - - AutoPtr clientInterfaceCodeEmitter = new JavaClientInterfaceCodeEmitter(ast_, targetDirectory_); - AutoPtr clientProxyCodeEmitter = new JavaClientProxyCodeEmitter(ast_, targetDirectory_); - - emitters_.push_back(clientInterfaceCodeEmitter); - emitters_.push_back(clientProxyCodeEmitter); - return true; -} - -bool JavaCodeGenerator::Generate() const -{ - for (auto emitter : emitters_) { - if (!emitter->isInvaildDir()) { - emitter->EmitCode(); - } - } - - return true; -} - -bool JavaCodeGenerator::ResolveDirectory() -{ - String packageFilePath = String::Format("%s/%s/", - targetDirectory_.string(), JavaCodeEmitter::FileName(ast_->GetPackageName()).string()); - targetDirectory_ = packageFilePath; - - if (!File::CreateParentDir(targetDirectory_)) { - Logger::E(TAG, "create '%s' directory failed!", targetDirectory_); - return false; - } - return true; -} -} // namespace HDI -} // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/codegen/java_code_generator.h b/tools/hdi-gen/codegen/java_code_generator.h deleted file mode 100755 index 0fea5d53b373a7dd2ce615322b29f925d186785d..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/codegen/java_code_generator.h +++ /dev/null @@ -1,35 +0,0 @@ -/* - * Copyright (c) 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 OHOS_HDI_JAVA_CODE_GENERATOR_H -#define OHOS_HDI_JAVA_CODE_GENERATOR_H - -#include "codegen/code_generator.h" -#include "codegen/java_code_emitter.h" - -namespace OHOS { -namespace HDI { -class JavaCodeGenerator : public CodeGenerator { -public: - JavaCodeGenerator() : CodeGenerator(), - emitters_() {} - - ~JavaCodeGenerator() override {}; - - bool Initializate(const AutoPtr& ast, const String& targetDirectory) override; - bool Generate() const override; -private: - bool ResolveDirectory() override; - - static const char* TAG; - std::vector> emitters_; -}; -} // namespace HDI -} // namespace OHOS - -#endif // OHOS_HDI_JAVA_CODE_GENERATOR_H \ No newline at end of file diff --git a/tools/hdi-gen/main.cpp b/tools/hdi-gen/main.cpp index 907efed688634c96fa67e41ea711d526c0e6c5fb..5974ef04814b7db18feaca48ef8cdb0ac6e96482 100755 --- a/tools/hdi-gen/main.cpp +++ b/tools/hdi-gen/main.cpp @@ -7,7 +7,6 @@ */ #include "codegen/code_generator.h" -#include "codegen/generator_factory.h" #include "parser/module_parser.h" #include "util/file.h" #include "util/logger.h" @@ -18,7 +17,6 @@ using namespace OHOS::HDI; int main(int argc, char** argv) { Options& options = Options::GetInstance().Parse(argc, argv); - if (options.HasErrors()) { options.ShowErrors(); return 0; @@ -39,52 +37,30 @@ int main(int argc, char** argv) } if (options.DoGetHashKey()) { - std::unique_ptr idlFile = std::make_unique(options.GetSourceFile(), int(File::READ)); - if (!idlFile->IsValid()) { - Logger::E("hdi-gen", "open idl file failed!"); - return -1; + for (const auto& sourceFile : options.GetSourceFiles()) { + std::unique_ptr idlFile = std::make_unique(sourceFile, int(File::READ)); + if (!idlFile->IsValid()) { + Logger::E("hdi-gen", "open idl file failed!"); + return -1; + } + printf("%s:%lu\n", idlFile->GetPath().string(), idlFile->GetHashKey()); } - - printf("%s:%lu\n", idlFile->GetPath().string(), idlFile->GetHashKey()); return 0; } ModuleParser moduleParser(options); - if (!moduleParser.ParserDependencies()) { - Logger::E("hdi-gen", "Parsing dependencies failed."); + AutoPtr astModule = moduleParser.Parse(); + if (astModule == nullptr) { return -1; } - if (!moduleParser.CompileFiles()) { - Logger::E("hdi-gen", "Parsing .idl failed."); - return -1; - } - - AutoPtr astModule = moduleParser.GetAStModule(); - if (!options.DoGenerateCode()) { return 0; } - for (auto& astPair : astModule->GetAllAsts()) { - AutoPtr ast = astPair.second; - GeneratorFactory factory; - AutoPtr codeGen = factory.GetCodeGenerator(options.GetTargetLanguage()); - if (codeGen == nullptr) { - Logger::E("hdi-gen", "new Generate failed."); - return -1; - } - - if (!codeGen->Initializate(ast, options.GetGenerationDirectory())) { - Logger::E("hdi-gen", "Generate initializate failed."); - return -1; - } - - if (!codeGen->Generate()) { - Logger::E("hdi-gen", "Generate \"%s\" codes failed.", options.GetTargetLanguage().string()); - return -1; - } + if (!CodeGenerator(astModule).Generate()) { + Logger::E("hdi-gen", "Generate \"%s\" codes failed.", options.GetTargetLanguage().string()); + return -1; } - return 0; } \ No newline at end of file diff --git a/tools/hdi-gen/parser/Makefile b/tools/hdi-gen/parser/Makefile deleted file mode 100755 index 186125b5692ae863af789171ade4b94a5986bead..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/parser/Makefile +++ /dev/null @@ -1,12 +0,0 @@ -OBJS_DIR:=$(BUILD_DIR)/parser -TARGET = $(OBJS_DIR)/parser.a -SOURCE:=$(wildcard *.cpp) -OBJS:=$(patsubst %.cpp, $(OBJS_DIR)/%.o, $(SOURCE)) - -$(TARGET):$(OBJS) - $(Q) echo $(TARGET) - $(Q) ar -rc $@ $^ - -$(OBJS_DIR)/%.o:%.cpp - $(Q) mkdir -p $(dir $@) - $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ \ No newline at end of file diff --git a/tools/hdi-gen/parser/file_detail.cpp b/tools/hdi-gen/parser/file_detail.cpp index 019f95438de13bd021cfda6b9caa27972ce82563..f454489542c9c46395a517e0bc823a9ab7ced1cf 100755 --- a/tools/hdi-gen/parser/file_detail.cpp +++ b/tools/hdi-gen/parser/file_detail.cpp @@ -7,6 +7,7 @@ */ #include "parser/file_detail.h" +#include "util/string_builder.h" namespace OHOS { namespace HDI { diff --git a/tools/hdi-gen/parser/file_detail.h b/tools/hdi-gen/parser/file_detail.h index 7f78afdd4f13a08b25b6b26a9da941bdddacd6a3..1684c1e505ae008649a766e41fc885432c2e8c40 100755 --- a/tools/hdi-gen/parser/file_detail.h +++ b/tools/hdi-gen/parser/file_detail.h @@ -10,8 +10,7 @@ #define OHOS_HDI_FILE_DETAIL_H #include -#include "util/string_builder.h" -#include "util/logger.h" +#include "util/string.h" namespace OHOS { namespace HDI { diff --git a/tools/hdi-gen/parser/module_parser.cpp b/tools/hdi-gen/parser/module_parser.cpp index d2f3b25864962515e28912f5c8b03cbc43b38c1a..d8ff0b53dbb1abe3ef9050a522160414a8a1e2c9 100755 --- a/tools/hdi-gen/parser/module_parser.cpp +++ b/tools/hdi-gen/parser/module_parser.cpp @@ -8,16 +8,38 @@ #include "parser/module_parser.h" #include +#include "parser/parser.h" +#include "util/logger.h" namespace OHOS { namespace HDI { const char* ModuleParser::TAG = "ModuleParser"; +AutoPtr ModuleParser::Parse() +{ + if (!ParserDependencies()) { + return nullptr; + } + + if (!CompileFiles()) { + return nullptr; + } + + return module_; +} + bool ModuleParser::ParserDependencies() { - if (!ParserAllImports(option_.GetSourceFile())) { - Logger::E(TAG, "Parsing all idl file failed."); - return false; + if (option_.GetSourceFiles().size() == 1) { + if (!ParserAllImports(option_.GetSourceFiles()[0])) { + Logger::E(TAG, "Parsing all idl file failed."); + return false; + } + } else { + if (!ParserAllidlFile(option_.GetSourceFiles())) { + Logger::E(TAG, "Parsing all given idl file failed."); + return false; + } } if (!CheckCircularReference()) { @@ -91,6 +113,26 @@ bool ModuleParser::ParserAllImportsRecursion(const std::shared_ptr& return true; } +bool ModuleParser::ParserAllidlFile(const std::vector& idlSourceFile) +{ + std::unique_ptr parserPtr = std::make_unique(option_); + + for (const auto& idlSourceFile : idlSourceFile) { + std::shared_ptr fileInfo = nullptr; + if (!parserPtr->Parse(idlSourceFile, fileInfo)) { + return false; + } + + if (fileInfo == nullptr) { + return false; + } + + sourceFiles_[fileInfo->GetFullName()] = fileInfo; + } + + return true; +} + bool ModuleParser::CheckCircularReference() { std::queue> fileQueue; diff --git a/tools/hdi-gen/parser/module_parser.h b/tools/hdi-gen/parser/module_parser.h index ba94b8f343f19d1f7f4559a69b521da1aa924ebf..e7f0537ef077e6f4f1f69d50a9b624dc1cda3c59 100755 --- a/tools/hdi-gen/parser/module_parser.h +++ b/tools/hdi-gen/parser/module_parser.h @@ -9,10 +9,11 @@ #ifndef OHOS_HDI_MODULE_PARSER_H #define OHOS_HDI_MODULE_PARSER_H +#include #include +#include "ast/ast_module.h" #include "parser/file_detail.h" -#include "parser/parser.h" -#include "util/logger.h" +#include "util/options.h" namespace OHOS { namespace HDI { @@ -30,26 +31,25 @@ public: ~ModuleParser() {} + AutoPtr Parse(); +private: // parser file and circular reference bool ParserDependencies(); bool CompileFiles(); - inline AutoPtr GetAStModule() const - { - return module_; - } - -private: // parse all idl file involved in compilation. bool ParserAllImports(const String& rootFilePath); bool ParserAllImportsRecursion(const std::shared_ptr& fileInfo); + bool ParserAllidlFile(const std::vector& idlSourceFile); + // check circular reference and reverse topology sorting of all idl file bool CheckCircularReference(); static const char* TAG; + const Options& option_; FileDetailMap sourceFiles_; diff --git a/tools/hdi-gen/parser/parser.cpp b/tools/hdi-gen/parser/parser.cpp index 73a1499db67c5482f3b9911f806cb7057054d015..4a47a31d440fea80a36ef89dc0ce29455698925a 100755 --- a/tools/hdi-gen/parser/parser.cpp +++ b/tools/hdi-gen/parser/parser.cpp @@ -185,10 +185,8 @@ bool Parser::ParseIdlImport(std::shared_ptr& fileDetailPtr) bool Parser::ParseFile() { bool ret = true; - ast_ = new AST(); ast_->SetIdlFile(lexer_->GetFilePath()); - ParseLicense(); Token token; @@ -229,17 +227,7 @@ bool Parser::ParseFile() } } lexer_->GetToken(); - - // here, ast_ cannot be a sequenceable idl - if (ast_->GetInterfaceDef() != nullptr) { - if (ast_->GetInterfaceDef()->IsCallback()) { - ast_->SetAStFileType(ASTFileType::AST_ICALLBACK); - } else { - ast_->SetAStFileType(ASTFileType::AST_IFACE); - } - } else { - ast_->SetAStFileType(ASTFileType::AST_TYPES); - } + SetAstFileType(); return ret; } @@ -413,48 +401,11 @@ bool Parser::ParseAttribute() bool ret = true; AutoPtr attributes = nullptr; - // read '[' - Token token = lexer_->GetToken(); - if (token == Token::BRACKETS_LEFT) { - attributes = new Attribute(); - token = lexer_->PeekToken(); - while (token != Token::BRACKETS_RIGHT) { - switch (token) { - case Token::ONEWAY: - attributes->isOneWay = true; - break; - case Token::CALLBACK: - attributes->isCallback = true; - break; - case Token::FULL: - attributes->isFull = true; - break; - case Token::LITE: - attributes->isLite = true; - break; - default: { - LogError(String::Format("'%s' is not expected.", lexer_->DumpToken().string())); - lexer_->SkipCurrentLine(Lexer::TokenToChar(Token::BRACKETS_RIGHT)); - lexer_->GetToken(); - return false; - } - } - lexer_->GetToken(); - token = lexer_->PeekToken(); - if (token == Token::COMMA) { - lexer_->GetToken(); - token = lexer_->PeekToken(); - } else if (token == Token::BRACKETS_RIGHT) { - break; - } else { - LogError(String::Format("'%s' is not expected.", lexer_->DumpToken().string())); - return false; - } - } - lexer_->GetToken(); + if (!ParseAttributeBody(attributes)) { + return false; } - token = lexer_->PeekToken(); + Token token = lexer_->PeekToken(); switch (token) { case Token::ENUM: ret = ParseEnumDefine(attributes) && ret; @@ -479,11 +430,6 @@ bool Parser::ParseAttribute() bool Parser::ParseInterface(const AutoPtr& attributes) { lexer_->GetToken(); - bool ret = true; - bool isOneWay = false; - bool isCallback = false; - bool isFull = false; - bool isLite = false; String interfaceName; Token token = lexer_->PeekToken(); @@ -494,7 +440,6 @@ bool Parser::ParseInterface(const AutoPtr& attributes) return false; } lexer_->GetToken(); - interfaceName = lexer_->GetIdentifier(); token = lexer_->PeekToken(); @@ -504,8 +449,6 @@ bool Parser::ParseInterface(const AutoPtr& attributes) lexer_->GetToken(); return false; } - - // read '{' lexer_->GetToken(); if (interfaceName.IsEmpty()) { @@ -529,7 +472,13 @@ bool Parser::ParseInterface(const AutoPtr& attributes) interface->SetFull(attributes->isFull); interface->SetLite(attributes->isLite); } + return ParseInterfaceBody(interface); +} +bool Parser::ParseInterfaceBody(const AutoPtr& interface) +{ + bool ret = true; + Token token = lexer_->PeekToken(); while (token != Token::BRACES_RIGHT && token != Token::END_OF_FILE) { ret = ParseMethod(interface) && ret; token = lexer_->PeekToken(); @@ -540,7 +489,6 @@ bool Parser::ParseInterface(const AutoPtr& attributes) lexer_->SkipEof(); return false; } - lexer_->GetToken(); if (ast_->GetInterfaceDef() != nullptr) { @@ -550,16 +498,13 @@ bool Parser::ParseInterface(const AutoPtr& attributes) } ast_->AddInterfaceDef(interface); - return ret; } bool Parser::ParseMethod(const AutoPtr& interface) { - bool ret = true; - AutoPtr attributes = new Attribute(); - ret = ParseMethodAttr(interface, attributes) && ret; - if (!ret) { + AutoPtr attributes = nullptr; + if (!ParseAttributeBody(attributes)) { return false; } @@ -580,7 +525,7 @@ bool Parser::ParseMethod(const AutoPtr& interface) } return false; } - token = lexer_->GetToken(); + lexer_->GetToken(); AutoPtr method = new ASTMethod(); method->SetName(lexer_->GetIdentifier()); @@ -591,24 +536,73 @@ bool Parser::ParseMethod(const AutoPtr& interface) method->SetLite(attributes->isLite); } + if (!ParseParameterList(method)) { + return false; + } + + interface->AddMethod(method); + return true; +} + +bool Parser::ParseAttributeBody(AutoPtr& attributes) +{ + Token token = lexer_->PeekToken(); + if (token != Token::BRACKETS_LEFT) { + return true; + } + lexer_->GetToken(); + + attributes = new Attribute(); token = lexer_->PeekToken(); - if (token != Token::PARENTHESES_LEFT) { - LogError(String("'(' is expected.")); - if (token == Token::BRACES_RIGHT) { - return false; + while (token != Token::BRACKETS_RIGHT) { + switch (token) { + case Token::ONEWAY: + attributes->isOneWay = true; + break; + case Token::CALLBACK: + attributes->isCallback = true; + break; + case Token::FULL: + attributes->isFull = true; + break; + case Token::LITE: + attributes->isLite = true; + break; + default: { + LogError(String::Format("'%s' is not expected.", lexer_->DumpToken().string())); + lexer_->Skip(Lexer::TokenToChar(Token::BRACKETS_RIGHT)); + lexer_->GetToken(); + return false; + } } - // jump over colon lexer_->GetToken(); - while (token != Token::SEMICOLON && token != Token::END_OF_FILE) { + token = lexer_->PeekToken(); + if (token == Token::COMMA) { + lexer_->GetToken(); token = lexer_->PeekToken(); - if (token == Token::BRACES_RIGHT) { - break; - } + } else if (token == Token::BRACKETS_RIGHT) { + break; + } else { + LogError(String::Format("'%s' is not expected.", lexer_->DumpToken().string())); + lexer_->Skip(Lexer::TokenToChar(Token::BRACKETS_RIGHT)); lexer_->GetToken(); + return false; } + } + lexer_->GetToken(); + return true; +} + +bool Parser::ParseParameterList(AutoPtr& method) +{ + bool ret = true; + Token token = lexer_->PeekToken(); + if (token != Token::PARENTHESES_LEFT) { + LogError(String("'(' is expected.")); + lexer_->Skip(';'); return false; } - token = lexer_->GetToken(); + lexer_->GetToken(); token = lexer_->PeekToken(); while (token != Token::PARENTHESES_RIGHT && token != Token::END_OF_FILE) { @@ -637,92 +631,19 @@ bool Parser::ParseMethod(const AutoPtr& interface) return false; } lexer_->GetToken(); - interface->AddMethod(method); - return ret; -} - -bool Parser::ParseMethodAttr(const AutoPtr& interface, const AutoPtr& attributes) -{ - if (interface == nullptr || attributes == nullptr) { - return false; - } - - Token token = lexer_->PeekToken(); - if (token == Token::BRACES_RIGHT) { - LogError(String::Format("%s has no method.", interface->GetName().string())); - lexer_->SkipCurrentLine(Lexer::TokenToChar(Token::BRACES_RIGHT)); - lexer_->GetToken(); - return false; - } - - if (token == Token::BRACKETS_LEFT) { - lexer_->GetToken(); - token = lexer_->PeekToken(); - while (token != Token::BRACKETS_RIGHT) { - switch (token) { - case Token::ONEWAY: - attributes->isOneWay = true; - break; - case Token::FULL: - attributes->isFull = true; - break; - case Token::LITE: - attributes->isLite = true; - break; - default: { - LogError(String::Format("'%s' is not expected.", lexer_->DumpToken().string())); - lexer_->SkipCurrentLine(Lexer::TokenToChar(Token::BRACKETS_RIGHT)); - lexer_->GetToken(); - return false; - } - } - lexer_->GetToken(); - token = lexer_->PeekToken(); - if (token == Token::COMMA) { - lexer_->GetToken(); - token = lexer_->PeekToken(); - } else if (token == Token::BRACKETS_RIGHT) { - } else { - LogError(String::Format("'%s' is not expected.", lexer_->DumpToken().string())); - lexer_->SkipCurrentLine(Lexer::TokenToChar(Token::BRACKETS_RIGHT)); - lexer_->GetToken(); - return false; - } - } - lexer_->GetToken(); - } return true; } bool Parser::ParseParameter(const AutoPtr& method) { - Token token = lexer_->PeekToken(); - if (token != Token::BRACKETS_LEFT) { - LogError(String("'[' is expected.")); - while (token != Token::COMMA && token != Token::PARENTHESES_RIGHT && token != Token::END_OF_FILE) { - lexer_->GetToken(); - token = lexer_->PeekToken(); - } - return false; - } - lexer_->GetToken(); - AutoPtr parameter = new ASTParameter(); if (!ParseParamAttr(parameter)) { return false; } - token = lexer_->PeekToken(); - if (token != Token::BRACKETS_RIGHT) { - LogError(String::Format("'%s' is not expected.", lexer_->DumpToken().string())); - while (token != Token::SEMICOLON && token != Token::END_OF_FILE) { - lexer_->GetToken(); - token = lexer_->PeekToken(); - } - return false; - } - lexer_->GetToken(); AutoPtr type = ParseType(); + + Token token = lexer_->PeekToken(); if (type == nullptr) { while (token != Token::COMMA && token != Token::PARENTHESES_RIGHT && token != Token::END_OF_FILE) { lexer_->GetToken(); @@ -731,7 +652,6 @@ bool Parser::ParseParameter(const AutoPtr& method) return false; } - token = lexer_->PeekToken(); if (token != Token::IDENTIFIER) { LogError(String("Parameter name is expected.")); while (token != Token::COMMA && token != Token::PARENTHESES_RIGHT && token != Token::END_OF_FILE) { @@ -741,6 +661,7 @@ bool Parser::ParseParameter(const AutoPtr& method) return false; } lexer_->GetToken(); + parameter->SetName(lexer_->GetIdentifier()); parameter->SetType(type); method->AddParameter(parameter); @@ -749,10 +670,22 @@ bool Parser::ParseParameter(const AutoPtr& method) bool Parser::ParseParamAttr(const AutoPtr& parameter) { + Token token = lexer_->PeekToken(); + if (token != Token::BRACKETS_LEFT) { + LogError(String("'[' is expected.")); + while (token != Token::COMMA && token != Token::PARENTHESES_RIGHT && token != Token::END_OF_FILE) { + lexer_->GetToken(); + token = lexer_->PeekToken(); + } + return false; + } + lexer_->GetToken(); + if (parameter == nullptr) { return false; } - Token token = lexer_->PeekToken(); + + token = lexer_->PeekToken(); if (token == Token::IN) { lexer_->GetToken(); parameter->SetAttribute(ParamAttr::PARAM_IN); @@ -768,6 +701,18 @@ bool Parser::ParseParamAttr(const AutoPtr& parameter) } return false; } + + token = lexer_->PeekToken(); + if (token != Token::BRACKETS_RIGHT) { + LogError(String::Format("']' is expected.")); + while (token != Token::SEMICOLON && token != Token::END_OF_FILE) { + lexer_->GetToken(); + token = lexer_->PeekToken(); + } + return false; + } + lexer_->GetToken(); + return true; } @@ -791,25 +736,8 @@ AutoPtr Parser::ParseType() lexer_->GetToken(); type = ast_->FindType(lexer_->GetIdentifier()); } else if (token == Token::UNSIGNED) { - String unsignedStr = lexer_->DumpToken(); lexer_->GetToken(); - token = lexer_->PeekToken(); - switch (token) { - case Token::CHAR: - case Token::SHORT: - case Token::INTEGER: - case Token::LONG: { - type = ast_->FindType(unsignedStr + " " + lexer_->DumpToken()); - lexer_->GetToken(); - break; - } - default: { - LogError(typeLineNo, typeColumnNo, - String::Format("'unsigned %s' type was not declared in the idl file.", - lexer_->DumpToken().string())); - return nullptr; - } - } + type = ParseUnsignedType(typeLineNo, typeColumnNo); } else { LogError(typeLineNo, typeColumnNo, String("Invalid type name.")); return nullptr; @@ -823,23 +751,7 @@ AutoPtr Parser::ParseType() token = lexer_->PeekToken(); if (token == Token::BRACKETS_LEFT) { lexer_->GetToken(); - token = lexer_->PeekToken(); - if (token != Token::BRACKETS_RIGHT) { - LogError(typeLineNo, typeColumnNo, String("']' is expected.")); - return nullptr; - } - lexer_->GetToken(); - - if (type != nullptr) { - AutoPtr arrayType = new ASTArrayType(); - arrayType->SetElementType(type); - - type = ast_->FindType(arrayType->ToString()); - if (type == nullptr) { - ast_->AddType(arrayType.Get()); - type = static_cast(arrayType.Get()); - } - } + type = ParseArrayType(type); } if (!CheckType(typeLineNo, typeColumnNo, type)) { @@ -849,6 +761,31 @@ AutoPtr Parser::ParseType() return type; } +AutoPtr Parser::ParseUnsignedType(int typeLineNo, int typeColumnNo) +{ + AutoPtr type = nullptr; + String unsignedStr = lexer_->DumpToken(); + Token token = lexer_->PeekToken(); + switch (token) { + case Token::CHAR: + case Token::SHORT: + case Token::INTEGER: + case Token::LONG: { + type = ast_->FindType(unsignedStr + " " + lexer_->DumpToken()); + lexer_->GetToken(); + break; + } + default: { + LogError(typeLineNo, typeColumnNo, + String::Format("'unsigned %s' type was not declared in the idl file.", + lexer_->DumpToken().string())); + return nullptr; + } + } + + return type; +} + AutoPtr Parser::ParseList() { lexer_->GetToken(); @@ -936,6 +873,31 @@ AutoPtr Parser::ParseMap() return ret; } +AutoPtr Parser::ParseArrayType(const AutoPtr& elementType) +{ + Token token = lexer_->PeekToken(); + if (token != Token::BRACKETS_RIGHT) { + LogError(String("']' is expected.")); + return nullptr; + } + lexer_->GetToken(); + + if (elementType == nullptr) { + return nullptr; + } + + AutoPtr arrayType = new ASTArrayType(); + arrayType->SetElementType(elementType); + AutoPtr type = ast_->FindType(arrayType->ToString()); + + if (type == nullptr) { + ast_->AddType(arrayType.Get()); + type = static_cast(arrayType.Get()); + } + + return type; +} + AutoPtr Parser::ParseCustomType() { Token token = lexer_->GetToken(); @@ -1106,7 +1068,22 @@ bool Parser::ParseStructDefine(const AutoPtr& attributes) type->SetName(lexer_->GetIdentifier()); lexer_->GetToken(); - token = lexer_->PeekToken(); + if (!ParseStructMember(type)) { + return false; + } + + if (attributes != nullptr) { + type->SetFull(attributes->isFull); + type->SetLite(attributes->isLite); + } + + ast_->AddTypeDefinition(type.Get()); + return true; +} + +bool Parser::ParseStructMember(const AutoPtr& type) +{ + Token token = lexer_->PeekToken(); if (token != Token::BRACES_LEFT) { lexer_->SkipCurrentLine(';'); return false; @@ -1129,7 +1106,6 @@ bool Parser::ParseStructDefine(const AutoPtr& attributes) } String memberName = lexer_->GetIdentifier(); lexer_->GetToken(); - type->AddMember(member, memberName); token = lexer_->PeekToken(); @@ -1152,13 +1128,6 @@ bool Parser::ParseStructDefine(const AutoPtr& attributes) return false; } lexer_->GetToken(); - - if (attributes != nullptr) { - type->SetFull(attributes->isFull); - type->SetLite(attributes->isLite); - } - - ast_->AddTypeDefinition(type.Get()); return true; } @@ -1180,7 +1149,22 @@ bool Parser::ParseUnionDefine(const AutoPtr& attributes) type->SetName(lexer_->GetIdentifier()); lexer_->GetToken(); - token = lexer_->PeekToken(); + if (!ParseUnionMember(type)) { + return false; + } + + if (attributes != nullptr) { + type->SetFull(attributes->isFull); + type->SetLite(attributes->isLite); + } + + ast_->AddTypeDefinition(type.Get()); + return true; +} + +bool Parser::ParseUnionMember(const AutoPtr& type) +{ + Token token = lexer_->PeekToken(); if (token != Token::BRACES_LEFT) { lexer_->SkipCurrentLine(';'); return false; @@ -1203,7 +1187,6 @@ bool Parser::ParseUnionDefine(const AutoPtr& attributes) } String memberName = lexer_->GetIdentifier(); lexer_->GetToken(); - type->AddMember(member, memberName); token = lexer_->PeekToken(); @@ -1226,13 +1209,6 @@ bool Parser::ParseUnionDefine(const AutoPtr& attributes) return false; } lexer_->GetToken(); - - if (attributes != nullptr) { - type->SetFull(attributes->isFull); - type->SetLite(attributes->isLite); - } - - ast_->AddTypeDefinition(type.Get()); return true; } @@ -1247,6 +1223,20 @@ bool Parser::CheckType(int lineNo, int columnNo, const AutoPtr& type) LogError(lineNo, columnNo, String::Format("The sequenceable type is not supported by c language.")); return false; } + + if (options_.DoGenerateKernelCode()) { + switch (type->GetTypeKind()) { + case TypeKind::TYPE_FLOAT: + case TypeKind::TYPE_DOUBLE: + case TypeKind::TYPE_FILEDESCRIPTOR: + case TypeKind::TYPE_INTERFACE: + LogError(lineNo, columnNo, String::Format("The '%s' type is not supported by c language.", + lexer_->DumpToken().string())); + break; + default: + break; + } + } } else if (options_.GetTargetLanguage().Equals("java")) { switch (type->GetTypeKind()) { case TypeKind::TYPE_UCHAR: @@ -1268,6 +1258,19 @@ bool Parser::CheckType(int lineNo, int columnNo, const AutoPtr& type) return true; } +void Parser::SetAstFileType() +{ + if (ast_->GetInterfaceDef() != nullptr) { + if (ast_->GetInterfaceDef()->IsCallback()) { + ast_->SetAStFileType(ASTFileType::AST_ICALLBACK); + } else { + ast_->SetAStFileType(ASTFileType::AST_IFACE); + } + } else { + ast_->SetAStFileType(ASTFileType::AST_TYPES); + } +} + bool Parser::CheckIntegrity() { if (ast_ == nullptr) { @@ -1287,36 +1290,10 @@ bool Parser::CheckIntegrity() switch (ast_->GetASTFileType()) { case ASTFileType::AST_IFACE: { - AutoPtr interface = ast_->GetInterfaceDef(); - if (interface == nullptr) { - LogError(String("ast's interface is empty.")); - return false; - } - - if (ast_->GetTypeDefinitionNumber() > 0) { - LogError(String("interface ast cannot has custom types.")); - return false; - } - - if (interface->GetMethodNumber() == 0) { - LogError(String("interface ast has no method.")); - return false; - } - - break; + return CheckInterfaceAst(); } case ASTFileType::AST_ICALLBACK: { - AutoPtr interface = ast_->GetInterfaceDef(); - if (interface == nullptr) { - LogError(String("ast's interface is empty.")); - return false; - } - - if (!interface->IsCallback()) { - LogError(String("ast is callback, but ast's interface is not callback.")); - return false; - } - break; + return CheckCallbackAst(); } case ASTFileType::AST_SEQUENCEABLE: { LogError(String("it's impossible that ast is sequenceable.")); @@ -1336,6 +1313,41 @@ bool Parser::CheckIntegrity() return true; } +bool Parser::CheckInterfaceAst() +{ + AutoPtr interface = ast_->GetInterfaceDef(); + if (interface == nullptr) { + LogError(String("ast's interface is empty.")); + return false; + } + + if (ast_->GetTypeDefinitionNumber() > 0) { + LogError(String("interface ast cannot has custom types.")); + return false; + } + + if (interface->GetMethodNumber() == 0) { + LogError(String("interface ast has no method.")); + return false; + } + return true; +} + +bool Parser::CheckCallbackAst() +{ + AutoPtr interface = ast_->GetInterfaceDef(); + if (interface == nullptr) { + LogError(String("ast's interface is empty.")); + return false; + } + + if (!interface->IsCallback()) { + LogError(String("ast is callback, but ast's interface is not callback.")); + return false; + } + return true; +} + bool Parser::IsValidTypeName(const String& typeName) { if (typeName[0] == '.') { @@ -1356,8 +1368,14 @@ bool Parser::IsValidTypeName(const String& typeName) */ bool Parser::CheckPackageName(const String& filePath, const String& packageName) { - String pkgToPath = packageName.Replace('.', '/'); - int index = filePath.LastIndexOf('/'); +#ifndef __MINGW32__ + char delimiter = '/'; +#else + char delimiter = '\\'; +#endif + + String pkgToPath = packageName.Replace('.', delimiter); + int index = filePath.LastIndexOf(delimiter); if (index == -1) { return false; } diff --git a/tools/hdi-gen/parser/parser.h b/tools/hdi-gen/parser/parser.h index 578bb8364963ef44b61f0f89631b7e42eafcf7ee..bfd1f02dec550ba25e063e99b4cd0d1f6d7fe7b1 100755 --- a/tools/hdi-gen/parser/parser.h +++ b/tools/hdi-gen/parser/parser.h @@ -81,9 +81,13 @@ private: bool ParseInterface(const AutoPtr& attributes = nullptr); + bool ParseInterfaceBody(const AutoPtr& interface); + bool ParseMethod(const AutoPtr& interface); - bool ParseMethodAttr(const AutoPtr& interface, const AutoPtr& attributes); + bool ParseAttributeBody(AutoPtr& attributes); + + bool ParseParameterList(AutoPtr& method); bool ParseParameter(const AutoPtr& method); @@ -91,10 +95,14 @@ private: AutoPtr ParseType(); + AutoPtr ParseUnsignedType(int typeLineNo, int typeColumnNo); + AutoPtr ParseList(); AutoPtr ParseMap(); + AutoPtr ParseArrayType(const AutoPtr& elementType); + AutoPtr ParseCustomType(); bool ParseEnumDefine(const AutoPtr& attributes = nullptr); @@ -105,12 +113,22 @@ private: bool ParseStructDefine(const AutoPtr& attributes = nullptr); + bool ParseStructMember(const AutoPtr& type); + bool ParseUnionDefine(const AutoPtr& attributes = nullptr); + bool ParseUnionMember(const AutoPtr& type); + bool CheckType(int lineNo, int columnNo, const AutoPtr& type); + void SetAstFileType(); + bool CheckIntegrity(); + bool CheckInterfaceAst(); + + bool CheckCallbackAst(); + bool IsValidTypeName(const String& typeName); bool CheckPackageName(const String& filePath, const String& packageName); diff --git a/tools/hdi-gen/test/c_test/array_test/v1_0/c_array_test.cpp b/tools/hdi-gen/test/c_test/array_test/v1_0/c_array_test.cpp index d681912be01531e7c8644573095d8c9190dc6dd7..32095c5f4d73f1883f4ea52ea5ac093d2ef07456 100755 --- a/tools/hdi-gen/test/c_test/array_test/v1_0/c_array_test.cpp +++ b/tools/hdi-gen/test/c_test/array_test/v1_0/c_array_test.cpp @@ -8,14 +8,14 @@ #include #include +#include +#include +#include #include #include -#include -#include -#include -#include -#include -#include +#include "hdf_log.h" +#include "osal_mem.h" +#include "securec.h" #include "c_test/array_test/v1_0/client/iarray_test.h" using namespace OHOS; @@ -23,7 +23,7 @@ using namespace testing::ext; static struct IArrayTest *g_testClient = nullptr; -class ArrayTest : public testing::Test { +class CArrayTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(); @@ -31,15 +31,15 @@ public: void TearDown(){} }; -void ArrayTest::SetUpTestCase() +void CArrayTest::SetUpTestCase() { g_testClient = HdiArrayTestGet(); if (g_testClient == nullptr) { - printf("ArrayTest: get g_testClient failed.\n"); + printf("CArrayTest: get g_testClient failed.\n"); } } -void ArrayTest::TearDownTestCase() +void CArrayTest::TearDownTestCase() { if (g_testClient != nullptr) { HdiArrayTestRelease(g_testClient); @@ -47,12 +47,12 @@ void ArrayTest::TearDownTestCase() } } -HWTEST_F(ArrayTest, ArratTest_001, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_001, TestSize.Level1) { ASSERT_NE(nullptr, g_testClient); } -HWTEST_F(ArrayTest, ArratTest_002, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_002, TestSize.Level1) { uint32_t inParamLen = 4; bool *inParam = (bool*)OsalMemAlloc(sizeof(bool) * inParamLen); @@ -89,7 +89,7 @@ HWTEST_F(ArrayTest, ArratTest_002, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_003, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_003, TestSize.Level1) { uint32_t inParamLen = 4; int8_t *inParam = (int8_t*)OsalMemAlloc(sizeof(int8_t) * inParamLen); @@ -127,7 +127,7 @@ HWTEST_F(ArrayTest, ArratTest_003, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_004, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_004, TestSize.Level1) { uint32_t inParamLen = 4; int16_t *inParam = (int16_t*)OsalMemAlloc(sizeof(int16_t) * inParamLen); @@ -164,7 +164,7 @@ HWTEST_F(ArrayTest, ArratTest_004, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_005, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_005, TestSize.Level1) { uint32_t inParamLen = 4; int32_t *inParam = (int32_t*)OsalMemAlloc(sizeof(int32_t) * inParamLen); @@ -201,7 +201,7 @@ HWTEST_F(ArrayTest, ArratTest_005, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_006, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_006, TestSize.Level1) { uint32_t inParamLen = 4; int64_t *inParam = (int64_t*)OsalMemAlloc(sizeof(int64_t) * inParamLen); @@ -238,7 +238,7 @@ HWTEST_F(ArrayTest, ArratTest_006, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_007, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_007, TestSize.Level1) { uint32_t inParamLen = 4; uint8_t *inParam = (uint8_t*)OsalMemAlloc(sizeof(uint8_t) * inParamLen); @@ -275,7 +275,7 @@ HWTEST_F(ArrayTest, ArratTest_007, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_008, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_008, TestSize.Level1) { uint32_t inParamLen = 4; uint16_t *inParam = (uint16_t*)OsalMemAlloc(sizeof(uint16_t) * inParamLen); @@ -312,7 +312,7 @@ HWTEST_F(ArrayTest, ArratTest_008, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_009, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_009, TestSize.Level1) { uint32_t inParamLen = 4; uint32_t *inParam = (uint32_t*)OsalMemAlloc(sizeof(uint32_t) * inParamLen); @@ -349,7 +349,7 @@ HWTEST_F(ArrayTest, ArratTest_009, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_010, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_010, TestSize.Level1) { uint32_t inParamLen = 4; uint64_t *inParam = (uint64_t*)OsalMemAlloc(sizeof(uint64_t) * inParamLen); @@ -386,7 +386,7 @@ HWTEST_F(ArrayTest, ArratTest_010, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_011, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_011, TestSize.Level1) { uint32_t inParamLen = 4; float *inParam = (float*)OsalMemAlloc(sizeof(float) * inParamLen); @@ -424,7 +424,7 @@ HWTEST_F(ArrayTest, ArratTest_011, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_012, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_012, TestSize.Level1) { uint32_t inParamLen = 4; double *inParam = (double*)OsalMemAlloc(sizeof(double) * inParamLen); @@ -462,7 +462,7 @@ HWTEST_F(ArrayTest, ArratTest_012, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_013, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_013, TestSize.Level1) { uint32_t inParamLen = 2; char **inParam = (char**)OsalMemAlloc(sizeof(char*) * inParamLen); @@ -505,7 +505,7 @@ HWTEST_F(ArrayTest, ArratTest_013, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_014, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_014, TestSize.Level1) { uint32_t inParamLen = 2; @@ -545,7 +545,7 @@ HWTEST_F(ArrayTest, ArratTest_014, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_015, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_015, TestSize.Level1) { uint32_t inParamLen = 4; enum ESample *inParam = (enum ESample*)OsalMemAlloc(sizeof(enum ESample) * inParamLen); @@ -582,7 +582,7 @@ HWTEST_F(ArrayTest, ArratTest_015, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_016, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_016, TestSize.Level1) { uint32_t inParamLen = 2; struct SSample *inParam = (struct SSample *)OsalMemAlloc(sizeof(struct SSample) * inParamLen); @@ -632,7 +632,7 @@ HWTEST_F(ArrayTest, ArratTest_016, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArratTest_017, TestSize.Level0) +HWTEST_F(CArrayTest, CArrayTest_017, TestSize.Level1) { uint32_t inParamLen = 2; union USample *inParam = (union USample *)OsalMemAlloc(sizeof(union USample) * inParamLen); diff --git a/tools/hdi-gen/test/c_test/cb_test/v1_0/c_cb_test.cpp b/tools/hdi-gen/test/c_test/cb_test/v1_0/c_cb_test.cpp index f84837ffcc30f4f19360d3c202aaf19b34c78a32..25f58600fb1635317bccbcc7e49ae8757b3f9ecb 100755 --- a/tools/hdi-gen/test/c_test/cb_test/v1_0/c_cb_test.cpp +++ b/tools/hdi-gen/test/c_test/cb_test/v1_0/c_cb_test.cpp @@ -10,11 +10,11 @@ #include #include #include -#include -#include -#include -#include "c_test/cb_test/v1_0/client/icb_test.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "securec.h" #include "c_test/cb_test/v1_0/callback_stub.h" +#include "c_test/cb_test/v1_0/client/icb_test.h" using namespace OHOS; using namespace testing::ext; @@ -22,7 +22,7 @@ using namespace testing::ext; static struct ICbTest *g_testClient = nullptr; static struct ICallback *g_callback = nullptr; -class CbTest : public testing::Test { +class CCbTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(); @@ -30,20 +30,20 @@ public: void TearDown(){} }; -void CbTest::SetUpTestCase() +void CCbTest::SetUpTestCase() { g_testClient = HdiCbTestGet(); if (g_testClient == nullptr) { - printf("CbTest: get g_testClient failed.\n"); + printf("CCbTest: get g_testClient failed.\n"); } g_callback = CallbackStubObtain(); if (g_callback == nullptr) { - printf("CbTest: get g_callback failed.\n"); + printf("CCbTest: get g_callback failed.\n"); } } -void CbTest::TearDownTestCase() +void CCbTest::TearDownTestCase() { if (g_testClient != nullptr) { HdiCbTestRelease(g_testClient); @@ -56,13 +56,13 @@ void CbTest::TearDownTestCase() } } -HWTEST_F(CbTest, CbTest_001, TestSize.Level0) +HWTEST_F(CCbTest, CCbTest_001, TestSize.Level1) { ASSERT_NE(nullptr, g_testClient); ASSERT_NE(nullptr, g_callback); } -HWTEST_F(CbTest, CbTest_002, TestSize.Level0) +HWTEST_F(CCbTest, CCbTest_002, TestSize.Level1) { int32_t ec = g_testClient->CallbackTest(g_testClient, g_callback); ASSERT_EQ(ec, HDF_SUCCESS); diff --git a/tools/hdi-gen/test/c_test/data_test/v1_0/c_data_test.cpp b/tools/hdi-gen/test/c_test/data_test/v1_0/c_data_test.cpp index 5d3bfbab6f3983b1b0f8d7123fa1b48825922114..6192a4d7176de130c762120f892af7c198bd1207 100755 --- a/tools/hdi-gen/test/c_test/data_test/v1_0/c_data_test.cpp +++ b/tools/hdi-gen/test/c_test/data_test/v1_0/c_data_test.cpp @@ -8,14 +8,14 @@ #include #include +#include +#include +#include #include #include -#include -#include -#include -#include -#include -#include +#include "hdf_log.h" +#include "osal_mem.h" +#include "securec.h" #include "test/c_test/data_test/v1_0/client/idata_test.h" using namespace OHOS; @@ -24,7 +24,7 @@ using namespace testing::ext; static struct IDataTest *g_testClient = nullptr; static struct ICallback *g_callback = nullptr; -class DataTest : public testing::Test { +class CDataTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(); @@ -32,15 +32,15 @@ public: void TearDown(){} }; -void DataTest::SetUpTestCase() +void CDataTest::SetUpTestCase() { g_testClient = HdiDataTestGet(); if (g_testClient == nullptr) { - printf("DataTest: get g_testClient failed.\n"); + printf("CDataTest: get g_testClient failed.\n"); } } -void DataTest::TearDownTestCase() +void CDataTest::TearDownTestCase() { if (g_testClient != nullptr) { HdiDataTestRelease(g_testClient); @@ -48,12 +48,12 @@ void DataTest::TearDownTestCase() } } -HWTEST_F(DataTest, DataTest_001, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_001, TestSize.Level1) { ASSERT_NE(nullptr, g_testClient); } -HWTEST_F(DataTest, DataTest_002, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_002, TestSize.Level1) { bool inParam = true; bool outParam = false; @@ -65,8 +65,7 @@ HWTEST_F(DataTest, DataTest_002, TestSize.Level0) EXPECT_TRUE(outParam); } - -HWTEST_F(DataTest, DataTest_003, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_003, TestSize.Level1) { int8_t inParam = 10; int8_t outParam = 0; @@ -77,7 +76,7 @@ HWTEST_F(DataTest, DataTest_003, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_004, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_004, TestSize.Level1) { int16_t inParam = 10; int16_t outParam = 0; @@ -88,7 +87,7 @@ HWTEST_F(DataTest, DataTest_004, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_005, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_005, TestSize.Level1) { int32_t inParam = 10; int32_t outParam = 0; @@ -99,7 +98,7 @@ HWTEST_F(DataTest, DataTest_005, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_006, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_006, TestSize.Level1) { int64_t inParam = 10; int64_t outParam = 0; @@ -110,7 +109,7 @@ HWTEST_F(DataTest, DataTest_006, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_007, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_007, TestSize.Level1) { uint8_t inParam = 10; uint8_t outParam = 0; @@ -121,7 +120,7 @@ HWTEST_F(DataTest, DataTest_007, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_008, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_008, TestSize.Level1) { uint16_t inParam = 10; uint16_t outParam = 0; @@ -132,7 +131,7 @@ HWTEST_F(DataTest, DataTest_008, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_009, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_009, TestSize.Level1) { uint32_t inParam = 10; uint32_t outParam = 0; @@ -143,7 +142,7 @@ HWTEST_F(DataTest, DataTest_009, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_010, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_010, TestSize.Level1) { uint64_t inParam = 10; uint64_t outParam = 0; @@ -154,7 +153,7 @@ HWTEST_F(DataTest, DataTest_010, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_011, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_011, TestSize.Level1) { float inParam = 10.5; float outParam = 0; @@ -165,7 +164,7 @@ HWTEST_F(DataTest, DataTest_011, TestSize.Level0) EXPECT_FLOAT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_012, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_012, TestSize.Level1) { double inParam = 10.5; double outParam = 0; @@ -176,7 +175,7 @@ HWTEST_F(DataTest, DataTest_012, TestSize.Level0) EXPECT_DOUBLE_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_013, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_013, TestSize.Level1) { const char* inParam = "hello"; char* outParam = nullptr; @@ -187,7 +186,7 @@ HWTEST_F(DataTest, DataTest_013, TestSize.Level0) EXPECT_STREQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_014, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_014, TestSize.Level1) { int fd = open("/c_data_test_014.txt", O_CREAT | O_RDWR | O_TRUNC, 0644); printf("file open, fd = %d\n", fd); @@ -219,7 +218,7 @@ finished: close(fd); } -HWTEST_F(DataTest, DataTest_015, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_015, TestSize.Level1) { enum ESample inParam = MEM_ONE; enum ESample outParam = MEM_TWO; @@ -230,7 +229,7 @@ HWTEST_F(DataTest, DataTest_015, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_016, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_016, TestSize.Level1) { struct SSample inParam; inParam.m1 = true; @@ -260,7 +259,7 @@ HWTEST_F(DataTest, DataTest_016, TestSize.Level0) } } -HWTEST_F(DataTest, DataTest_017, TestSize.Level0) +HWTEST_F(CDataTest, CDataTest_017, TestSize.Level1) { union USample inParam; inParam.m2 = 10; diff --git a/tools/hdi-gen/test/c_test/list_test/v1_0/c_list_test.cpp b/tools/hdi-gen/test/c_test/list_test/v1_0/c_list_test.cpp index 38113c4294a8df5577c5ff611d9b2395ee46d3c3..80ceecf58abd8f970d1977b3a0a81a293ece129f 100755 --- a/tools/hdi-gen/test/c_test/list_test/v1_0/c_list_test.cpp +++ b/tools/hdi-gen/test/c_test/list_test/v1_0/c_list_test.cpp @@ -8,14 +8,14 @@ #include #include +#include +#include +#include #include #include -#include -#include -#include -#include -#include -#include +#include "hdf_log.h" +#include "osal_mem.h" +#include "securec.h" #include "c_test/list_test/v1_0/client/ilist_test.h" using namespace OHOS; @@ -23,7 +23,7 @@ using namespace testing::ext; static struct IListTest *g_testClient = nullptr; -class ListTest : public testing::Test { +class CListTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(); @@ -31,15 +31,15 @@ public: void TearDown(){} }; -void ListTest::SetUpTestCase() +void CListTest::SetUpTestCase() { g_testClient = HdiListTestGet(); if (g_testClient == nullptr) { - printf("ListTest: get g_testClient failed.\n"); + printf("CListTest: get g_testClient failed.\n"); } } -void ListTest::TearDownTestCase() +void CListTest::TearDownTestCase() { if (g_testClient != nullptr) { HdiListTestRelease(g_testClient); @@ -47,12 +47,12 @@ void ListTest::TearDownTestCase() } } -HWTEST_F(ListTest, ArratTest_001, TestSize.Level0) +HWTEST_F(CListTest, CListTest_001, TestSize.Level1) { ASSERT_NE(nullptr, g_testClient); } -HWTEST_F(ListTest, ArratTest_002, TestSize.Level0) +HWTEST_F(CListTest, CListTest_002, TestSize.Level1) { uint32_t inParamLen = 4; bool *inParam = (bool*)OsalMemAlloc(sizeof(bool) * inParamLen); @@ -89,7 +89,7 @@ HWTEST_F(ListTest, ArratTest_002, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_003, TestSize.Level0) +HWTEST_F(CListTest, CListTest_003, TestSize.Level1) { uint32_t inParamLen = 4; int8_t *inParam = (int8_t*)OsalMemAlloc(sizeof(int8_t) * inParamLen); @@ -127,7 +127,7 @@ HWTEST_F(ListTest, ArratTest_003, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_004, TestSize.Level0) +HWTEST_F(CListTest, CListTest_004, TestSize.Level1) { uint32_t inParamLen = 4; int16_t *inParam = (int16_t*)OsalMemAlloc(sizeof(int16_t) * inParamLen); @@ -164,7 +164,7 @@ HWTEST_F(ListTest, ArratTest_004, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_005, TestSize.Level0) +HWTEST_F(CListTest, CListTest_005, TestSize.Level1) { uint32_t inParamLen = 4; int32_t *inParam = (int32_t*)OsalMemAlloc(sizeof(int32_t) * inParamLen); @@ -201,7 +201,7 @@ HWTEST_F(ListTest, ArratTest_005, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_006, TestSize.Level0) +HWTEST_F(CListTest, CListTest_006, TestSize.Level1) { uint32_t inParamLen = 4; int64_t *inParam = (int64_t*)OsalMemAlloc(sizeof(int64_t) * inParamLen); @@ -238,7 +238,7 @@ HWTEST_F(ListTest, ArratTest_006, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_007, TestSize.Level0) +HWTEST_F(CListTest, CListTest_007, TestSize.Level1) { uint32_t inParamLen = 4; uint8_t *inParam = (uint8_t*)OsalMemAlloc(sizeof(uint8_t) * inParamLen); @@ -275,7 +275,7 @@ HWTEST_F(ListTest, ArratTest_007, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_008, TestSize.Level0) +HWTEST_F(CListTest, CListTest_008, TestSize.Level1) { uint32_t inParamLen = 4; uint16_t *inParam = (uint16_t*)OsalMemAlloc(sizeof(uint16_t) * inParamLen); @@ -312,7 +312,7 @@ HWTEST_F(ListTest, ArratTest_008, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_009, TestSize.Level0) +HWTEST_F(CListTest, CListTest_009, TestSize.Level1) { uint32_t inParamLen = 4; uint32_t *inParam = (uint32_t*)OsalMemAlloc(sizeof(uint32_t) * inParamLen); @@ -349,7 +349,7 @@ HWTEST_F(ListTest, ArratTest_009, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_010, TestSize.Level0) +HWTEST_F(CListTest, CListTest_010, TestSize.Level1) { uint32_t inParamLen = 4; uint64_t *inParam = (uint64_t*)OsalMemAlloc(sizeof(uint64_t) * inParamLen); @@ -386,7 +386,7 @@ HWTEST_F(ListTest, ArratTest_010, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_011, TestSize.Level0) +HWTEST_F(CListTest, CListTest_011, TestSize.Level1) { uint32_t inParamLen = 4; float *inParam = (float*)OsalMemAlloc(sizeof(float) * inParamLen); @@ -424,7 +424,7 @@ HWTEST_F(ListTest, ArratTest_011, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_012, TestSize.Level0) +HWTEST_F(CListTest, CListTest_012, TestSize.Level1) { uint32_t inParamLen = 4; double *inParam = (double*)OsalMemAlloc(sizeof(double) * inParamLen); @@ -462,7 +462,7 @@ HWTEST_F(ListTest, ArratTest_012, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_013, TestSize.Level0) +HWTEST_F(CListTest, CListTest_013, TestSize.Level1) { uint32_t inParamLen = 2; char **inParam = (char**)OsalMemAlloc(sizeof(char*) * inParamLen); @@ -505,7 +505,7 @@ HWTEST_F(ListTest, ArratTest_013, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_014, TestSize.Level0) +HWTEST_F(CListTest, CListTest_014, TestSize.Level1) { uint32_t inParamLen = 2; @@ -545,7 +545,7 @@ HWTEST_F(ListTest, ArratTest_014, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_015, TestSize.Level0) +HWTEST_F(CListTest, CListTest_015, TestSize.Level1) { uint32_t inParamLen = 4; enum ESample *inParam = (enum ESample*)OsalMemAlloc(sizeof(enum ESample) * inParamLen); @@ -582,7 +582,7 @@ HWTEST_F(ListTest, ArratTest_015, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_016, TestSize.Level0) +HWTEST_F(CListTest, CListTest_016, TestSize.Level1) { uint32_t inParamLen = 2; struct SSample *inParam = (struct SSample *)OsalMemAlloc(sizeof(struct SSample) * inParamLen); @@ -632,7 +632,7 @@ HWTEST_F(ListTest, ArratTest_016, TestSize.Level0) } } -HWTEST_F(ListTest, ArratTest_017, TestSize.Level0) +HWTEST_F(CListTest, CListTest_017, TestSize.Level1) { uint32_t inParamLen = 2; union USample *inParam = (union USample *)OsalMemAlloc(sizeof(union USample) * inParamLen); diff --git a/tools/hdi-gen/test/c_test/struct_test/v1_0/c_struct_test.cpp b/tools/hdi-gen/test/c_test/struct_test/v1_0/c_struct_test.cpp index 1928b42bd6d2e72f4ffaa61b0cd9ec6e79677983..d4b937007e7cdeb96b93a66c64a3e0d5c19f0b23 100755 --- a/tools/hdi-gen/test/c_test/struct_test/v1_0/c_struct_test.cpp +++ b/tools/hdi-gen/test/c_test/struct_test/v1_0/c_struct_test.cpp @@ -8,22 +8,34 @@ #include #include +#include +#include +#include #include #include -#include -#include -#include -#include -#include -#include +#include "hdf_log.h" +#include "osal_mem.h" +#include "securec.h" #include "c_test/struct_test/v1_0/client/istruct_test.h" using namespace OHOS; using namespace testing::ext; -static struct IStructTest* g_testClient = nullptr; - -class StructTest : public testing::Test { +static const uint32_t g_arrayLen = 2; +static const int8_t g_integer8Var = 65; +static const int16_t g_integer16Var = 3; +static const int32_t g_integer32Var = 4; +static const int64_t g_integer64Var = 5; +static const uint8_t g_uInteger8Var = 97; +static const uint16_t g_uInteger16Var = 7; +static const uint32_t g_uInteger32Var = 8; +static const uint64_t g_uInteger64Var = 8; +static const float g_floatVar = 10.5; +static const double g_doubleVar = 11.55; + +static struct IStructTest *g_testClient = nullptr; + +class CStructTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(){} @@ -31,11 +43,11 @@ public: void TearDown(){} }; -void StructTest::SetUpTestCase() +void CStructTest::SetUpTestCase() { g_testClient = HdiStructTestGet(); if (g_testClient == nullptr) { - printf("StructTest: get g_testClient failed.\n"); + printf("CStructTest: get g_testClient failed.\n"); } } @@ -47,58 +59,22 @@ void TearDownTestCase() } } -HWTEST_F(StructTest, StructTest_001, TestSize.Level0) +HWTEST_F(CStructTest, CStructTest_001, TestSize.Level1) { ASSERT_NE(nullptr, g_testClient); } - -static std::string ESampleToStr(ESample obj) +HWTEST_F(CStructTest, CStructTest_002, TestSize.Level1) { - switch (obj) { - case MEM_ONE: - return "MEM_ONE"; - case MEM_TWO: - return "MEM_TWO"; - case MEM_THREE: - return "MEM_THREE"; - default: - return "unknown"; - } -} - -static void PrintSSample(const struct SSample* obj) -{ - std::cout << "{"; - std::cout << (obj->m1 ? 1 : 0) << ","; - std::cout << obj->m2 << ","; - std::cout << obj->m3 << ","; - std::cout << obj->m4; - std::cout << "}"; -} - -static void PrintUSample(const union USample* obj) -{ - std::cout << "{"; - std::cout << (obj->m1 ? 1 : 0) << ","; - std::cout << obj->m2; - std::cout << "}"; -} - -HWTEST_F(StructTest, StructTest_002, TestSize.Level0) -{ - struct SSample* srcObj = (struct SSample*)OsalMemCalloc(sizeof(struct SSample)); + struct SSample *srcObj = (struct SSample *)OsalMemCalloc(sizeof(struct SSample)); ASSERT_NE(srcObj, nullptr); srcObj->m1 = true; - srcObj->m2 = 1; - srcObj->m3 = 10.125; + srcObj->m2 = g_integer32Var; + srcObj->m3 = g_doubleVar; srcObj->m4 = strdup("hello world"); - PrintSSample(srcObj); - std::cout << "\n"; - - struct SSample* destObj = nullptr; + struct SSample *destObj = nullptr; int32_t ec = g_testClient->SSampleTest(g_testClient, srcObj, &destObj); ASSERT_EQ(ec, HDF_SUCCESS); @@ -107,51 +83,28 @@ HWTEST_F(StructTest, StructTest_002, TestSize.Level0) EXPECT_DOUBLE_EQ(srcObj->m3, destObj->m3); EXPECT_STREQ(srcObj->m4, destObj->m4); - PrintSSample(destObj); - std::cout << "\n"; - SSampleFree(srcObj, true); SSampleFree(destObj, true); } -static void PrintSSample2(const struct SSample2* obj) +HWTEST_F(CStructTest, CStructTest_003, TestSize.Level1) { - std::cout << "{"; - std::cout << (obj->m1 ? 1 : 0) << ","; - std::cout << obj->m2 << ","; - std::cout << obj->m3 << ","; - std::cout << obj->m4 << ","; - std::cout << obj->m5 << ","; - std::cout << obj->m6 << ","; - std::cout << obj->m7 << ","; - std::cout << obj->m8 << ","; - std::cout << obj->m9 << ","; - std::cout << obj->m10 << ","; - std::cout << obj->m11; - std::cout << "}"; -} - -HWTEST_F(StructTest, StructTest_003, TestSize.Level0) -{ - struct SSample2* srcObj = (struct SSample2*)OsalMemCalloc(sizeof(struct SSample2)); + struct SSample2 *srcObj = (struct SSample2 *)OsalMemCalloc(sizeof(struct SSample2)); ASSERT_NE(srcObj, nullptr); srcObj->m1 = true; - srcObj->m2 = 65; - srcObj->m3 = 10; - srcObj->m4 = 20; - srcObj->m5 = 30; - srcObj->m6 = 97; - srcObj->m7 = 100; - srcObj->m8 = 200; - srcObj->m9 = 300; - srcObj->m10 = 10.5; - srcObj->m11 = 20.125; - - PrintSSample2(srcObj); - std::cout << "\n"; - - struct SSample2* destObj = nullptr; + srcObj->m2 = g_integer8Var; + srcObj->m3 = g_integer16Var; + srcObj->m4 = g_integer32Var; + srcObj->m5 = g_integer64Var; + srcObj->m6 = g_uInteger8Var; + srcObj->m7 = g_uInteger16Var; + srcObj->m8 = g_uInteger32Var; + srcObj->m9 = g_uInteger64Var; + srcObj->m10 = g_floatVar; + srcObj->m11 = g_doubleVar; + + struct SSample2 *destObj = nullptr; int32_t ec = g_testClient->SSample2Test(g_testClient, srcObj, &destObj); ASSERT_EQ(ec, HDF_SUCCESS); @@ -167,56 +120,36 @@ HWTEST_F(StructTest, StructTest_003, TestSize.Level0) EXPECT_FLOAT_EQ(srcObj->m10, destObj->m10); EXPECT_DOUBLE_EQ(srcObj->m11, destObj->m11); - PrintSSample2(destObj); - std::cout << "\n"; - SSample2Free(srcObj, true); SSample2Free(destObj, true); } -static void PrintSSample3(const struct SSample3* obj) +HWTEST_F(CStructTest, CStructTest_004, TestSize.Level1) { - std::cout << "{"; - std::cout << obj->m1 << ", "; - std::cout << ESampleToStr(obj->m2) << ", "; - PrintSSample2(&obj->m3); - std::cout << ", "; - std::cout << obj->m4; - std::cout << "}"; -} - -HWTEST_F(StructTest, StructTest_004, TestSize.Level0) -{ - struct SSample3* srcObj = (struct SSample3*)OsalMemCalloc(sizeof(struct SSample3)); + struct SSample3 *srcObj = (struct SSample3 *)OsalMemCalloc(sizeof(struct SSample3)); ASSERT_NE(srcObj, nullptr); srcObj->m1 = strdup("hello world"); srcObj->m2 = MEM_THREE; - srcObj->m3.m1 = true; - srcObj->m3.m2 = 65; - srcObj->m3.m3 = 10; - srcObj->m3.m4 = 20; - srcObj->m3.m5 = 30; - srcObj->m3.m6 = 97; - srcObj->m3.m7 = 100; - srcObj->m3.m8 = 200; - srcObj->m3.m9 = 300; - srcObj->m3.m10 = 10.5; - srcObj->m3.m11 = 20.125; - + srcObj->m3.m2 = g_integer8Var; + srcObj->m3.m3 = g_integer16Var; + srcObj->m3.m4 = g_integer32Var; + srcObj->m3.m5 = g_integer64Var; + srcObj->m3.m6 = g_uInteger8Var; + srcObj->m3.m7 = g_uInteger16Var; + srcObj->m3.m8 = g_uInteger32Var; + srcObj->m3.m9 = g_uInteger64Var; + srcObj->m3.m10 = g_floatVar; + srcObj->m3.m11 = g_doubleVar; srcObj->m4 = open("/fdtest1.txt", O_CREAT | O_RDWR | O_TRUNC, 0644); - PrintSSample3(srcObj); - std::cout << "\n"; - - struct SSample3* destObj = nullptr; + struct SSample3 *destObj = nullptr; int32_t ec = g_testClient->SSample3Test(g_testClient, srcObj, &destObj); ASSERT_EQ(ec, HDF_SUCCESS); EXPECT_STREQ(srcObj->m1, destObj->m1); EXPECT_EQ(srcObj->m2, destObj->m2); - EXPECT_EQ((srcObj->m3.m1 ? 1 : 0), (destObj->m3.m1 ? 1 : 0)); EXPECT_EQ(srcObj->m3.m2, destObj->m3.m2); EXPECT_EQ(srcObj->m3.m3, destObj->m3.m3); @@ -228,207 +161,116 @@ HWTEST_F(StructTest, StructTest_004, TestSize.Level0) EXPECT_EQ(srcObj->m3.m9, destObj->m3.m9); EXPECT_FLOAT_EQ(srcObj->m3.m10, destObj->m3.m10); EXPECT_DOUBLE_EQ(srcObj->m3.m11, destObj->m3.m11); - - PrintSSample3(destObj); - std::cout << "\n"; - SSample3Free(srcObj, true); SSample3Free(destObj, true); } -static void PrintSSample4(const struct SSample4* obj) +static void SSample4Part1Init(struct SSample4 *srcObj) { - std::cout << "{"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m1Len; i++) { - std::cout << (obj->m1[i] ? 1 : 0) << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m2Len; i++) { - std::cout << obj->m2[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m3Len; i++) { - std::cout << obj->m3[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m4Len; i++) { - std::cout << obj->m4[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m5Len; i++) { - std::cout << obj->m5[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m6Len; i++) { - std::cout << obj->m6[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m7Len; i++) { - std::cout << obj->m7[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m8Len; i++) { - std::cout << obj->m8[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m9Len; i++) { - std::cout << obj->m9[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m10Len; i++) { - std::cout << obj->m10[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m11Len; i++) { - std::cout << obj->m11[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m12Len; i++) { - std::cout << obj->m12[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m13Len; i++) { - std::cout << ESampleToStr(obj->m13[i]) << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m14Len; i++) { - PrintSSample(&(obj->m14[i])); - std::cout << ","; - } - std::cout << "}"; - - std::cout << "}\n"; -} - -HWTEST_F(StructTest, StructTest_005, TestSize.Level0) -{ - struct SSample4* srcObj = (struct SSample4*)OsalMemCalloc(sizeof(struct SSample4)); - ASSERT_NE(srcObj, nullptr); - - srcObj->m1Len = 2; - srcObj->m1 = (bool*)OsalMemCalloc(sizeof(bool) * srcObj->m1Len); + srcObj->m1Len = g_arrayLen; + srcObj->m1 = (bool*)OsalMemCalloc(sizeof(bool) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m1Len; i++) { srcObj->m1[i] = true; } - srcObj->m2Len = 2; - srcObj->m2 = (int8_t*)OsalMemCalloc(sizeof(int8_t) * srcObj->m2Len); + srcObj->m2Len = g_arrayLen; + srcObj->m2 = (int8_t*)OsalMemCalloc(sizeof(int8_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m2Len; i++) { - srcObj->m2[i] = 65; + srcObj->m2[i] = g_integer8Var; } - srcObj->m3Len = 2; - srcObj->m3 = (int16_t*)OsalMemCalloc(sizeof(int16_t) * srcObj->m3Len); + srcObj->m3Len = g_arrayLen; + srcObj->m3 = (int16_t*)OsalMemCalloc(sizeof(int16_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m3Len; i++) { - srcObj->m3[i] = 3; + srcObj->m3[i] = g_integer16Var; } - srcObj->m4Len = 2; - srcObj->m4 = (int32_t*)OsalMemCalloc(sizeof(int32_t) * srcObj->m4Len); + srcObj->m4Len = g_arrayLen; + srcObj->m4 = (int32_t*)OsalMemCalloc(sizeof(int32_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m4Len; i++) { - srcObj->m4[i] = 4; + srcObj->m4[i] = g_integer32Var; } - srcObj->m5Len = 2; - srcObj->m5 = (int64_t*)OsalMemCalloc(sizeof(int64_t) * srcObj->m5Len); + srcObj->m5Len = g_arrayLen; + srcObj->m5 = (int64_t*)OsalMemCalloc(sizeof(int64_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m5Len; i++) { - srcObj->m5[i] = 5; + srcObj->m5[i] = g_integer64Var; } +} - srcObj->m6Len = 2; - srcObj->m6 = (uint8_t*)OsalMemCalloc(sizeof(uint8_t) * srcObj->m6Len); +static void SSample4Part2Init(struct SSample4 *srcObj) +{ + srcObj->m6Len = g_arrayLen; + srcObj->m6 = (uint8_t*)OsalMemCalloc(sizeof(uint8_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m6Len; i++) { - srcObj->m6[i] = 97; + srcObj->m6[i] = g_uInteger8Var; } - srcObj->m7Len = 2; - srcObj->m7 = (uint16_t*)OsalMemCalloc(sizeof(uint16_t) * srcObj->m7Len); + srcObj->m7Len = g_arrayLen; + srcObj->m7 = (uint16_t*)OsalMemCalloc(sizeof(uint16_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m7Len; i++) { - srcObj->m7[i] = 7; + srcObj->m7[i] = g_uInteger16Var; } - srcObj->m8Len = 2; - srcObj->m8 = (uint32_t*)OsalMemCalloc(sizeof(uint32_t) * srcObj->m8Len); + srcObj->m8Len = g_arrayLen; + srcObj->m8 = (uint32_t*)OsalMemCalloc(sizeof(uint32_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m8Len; i++) { - srcObj->m8[i] = 8; + srcObj->m8[i] = g_uInteger32Var; } - srcObj->m9Len = 2; - srcObj->m9 = (uint64_t*)OsalMemCalloc(sizeof(uint64_t) * srcObj->m9Len); + srcObj->m9Len = g_arrayLen; + srcObj->m9 = (uint64_t*)OsalMemCalloc(sizeof(uint64_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m9Len; i++) { - srcObj->m9[i] = 9; + srcObj->m9[i] = g_uInteger64Var; } - srcObj->m10Len = 2; - srcObj->m10 = (float*)OsalMemCalloc(sizeof(float) * srcObj->m10Len); + srcObj->m10Len = g_arrayLen; + srcObj->m10 = (float*)OsalMemCalloc(sizeof(float) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m10Len; i++) { - srcObj->m10[i] = 10.5; + srcObj->m10[i] = g_floatVar; } - srcObj->m11Len = 2; - srcObj->m11 = (double*)OsalMemCalloc(sizeof(double) * srcObj->m11Len); + srcObj->m11Len = g_arrayLen; + srcObj->m11 = (double*)OsalMemCalloc(sizeof(double) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m11Len; i++) { - srcObj->m11[i] = 11.55; + srcObj->m11[i] = g_doubleVar; } +} - srcObj->m12Len = 2; - srcObj->m12 = (char**)OsalMemCalloc(sizeof(char*) * srcObj->m12Len); +static void SSample4Part3Init(struct SSample4 *srcObj) +{ + srcObj->m12Len = g_arrayLen; + srcObj->m12 = (char**)OsalMemCalloc(sizeof(char *) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m12Len; i++) { - const char* str = "hello world"; + const char *str = "hello world"; srcObj->m12[i] = strdup(str); } - srcObj->m13Len = 2; - srcObj->m13 = (enum ESample*)OsalMemCalloc(sizeof(enum ESample) * srcObj->m13Len); + srcObj->m13Len = g_arrayLen; + srcObj->m13 = (enum ESample *)OsalMemCalloc(sizeof(enum ESample) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m13Len; i++) { srcObj->m13[i] = MEM_ONE; } - srcObj->m14Len = 2; - srcObj->m14 = (struct SSample*)OsalMemCalloc(sizeof(struct SSample) * srcObj->m14Len); + srcObj->m14Len = g_arrayLen; + srcObj->m14 = (struct SSample*)OsalMemCalloc(sizeof(struct SSample) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m14Len; i++) { srcObj->m14[i].m1 = true; - srcObj->m14[i].m2 = 2; - srcObj->m14[i].m3 = 3.55; + srcObj->m14[i].m2 = g_integer32Var; + srcObj->m14[i].m3 = g_doubleVar; srcObj->m14[i].m4 = strdup("hello"); } +} - PrintSSample4(srcObj); - std::cout << "\n"; - - struct SSample4* destObj = nullptr; - int32_t ec = g_testClient->SSample4Test(g_testClient, srcObj, &destObj); - ASSERT_EQ(ec, HDF_SUCCESS); - +static void SSample4Init(struct SSample4 *srcObj) +{ + SSample4Part1Init(srcObj); + SSample4Part2Init(srcObj); + SSample4Part3Init(srcObj); +} +static void CompareSSample4Part1(const struct SSample4 *srcObj, const struct SSample4 *destObj) +{ for (uint32_t i = 0; i < srcObj->m1Len; i++) { EXPECT_EQ((srcObj->m1[i] ? 1 : 0), (destObj->m1[i] ? 1 : 0)); } @@ -448,7 +290,10 @@ HWTEST_F(StructTest, StructTest_005, TestSize.Level0) for (uint32_t i = 0; i < srcObj->m5Len; i++) { EXPECT_EQ(srcObj->m5[i], destObj->m5[i]); } +} +static void CompareSSample4Part2(const struct SSample4 *srcObj, const struct SSample4 *destObj) +{ for (uint32_t i = 0; i < srcObj->m6Len; i++) { EXPECT_EQ(srcObj->m6[i], destObj->m6[i]); } @@ -472,7 +317,10 @@ HWTEST_F(StructTest, StructTest_005, TestSize.Level0) for (uint32_t i = 0; i < srcObj->m11Len; i++) { EXPECT_DOUBLE_EQ(srcObj->m11[i], destObj->m11[i]); } +} +static void CompareSSample4Part3(const struct SSample4 *srcObj, const struct SSample4 *destObj) +{ for (uint32_t i = 0; i < srcObj->m12Len; i++) { EXPECT_STREQ(srcObj->m12[i], destObj->m12[i]); } @@ -487,206 +335,138 @@ HWTEST_F(StructTest, StructTest_005, TestSize.Level0) EXPECT_DOUBLE_EQ((srcObj->m14[i]).m3, (destObj->m14[i]).m3); EXPECT_STREQ((srcObj->m14[i]).m4, (destObj->m14[i]).m4); } - - PrintSSample4(destObj); - std::cout << "\n"; - - SSample4Free(srcObj, true); - SSample4Free(destObj, true); } -static void PrintSSample5(const struct SSample5* obj) +static void CompareSSample4(const struct SSample4 *srcObj, const struct SSample4 *destObj) { - std::cout << "{"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m1Len; i++) { - std::cout << (obj->m1[i] ? 1 : 0) << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m2Len; i++) { - std::cout << obj->m2[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m3Len; i++) { - std::cout << obj->m3[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m4Len; i++) { - std::cout << obj->m4[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m5Len; i++) { - std::cout << obj->m5[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m6Len; i++) { - std::cout << obj->m6[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m7Len; i++) { - std::cout << obj->m7[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m8Len; i++) { - std::cout << obj->m8[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m9Len; i++) { - std::cout << obj->m9[i] << ","; - } - std::cout << "},"; - - std::cout << "{"; - for (uint32_t i = 0; i < obj->m10Len; i++) { - std::cout << obj->m10[i] << ","; - } - std::cout << "},"; + CompareSSample4Part1(srcObj, destObj); + CompareSSample4Part2(srcObj, destObj); + CompareSSample4Part3(srcObj, destObj); +} - std::cout << "{"; - for (uint32_t i = 0; i < obj->m11Len; i++) { - std::cout << obj->m11[i] << ","; - } - std::cout << "},"; +HWTEST_F(CStructTest, CStructTest_005, TestSize.Level1) +{ + struct SSample4 *srcObj = (struct SSample4*)OsalMemCalloc(sizeof(struct SSample4)); + ASSERT_NE(srcObj, nullptr); - std::cout << "{"; - for (uint32_t i = 0; i < obj->m12Len; i++) { - std::cout << obj->m12[i] << ","; - } - std::cout << "},"; + SSample4Init(srcObj); - std::cout << "{"; - for (uint32_t i = 0; i < obj->m13Len; i++) { - std::cout << ESampleToStr(obj->m13[i]) << ","; - } - std::cout << "},"; + struct SSample4 *destObj = nullptr; + int32_t ec = g_testClient->SSample4Test(g_testClient, srcObj, &destObj); + ASSERT_EQ(ec, HDF_SUCCESS); - std::cout << "{"; - for (uint32_t i = 0; i < obj->m14Len; i++) { - PrintSSample(&(obj->m14[i])); - std::cout << ","; - } - std::cout << "},"; + CompareSSample4(srcObj, destObj); - std::cout << "}\n"; + SSample4Free(srcObj, true); + SSample4Free(destObj, true); } -HWTEST_F(StructTest, StructTest_006, TestSize.Level0) +static void SSample5Part1Init(struct SSample4 *srcObj) { - struct SSample5* srcObj = (struct SSample5*)OsalMemCalloc(sizeof(struct SSample5)); - ASSERT_NE(srcObj, nullptr); - - srcObj->m1Len = 2; - srcObj->m1 = (bool*)OsalMemCalloc(sizeof(bool) * srcObj->m1Len); + srcObj->m1Len = g_arrayLen; + srcObj->m1 = (bool*)OsalMemCalloc(sizeof(bool) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m1Len; i++) { srcObj->m1[i] = true; } - srcObj->m2Len = 2; - srcObj->m2 = (int8_t*)OsalMemCalloc(sizeof(int8_t) * srcObj->m2Len); + srcObj->m2Len = g_arrayLen; + srcObj->m2 = (int8_t*)OsalMemCalloc(sizeof(int8_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m2Len; i++) { - srcObj->m2[i] = 65; + srcObj->m2[i] = g_integer8Var; } - srcObj->m3Len = 2; - srcObj->m3 = (int16_t*)OsalMemCalloc(sizeof(int16_t) * srcObj->m3Len); + srcObj->m3Len = g_arrayLen; + srcObj->m3 = (int16_t*)OsalMemCalloc(sizeof(int16_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m3Len; i++) { - srcObj->m3[i] = 3; + srcObj->m3[i] = g_integer16Var; } - srcObj->m4Len = 2; - srcObj->m4 = (int32_t*)OsalMemCalloc(sizeof(int32_t) * srcObj->m4Len); + srcObj->m4Len = g_arrayLen; + srcObj->m4 = (int32_t*)OsalMemCalloc(sizeof(int32_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m4Len; i++) { - srcObj->m4[i] = 4; + srcObj->m4[i] = g_integer32Var; } - srcObj->m5Len = 2; - srcObj->m5 = (int64_t*)OsalMemCalloc(sizeof(int64_t) * srcObj->m5Len); + srcObj->m5Len = g_arrayLen; + srcObj->m5 = (int64_t*)OsalMemCalloc(sizeof(int64_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m5Len; i++) { - srcObj->m5[i] = 5; + srcObj->m5[i] = g_integer64Var; } +} - srcObj->m6Len = 2; - srcObj->m6 = (uint8_t*)OsalMemCalloc(sizeof(uint8_t) * srcObj->m6Len); +static void SSample5Part2Init(struct SSample4 *srcObj) +{ + srcObj->m6Len = g_arrayLen; + srcObj->m6 = (uint8_t*)OsalMemCalloc(sizeof(uint8_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m6Len; i++) { - srcObj->m6[i] = 97; + srcObj->m6[i] = g_uInteger8Var; } - srcObj->m7Len = 2; - srcObj->m7 = (uint16_t*)OsalMemCalloc(sizeof(uint16_t) * srcObj->m7Len); + srcObj->m7Len = g_arrayLen; + srcObj->m7 = (uint16_t*)OsalMemCalloc(sizeof(uint16_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m7Len; i++) { - srcObj->m7[i] = 7; + srcObj->m7[i] = g_uInteger16Var; } - srcObj->m8Len = 2; - srcObj->m8 = (uint32_t*)OsalMemCalloc(sizeof(uint32_t) * srcObj->m8Len); + srcObj->m8Len = g_arrayLen; + srcObj->m8 = (uint32_t*)OsalMemCalloc(sizeof(uint32_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m8Len; i++) { - srcObj->m8[i] = 8; + srcObj->m8[i] = g_uInteger32Var; } - srcObj->m9Len = 2; - srcObj->m9 = (uint64_t*)OsalMemCalloc(sizeof(uint64_t) * srcObj->m9Len); + srcObj->m9Len = g_arrayLen; + srcObj->m9 = (uint64_t*)OsalMemCalloc(sizeof(uint64_t) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m9Len; i++) { - srcObj->m9[i] = 9; + srcObj->m9[i] = g_uInteger64Var; } - srcObj->m10Len = 2; - srcObj->m10 = (float*)OsalMemCalloc(sizeof(float) * srcObj->m10Len); + srcObj->m10Len = g_arrayLen; + srcObj->m10 = (float*)OsalMemCalloc(sizeof(float) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m10Len; i++) { - srcObj->m10[i] = 10.5; + srcObj->m10[i] = g_floatVar; } - srcObj->m11Len = 2; - srcObj->m11 = (double*)OsalMemCalloc(sizeof(double) * srcObj->m11Len); + srcObj->m11Len = g_arrayLen; + srcObj->m11 = (double*)OsalMemCalloc(sizeof(double) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m11Len; i++) { - srcObj->m11[i] = 11.55; + srcObj->m11[i] = g_doubleVar; } +} - srcObj->m12Len = 2; - srcObj->m12 = (char**)OsalMemCalloc(sizeof(char*) * srcObj->m12Len); +static void SSample5Part3Init(struct SSample4 *srcObj) +{ + srcObj->m12Len = g_arrayLen; + srcObj->m12 = (char**)OsalMemCalloc(sizeof(char *) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m12Len; i++) { - const char* str = "hello world"; + const char *str = "hello world"; srcObj->m12[i] = strdup(str); } - srcObj->m13Len = 2; - srcObj->m13 = (enum ESample*)OsalMemCalloc(sizeof(enum ESample) * srcObj->m13Len); + srcObj->m13Len = g_arrayLen; + srcObj->m13 = (enum ESample *)OsalMemCalloc(sizeof(enum ESample) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m13Len; i++) { srcObj->m13[i] = MEM_ONE; } - srcObj->m14Len = 2; - srcObj->m14 = (struct SSample*)OsalMemCalloc(sizeof(struct SSample) * srcObj->m14Len); + srcObj->m14Len = g_arrayLen; + srcObj->m14 = (struct SSample*)OsalMemCalloc(sizeof(struct SSample) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m14Len; i++) { srcObj->m14[i].m1 = true; - srcObj->m14[i].m2 = 2; - srcObj->m14[i].m3 = 3.55; + srcObj->m14[i].m2 = g_integer32Var; + srcObj->m14[i].m3 = g_doubleVar; srcObj->m14[i].m4 = strdup("hello"); } +} - PrintSSample5(srcObj); - std::cout << "\n"; - - struct SSample5* destObj = nullptr; - int32_t ec = g_testClient->SSample5Test(g_testClient, srcObj, &destObj); - ASSERT_EQ(ec, HDF_SUCCESS); +static void SSample5Init(struct SSample5 *srcObj) +{ + SSample5Part1Init(srcObj); + SSample5Part2Init(srcObj); + SSample5Part3Init(srcObj); +} +static void CompareSSample5Part1(const struct SSample5 *srcObj, const struct SSample5 *destObj) +{ for (uint32_t i = 0; i < srcObj->m1Len; i++) { EXPECT_EQ((srcObj->m1[i] ? 1 : 0), (destObj->m1[i] ? 1 : 0)); } @@ -706,7 +486,10 @@ HWTEST_F(StructTest, StructTest_006, TestSize.Level0) for (uint32_t i = 0; i < srcObj->m5Len; i++) { EXPECT_EQ(srcObj->m5[i], destObj->m5[i]); } +} +static void CompareSSample5Part2(const struct SSample5 *srcObj, const struct SSample5 *destObj) +{ for (uint32_t i = 0; i < srcObj->m6Len; i++) { EXPECT_EQ(srcObj->m6[i], destObj->m6[i]); } @@ -730,7 +513,10 @@ HWTEST_F(StructTest, StructTest_006, TestSize.Level0) for (uint32_t i = 0; i < srcObj->m11Len; i++) { EXPECT_DOUBLE_EQ(srcObj->m11[i], destObj->m11[i]); } +} +static void CompareSSample5Part3(const struct SSample5 *srcObj, const struct SSample5 *destObj) +{ for (uint32_t i = 0; i < srcObj->m12Len; i++) { EXPECT_STREQ(srcObj->m12[i], destObj->m12[i]); } @@ -745,62 +531,55 @@ HWTEST_F(StructTest, StructTest_006, TestSize.Level0) EXPECT_DOUBLE_EQ((srcObj->m14[i]).m3, (destObj->m14[i]).m3); EXPECT_STREQ((srcObj->m14[i]).m4, (destObj->m14[i]).m4); } +} - PrintSSample5(destObj); - std::cout << "\n"; - - SSample5Free(srcObj, true); - SSample5Free(destObj, true); +static void CompareSSample5(const struct SSample5 *srcObj, const struct SSample5 *destObj) +{ + CompareSSample5Part1(srcObj, destObj); + CompareSSample5Part2(srcObj, destObj); + CompareSSample5Part3(srcObj, destObj); } -static void PrintSSample6(const struct SSample6* obj) +HWTEST_F(CStructTest, CStructTest_006, TestSize.Level1) { - std::cout << "{"; + struct SSample5 *srcObj = (struct SSample5*)OsalMemCalloc(sizeof(struct SSample5)); + ASSERT_NE(srcObj, nullptr); - PrintUSample(&obj->m1); - std::cout << ",\n"; + SSample5Init(srcObj); - std::cout << "{"; - for (uint32_t i = 0; i < obj->m2Len; i++) { - PrintUSample(&obj->m2[i]); - } - std::cout << "},"; + struct SSample5 *destObj = nullptr; + int32_t ec = g_testClient->SSample5Test(g_testClient, srcObj, &destObj); + ASSERT_EQ(ec, HDF_SUCCESS); - std::cout << "{"; - for (uint32_t i = 0; i < obj->m3Len; i++) { - PrintUSample(&obj->m3[i]); - } - std::cout << "}"; + CompareSSample5(srcObj, destObj); - std::cout << "}"; + SSample5Free(srcObj, true); + SSample5Free(destObj, true); } -HWTEST_F(StructTest, StructTest_007, TestSize.Level0) +HWTEST_F(CStructTest, CStructTest_007, TestSize.Level1) { - struct SSample6* srcObj = (struct SSample6*)OsalMemCalloc(sizeof(struct SSample6)); + struct SSample6 *srcObj = (struct SSample6 *)OsalMemCalloc(sizeof(struct SSample6)); ASSERT_NE(srcObj, nullptr); srcObj->m1.m1 = true; - srcObj->m1.m2 = 1; + srcObj->m1.m2 = g_integer32Var; - srcObj->m2Len = 2; - srcObj->m2 = (union USample*)OsalMemCalloc(sizeof(union USample) * srcObj->m2Len); + srcObj->m2Len = g_arrayLen; + srcObj->m2 = (union USample*)OsalMemCalloc(sizeof(union USample) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m2Len; i++) { (srcObj->m2[i]).m1 = true; (srcObj->m2[i]).m2 = 2; } - srcObj->m3Len = 2; - srcObj->m3 = (union USample*)OsalMemCalloc(sizeof(union USample) * srcObj->m3Len); + srcObj->m3Len = g_arrayLen; + srcObj->m3 = (union USample*)OsalMemCalloc(sizeof(union USample) * g_arrayLen); for (uint32_t i = 0; i < srcObj->m3Len; i++) { (srcObj->m3[i]).m1 = true; (srcObj->m3[i]).m2 = 2; } - PrintSSample6(srcObj); - std::cout << "\n"; - - struct SSample6* destObj = nullptr; + struct SSample6 *destObj = nullptr; int32_t ec = g_testClient->SSample6Test(g_testClient, srcObj, &destObj); ASSERT_EQ(ec, HDF_SUCCESS); @@ -817,9 +596,6 @@ HWTEST_F(StructTest, StructTest_007, TestSize.Level0) EXPECT_EQ((srcObj->m3[i]).m2, (destObj->m3[i]).m2); } - PrintSSample6(destObj); - std::cout << "\n"; - SSample6Free(srcObj, true); SSample6Free(destObj, true); } diff --git a/tools/hdi-gen/test/cpp_test/array_test/v1_0/cpp_array_test.cpp b/tools/hdi-gen/test/cpp_test/array_test/v1_0/cpp_array_test.cpp index f89d97475436b8ebbee6a0352264c6ce1dda4501..589d4292ce78dc249b7402d3d9dd4f80cb392361 100755 --- a/tools/hdi-gen/test/cpp_test/array_test/v1_0/cpp_array_test.cpp +++ b/tools/hdi-gen/test/cpp_test/array_test/v1_0/cpp_array_test.cpp @@ -8,14 +8,14 @@ #include #include +#include +#include +#include #include #include -#include -#include -#include -#include -#include -#include +#include "hdf_log.h" +#include "osal_mem.h" +#include "securec.h" #include "test/cpp_test/array_test/v1_0/client/array_test_proxy.h" using namespace OHOS; @@ -25,7 +25,7 @@ using namespace test::cpp_test::types::v1_0; static sptr g_testClient = nullptr; -class ArrayTest : public testing::Test { +class CppArrayTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(){} @@ -33,20 +33,20 @@ public: void TearDown(){} }; -void ArrayTest::SetUpTestCase() +void CppArrayTest::SetUpTestCase() { g_testClient = IArrayTest::Get(); if (g_testClient == nullptr) { - printf("ArrayTest: get g_testClient failed.\n"); + printf("CppArrayTest: get g_testClient failed.\n"); } } -HWTEST_F(ArrayTest, ArrayTest_001, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_001, TestSize.Level1) { ASSERT_NE(nullptr, g_testClient); } -HWTEST_F(ArrayTest, ArrayTest_002, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_002, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -70,7 +70,7 @@ HWTEST_F(ArrayTest, ArrayTest_002, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_003, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_003, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -90,7 +90,7 @@ HWTEST_F(ArrayTest, ArrayTest_003, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_004, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_004, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -110,7 +110,7 @@ HWTEST_F(ArrayTest, ArrayTest_004, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_005, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_005, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -130,7 +130,7 @@ HWTEST_F(ArrayTest, ArrayTest_005, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_006, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_006, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -150,7 +150,7 @@ HWTEST_F(ArrayTest, ArrayTest_006, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_007, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_007, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -170,7 +170,7 @@ HWTEST_F(ArrayTest, ArrayTest_007, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_008, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_008, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -190,7 +190,7 @@ HWTEST_F(ArrayTest, ArrayTest_008, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_009, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_009, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -210,7 +210,7 @@ HWTEST_F(ArrayTest, ArrayTest_009, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_010, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_010, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -230,7 +230,7 @@ HWTEST_F(ArrayTest, ArrayTest_010, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_011, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_011, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -250,7 +250,7 @@ HWTEST_F(ArrayTest, ArrayTest_011, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_012, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_012, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -270,7 +270,7 @@ HWTEST_F(ArrayTest, ArrayTest_012, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_013, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_013, TestSize.Level1) { uint32_t len = 2; std::vector inParam; @@ -290,10 +290,10 @@ HWTEST_F(ArrayTest, ArrayTest_013, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_014, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_014, TestSize.Level1) { - int fd1 = open("/ArrayTest_014_0.txt", O_CREAT | O_RDWR | O_TRUNC, 0644); - int fd2 = open("/ArrayTest_014_1.txt", O_CREAT | O_RDWR | O_TRUNC, 0644); + int fd1 = open("/CppArrayTest_014_0.txt", O_CREAT | O_RDWR | O_TRUNC, 0644); + int fd2 = open("/CppArrayTest_014_1.txt", O_CREAT | O_RDWR | O_TRUNC, 0644); ASSERT_NE(fd1, -1); ASSERT_NE(fd2, -1); @@ -314,7 +314,7 @@ HWTEST_F(ArrayTest, ArrayTest_014, TestSize.Level0) close(fd2); } -HWTEST_F(ArrayTest, ArrayTest_015, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_015, TestSize.Level1) { uint32_t len = 2; std::vector inParam; @@ -334,7 +334,7 @@ HWTEST_F(ArrayTest, ArrayTest_015, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_016, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_016, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -362,7 +362,7 @@ HWTEST_F(ArrayTest, ArrayTest_016, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_017, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_017, TestSize.Level1) { uint32_t len = 2; std::vector inParam; @@ -385,7 +385,7 @@ HWTEST_F(ArrayTest, ArrayTest_017, TestSize.Level0) } } -HWTEST_F(ArrayTest, ArrayTest_018, TestSize.Level0) +HWTEST_F(CppArrayTest, CppArrayTest_018, TestSize.Level1) { std::vector> inParam = { sptr(new SequenceData(1, 1.2, "hello")), diff --git a/tools/hdi-gen/test/cpp_test/cb_test/v1_0/cpp_cb_test.cpp b/tools/hdi-gen/test/cpp_test/cb_test/v1_0/cpp_cb_test.cpp index 658522b77456dfa9cb8964e5cf5b10f4e896f2e8..87e48b6c0d09ee3d878738281c541042f3e1a468 100755 --- a/tools/hdi-gen/test/cpp_test/cb_test/v1_0/cpp_cb_test.cpp +++ b/tools/hdi-gen/test/cpp_test/cb_test/v1_0/cpp_cb_test.cpp @@ -9,9 +9,9 @@ #include #include #include -#include -#include -#include +#include "hdf_log.h" +#include "osal_mem.h" +#include "securec.h" #include "test/cpp_test/cb_test/v1_0/client/cb_test_proxy.h" using namespace OHOS; @@ -24,7 +24,7 @@ static sptr g_testClient = nullptr; static sptr g_callbackObj = nullptr; -class CbTest : public testing::Test { +class CppCbTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(){} @@ -32,24 +32,24 @@ public: void TearDown(){} }; -void CbTest::SetUpTestCase() +void CppCbTest::SetUpTestCase() { g_testClient = ICbTest::Get(); if (g_testClient == nullptr) { - printf("CbTest: get g_testClient failed.\n"); + printf("CppCbTest: get g_testClient failed.\n"); } g_callbackObj = new CallbackService(); if (g_callbackObj == nullptr) { - printf("CbTest: get g_callbackObj failed.\n"); + printf("CppCbTest: get g_callbackObj failed.\n"); } } -HWTEST_F(CbTest, CbTest_001, TestSize.Level0) +HWTEST_F(CppCbTest, CppCbTest_001, TestSize.Level1) { ASSERT_NE(nullptr, g_testClient); } -HWTEST_F(CbTest, CbTest_002, TestSize.Level0) +HWTEST_F(CppCbTest, CppCbTest_002, TestSize.Level1) { int32_t ec = g_testClient->CallbackTest(g_callbackObj); ASSERT_EQ(ec, HDF_SUCCESS); diff --git a/tools/hdi-gen/test/cpp_test/data_test/v1_0/cpp_data_test.cpp b/tools/hdi-gen/test/cpp_test/data_test/v1_0/cpp_data_test.cpp index 4669a6f82611011f24ff1a2db65c2d2fc165c467..fbe6c0160ae02bf78a1bb33a79c7be6155744572 100755 --- a/tools/hdi-gen/test/cpp_test/data_test/v1_0/cpp_data_test.cpp +++ b/tools/hdi-gen/test/cpp_test/data_test/v1_0/cpp_data_test.cpp @@ -8,14 +8,14 @@ #include #include +#include +#include +#include #include #include -#include -#include -#include -#include -#include -#include +#include "hdf_log.h" +#include "osal_mem.h" +#include "securec.h" #include "cpp_test/data_test/v1_0/client/data_test_proxy.h" using namespace OHOS; @@ -25,7 +25,7 @@ using namespace test::cpp_test::types::v1_0; static sptr g_testClient = nullptr; -class DataTest : public testing::Test { +class CppDataTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(){} @@ -33,20 +33,20 @@ public: void TearDown(){} }; -void DataTest::SetUpTestCase() +void CppDataTest::SetUpTestCase() { g_testClient = IDataTest::Get(); if (g_testClient == nullptr) { - printf("DataTest: get g_testClient failed.\n"); + printf("CppDataTest: get g_testClient failed.\n"); } } -HWTEST_F(DataTest, DataTest_001, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_001, TestSize.Level1) { ASSERT_NE(nullptr, g_testClient); } -HWTEST_F(DataTest, DataTest_002, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_002, TestSize.Level1) { bool inParam = true; bool outParam = false; @@ -57,7 +57,7 @@ HWTEST_F(DataTest, DataTest_002, TestSize.Level0) EXPECT_TRUE(outParam); } -HWTEST_F(DataTest, DataTest_003, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_003, TestSize.Level1) { int8_t inParam = 10; int8_t outParam = 0; @@ -68,7 +68,7 @@ HWTEST_F(DataTest, DataTest_003, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_004, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_004, TestSize.Level1) { int16_t inParam = 10; int16_t outParam = 0; @@ -79,7 +79,7 @@ HWTEST_F(DataTest, DataTest_004, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_005, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_005, TestSize.Level1) { int32_t inParam = 10; int32_t outParam = 0; @@ -90,7 +90,7 @@ HWTEST_F(DataTest, DataTest_005, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_006, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_006, TestSize.Level1) { int64_t inParam = 10; int64_t outParam = 0; @@ -101,7 +101,7 @@ HWTEST_F(DataTest, DataTest_006, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_007, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_007, TestSize.Level1) { uint8_t inParam = 10; uint8_t outParam = 0; @@ -112,7 +112,7 @@ HWTEST_F(DataTest, DataTest_007, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_008, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_008, TestSize.Level1) { uint16_t inParam = 10; uint16_t outParam = 0; @@ -123,7 +123,7 @@ HWTEST_F(DataTest, DataTest_008, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_009, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_009, TestSize.Level1) { uint32_t inParam = 10; uint32_t outParam = 0; @@ -134,7 +134,7 @@ HWTEST_F(DataTest, DataTest_009, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_010, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_010, TestSize.Level1) { uint64_t inParam = 10; uint64_t outParam = 0; @@ -145,7 +145,7 @@ HWTEST_F(DataTest, DataTest_010, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_011, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_011, TestSize.Level1) { float inParam = 10.5; float outParam = 0; @@ -156,7 +156,7 @@ HWTEST_F(DataTest, DataTest_011, TestSize.Level0) EXPECT_FLOAT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_012, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_012, TestSize.Level1) { double inParam = 10.5; double outParam = 0; @@ -167,7 +167,7 @@ HWTEST_F(DataTest, DataTest_012, TestSize.Level0) EXPECT_DOUBLE_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_013, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_013, TestSize.Level1) { std::string inParam("hello"); std::string outParam; @@ -178,7 +178,7 @@ HWTEST_F(DataTest, DataTest_013, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_014, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_014, TestSize.Level1) { int fd = open("/cpp_data_test_014.txt", O_CREAT | O_RDWR | O_TRUNC, 0644); printf("file open, fd = %d\n", fd); @@ -210,7 +210,7 @@ finished: close(fd); } -HWTEST_F(DataTest, DataTest_015, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_015, TestSize.Level1) { ESample inParam = ESample::MEM_ONE; ESample outParam = ESample::MEM_TWO; @@ -221,7 +221,7 @@ HWTEST_F(DataTest, DataTest_015, TestSize.Level0) EXPECT_EQ(inParam, outParam); } -HWTEST_F(DataTest, DataTest_016, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_016, TestSize.Level1) { SSample inParam; inParam.m1 = true; @@ -240,7 +240,7 @@ HWTEST_F(DataTest, DataTest_016, TestSize.Level0) EXPECT_EQ(inParam.m4, outParam.m4); } -HWTEST_F(DataTest, DataTest_017, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_017, TestSize.Level1) { USample inParam; inParam.m2 = 10; @@ -254,7 +254,7 @@ HWTEST_F(DataTest, DataTest_017, TestSize.Level0) EXPECT_DOUBLE_EQ(inParam.m2, outParam.m2); } -HWTEST_F(DataTest, DataTest_018, TestSize.Level0) +HWTEST_F(CppDataTest, CppDataTest_018, TestSize.Level1) { sptr inParam(new SequenceData(1, 1.2, "hello")); diff --git a/tools/hdi-gen/test/cpp_test/list_test/v1_0/cpp_list_test.cpp b/tools/hdi-gen/test/cpp_test/list_test/v1_0/cpp_list_test.cpp index 2d3a11a147d52dbba26248d317d6c1cd63d902f9..4fb130400f7be800be5108d2d2b7dc396e81dc2d 100755 --- a/tools/hdi-gen/test/cpp_test/list_test/v1_0/cpp_list_test.cpp +++ b/tools/hdi-gen/test/cpp_test/list_test/v1_0/cpp_list_test.cpp @@ -8,14 +8,14 @@ #include #include +#include +#include +#include #include #include -#include -#include -#include -#include -#include -#include +#include "hdf_log.h" +#include "osal_mem.h" +#include "securec.h" #include "test/cpp_test/list_test/v1_0/client/list_test_proxy.h" using namespace OHOS; @@ -25,7 +25,7 @@ using namespace test::cpp_test::types::v1_0; static sptr g_testClient = nullptr; -class ListTest : public testing::Test { +class CppListTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(){} @@ -33,20 +33,20 @@ public: void TearDown(){} }; -void ListTest::SetUpTestCase() +void CppListTest::SetUpTestCase() { g_testClient = IListTest::Get(); if (g_testClient == nullptr) { - printf("ListTest: get g_testClient failed.\n"); + printf("CppListTest: get g_testClient failed.\n"); } } -HWTEST_F(ListTest, ListTest_001, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_001, TestSize.Level1) { ASSERT_NE(nullptr, g_testClient); } -HWTEST_F(ListTest, ListTest_002, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_002, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -70,7 +70,7 @@ HWTEST_F(ListTest, ListTest_002, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_003, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_003, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -90,7 +90,7 @@ HWTEST_F(ListTest, ListTest_003, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_004, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_004, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -110,7 +110,7 @@ HWTEST_F(ListTest, ListTest_004, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_005, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_005, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -130,7 +130,7 @@ HWTEST_F(ListTest, ListTest_005, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_006, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_006, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -150,7 +150,7 @@ HWTEST_F(ListTest, ListTest_006, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_007, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_007, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -170,7 +170,7 @@ HWTEST_F(ListTest, ListTest_007, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_008, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_008, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -190,7 +190,7 @@ HWTEST_F(ListTest, ListTest_008, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_009, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_009, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -210,7 +210,7 @@ HWTEST_F(ListTest, ListTest_009, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_010, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_010, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -230,7 +230,7 @@ HWTEST_F(ListTest, ListTest_010, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_011, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_011, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -250,7 +250,7 @@ HWTEST_F(ListTest, ListTest_011, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_012, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_012, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -270,7 +270,7 @@ HWTEST_F(ListTest, ListTest_012, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_013, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_013, TestSize.Level1) { uint32_t len = 2; std::vector inParam; @@ -290,10 +290,10 @@ HWTEST_F(ListTest, ListTest_013, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_014, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_014, TestSize.Level1) { - int fd1 = open("/ListTest_014_0.txt", O_CREAT | O_RDWR | O_TRUNC, 0644); - int fd2 = open("/ListTest_014_1.txt", O_CREAT | O_RDWR | O_TRUNC, 0644); + int fd1 = open("/CppListTest_014_0.txt", O_CREAT | O_RDWR | O_TRUNC, 0644); + int fd2 = open("/CppListTest_014_1.txt", O_CREAT | O_RDWR | O_TRUNC, 0644); ASSERT_NE(fd1, -1); ASSERT_NE(fd2, -1); @@ -314,7 +314,7 @@ HWTEST_F(ListTest, ListTest_014, TestSize.Level0) close(fd2); } -HWTEST_F(ListTest, ListTest_015, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_015, TestSize.Level1) { uint32_t len = 2; std::vector inParam; @@ -334,7 +334,7 @@ HWTEST_F(ListTest, ListTest_015, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_016, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_016, TestSize.Level1) { uint32_t len = 4; std::vector inParam; @@ -362,7 +362,7 @@ HWTEST_F(ListTest, ListTest_016, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_017, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_017, TestSize.Level1) { uint32_t len = 2; std::vector inParam; @@ -385,7 +385,7 @@ HWTEST_F(ListTest, ListTest_017, TestSize.Level0) } } -HWTEST_F(ListTest, ListTest_018, TestSize.Level0) +HWTEST_F(CppListTest, CppListTest_018, TestSize.Level1) { std::vector> inParam = { sptr(new SequenceData(1, 1.2, "hello")), diff --git a/tools/hdi-gen/test/cpp_test/map_test/v1_0/cpp_map_test.cpp b/tools/hdi-gen/test/cpp_test/map_test/v1_0/cpp_map_test.cpp index 96edcb6adebdda29769e20f52d9c48904147c842..6a25df095e1b3612ddf0c40a12f09557e683afe2 100755 --- a/tools/hdi-gen/test/cpp_test/map_test/v1_0/cpp_map_test.cpp +++ b/tools/hdi-gen/test/cpp_test/map_test/v1_0/cpp_map_test.cpp @@ -6,18 +6,18 @@ * See the LICENSE file in the root of this repository for complete details. */ +#include +#include +#include #include +#include +#include +#include #include #include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "hdf_log.h" +#include "osal_mem.h" +#include "securec.h" #include "cpp_test/map_test/v1_0/client/map_test_proxy.h" using namespace OHOS; @@ -27,7 +27,7 @@ using namespace test::cpp_test::types::v1_0; static sptr g_testClient = nullptr; -class MapTest : public testing::Test { +class CppMapTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(); @@ -35,15 +35,15 @@ public: void TearDown(){} }; -void MapTest::SetUpTestCase() +void CppMapTest::SetUpTestCase() { g_testClient = IMapTest::Get(); if (g_testClient == nullptr) { - std::cout << "MapTest: get g_testClient failed." << std::endl; + std::cout << "CppMapTest: get g_testClient failed." << std::endl; } } -void MapTest::TearDownTestCase() +void CppMapTest::TearDownTestCase() { if (g_testClient != nullptr) { delete g_testClient; @@ -51,12 +51,12 @@ void MapTest::TearDownTestCase() } } -HWTEST_F(MapTest, MapTest_001, TestSize.Level0) +HWTEST_F(CppMapTest, CppMapTest_001, TestSize.Level1) { ASSERT_NE(nullptr, g_testClient); } -HWTEST_F(MapTest, MapTest_002, TestSize.Level0) +HWTEST_F(CppMapTest, CppMapTest_002, TestSize.Level1) { std::map inParam; inParam[1] = 'A'; @@ -72,13 +72,12 @@ HWTEST_F(MapTest, MapTest_002, TestSize.Level0) if (outIter != outParam.end()) { ASSERT_EQ(inIter->second, outIter->second); } else { - std::cout << "MapTest_002 TestCase is failed!" << std::endl; + std::cout << "CppMapTest_002 TestCase is failed!" << std::endl; } } } - -HWTEST_F(MapTest, MapTest_003, TestSize.Level0) +HWTEST_F(CppMapTest, CppMapTest_003, TestSize.Level1) { std::map inParam; inParam[1] = 1; @@ -94,12 +93,12 @@ HWTEST_F(MapTest, MapTest_003, TestSize.Level0) if (outIter != outParam.end()) { ASSERT_EQ(inIter->second, outIter->second); } else { - std::cout << "MapTest_003 TestCase is failed!" << std::endl; + std::cout << "CppMapTest_003 TestCase is failed!" << std::endl; } } } -HWTEST_F(MapTest, MapTest_004, TestSize.Level0) +HWTEST_F(CppMapTest, CppMapTest_004, TestSize.Level1) { std::map inParam; inParam[1] = 1; @@ -115,12 +114,12 @@ HWTEST_F(MapTest, MapTest_004, TestSize.Level0) if (outIter != outParam.end()) { ASSERT_EQ(inIter->second, outIter->second); } else { - std::cout << "MapTest_004 TestCase is failed!" << std::endl; + std::cout << "CppMapTest_004 TestCase is failed!" << std::endl; } } } -HWTEST_F(MapTest, MapTest_005, TestSize.Level0) +HWTEST_F(CppMapTest, CppMapTest_005, TestSize.Level1) { std::map inParam; inParam[1] = 100; @@ -136,12 +135,12 @@ HWTEST_F(MapTest, MapTest_005, TestSize.Level0) if (outIter != outParam.end()) { ASSERT_EQ(inIter->second, outIter->second); } else { - std::cout << "MapTest_005 TestCase is failed!" << std::endl; + std::cout << "CppMapTest_005 TestCase is failed!" << std::endl; } } } -HWTEST_F(MapTest, MapTest_006, TestSize.Level0) +HWTEST_F(CppMapTest, CppMapTest_006, TestSize.Level1) { std::map inParam; inParam[1] = 10.5; @@ -157,12 +156,12 @@ HWTEST_F(MapTest, MapTest_006, TestSize.Level0) if (outIter != outParam.end()) { ASSERT_EQ(inIter->second, outIter->second); } else { - std::cout << "MapTest_006 TestCase is failed!" << std::endl; + std::cout << "CppMapTest_006 TestCase is failed!" << std::endl; } } } -HWTEST_F(MapTest, MapTest_007, TestSize.Level0) +HWTEST_F(CppMapTest, CppMapTest_007, TestSize.Level1) { std::map inParam; inParam[1] = 10.55; @@ -178,12 +177,12 @@ HWTEST_F(MapTest, MapTest_007, TestSize.Level0) if (outIter != outParam.end()) { ASSERT_DOUBLE_EQ(inIter->second, outIter->second); } else { - std::cout << "MapTest_007 TestCase is failed!" << std::endl; + std::cout << "CppMapTest_007 TestCase is failed!" << std::endl; } } } -HWTEST_F(MapTest, MapTest_008, TestSize.Level0) +HWTEST_F(CppMapTest, CppMapTest_008, TestSize.Level1) { std::map inParam; inParam[1] = "hello"; @@ -192,19 +191,19 @@ HWTEST_F(MapTest, MapTest_008, TestSize.Level0) std::map outParam; int32_t ec = g_testClient->MapIntStringTest(inParam, outParam); - ASSERT_EQ(ec, HDF_SUCCESS); + ASSERT_EQ(ec, HDF_SUCCESS); for (auto inIter = inParam.begin(); inIter != inParam.end(); ++inIter) { auto outIter = outParam.find(inIter->first); if (outIter != outParam.end()) { ASSERT_STREQ(inIter->second.c_str(), outIter->second.c_str()); } else { - std::cout << "MapTest_008 TestCase is failed!" << std::endl; + std::cout << "CppMapTest_008 TestCase is failed!" << std::endl; } } } -HWTEST_F(MapTest, MapTest_009, TestSize.Level0) +HWTEST_F(CppMapTest, CppMapTest_009, TestSize.Level1) { std::map inParam; inParam[1] = open("/cpp_test_map_009.txt", O_CREAT | O_RDWR | O_TRUNC, 0644); @@ -213,7 +212,7 @@ HWTEST_F(MapTest, MapTest_009, TestSize.Level0) std::map outParam; int32_t ec = g_testClient->MapIntFdTest(inParam, outParam); - ASSERT_EQ(ec, HDF_SUCCESS); + ASSERT_EQ(ec, HDF_SUCCESS); for (auto inIter = inParam.begin(); inIter != inParam.end(); ++inIter) { auto outIter = outParam.find(inIter->first); @@ -221,7 +220,7 @@ HWTEST_F(MapTest, MapTest_009, TestSize.Level0) std::cout << "inParam[" << inIter->first << "]:" << inIter->second << std::endl; std::cout << "outParam[" << outIter->first << "]:" << outIter->second << std::endl; } else { - std::cout << "MapTest_009 TestCase is failed!" << std::endl; + std::cout << "CppMapTest_009 TestCase is failed!" << std::endl; } } @@ -229,7 +228,7 @@ HWTEST_F(MapTest, MapTest_009, TestSize.Level0) close(outParam[0]); } -HWTEST_F(MapTest, MapTest_010, TestSize.Level0) +HWTEST_F(CppMapTest, CppMapTest_010, TestSize.Level1) { std::map> inParam = { {0, sptr(new SequenceData(1, 1.2, "hello"))}, @@ -239,7 +238,7 @@ HWTEST_F(MapTest, MapTest_010, TestSize.Level0) std::map> outParam; int32_t ec = g_testClient->MapIntSeqTest(inParam, outParam); - ASSERT_EQ(ec, HDF_SUCCESS); + ASSERT_EQ(ec, HDF_SUCCESS); for (auto inIter = inParam.begin(); inIter != inParam.end(); ++inIter) { auto outIter = outParam.find(inIter->first); @@ -248,12 +247,12 @@ HWTEST_F(MapTest, MapTest_010, TestSize.Level0) EXPECT_DOUBLE_EQ(inIter->second->m2_, outIter->second->m2_); EXPECT_EQ(inIter->second->m3_, outIter->second->m3_); } else { - std::cout << "MapTest_010 TestCase is failed!" << std::endl; + std::cout << "CppMapTest_010 TestCase is failed!" << std::endl; } } } -HWTEST_F(MapTest, MapTest_011, TestSize.Level0) +HWTEST_F(CppMapTest, CppMapTest_011, TestSize.Level1) { std::map inParam; inParam[1] = ESample::MEM_ONE; @@ -262,19 +261,19 @@ HWTEST_F(MapTest, MapTest_011, TestSize.Level0) std::map outParam; int32_t ec = g_testClient->MapIntEnumTest(inParam, outParam); - ASSERT_EQ(ec, HDF_SUCCESS); + ASSERT_EQ(ec, HDF_SUCCESS); for (auto inIter = inParam.begin(); inIter != inParam.end(); ++inIter) { auto outIter = outParam.find(inIter->first); if (outIter != outParam.end()) { ASSERT_EQ(inIter->second, outIter->second); } else { - std::cout << "MapTest_011 TestCase is failed!" << std::endl; + std::cout << "CppMapTest_011 TestCase is failed!" << std::endl; } } } -HWTEST_F(MapTest, MapTest_012, TestSize.Level0) +HWTEST_F(CppMapTest, CppMapTest_012, TestSize.Level1) { std::map inParam; for (int32_t i = 0; i < 2; i++) { @@ -299,12 +298,12 @@ HWTEST_F(MapTest, MapTest_012, TestSize.Level0) ASSERT_DOUBLE_EQ((inIter->second).m3, (outIter->second).m3); ASSERT_EQ((inIter->second).m4, (outIter->second).m4); } else { - std::cout << "MapTest_012 TestCase is failed!" << std::endl; + std::cout << "CppMapTest_012 TestCase is failed!" << std::endl; } } } -HWTEST_F(MapTest, MapTest_013, TestSize.Level0) +HWTEST_F(CppMapTest, CppMapTest_013, TestSize.Level1) { std::map inParam; for (int32_t i = 0; i < 2; i++) { @@ -325,7 +324,7 @@ HWTEST_F(MapTest, MapTest_013, TestSize.Level0) ASSERT_EQ(((inIter->second).m1 ? 1 : 0), ((outIter->second).m1 ? 1 : 0)); ASSERT_EQ((inIter->second).m2, (outIter->second).m2); } else { - std::cout << "MapTest_013 TestCase is failed!" << std::endl; + std::cout << "CppMapTest_013 TestCase is failed!" << std::endl; } } } \ No newline at end of file diff --git a/tools/hdi-gen/test/cpp_test/struct_test/v1_0/cpp_struct_test.cpp b/tools/hdi-gen/test/cpp_test/struct_test/v1_0/cpp_struct_test.cpp index 4343b89c83b5108bd9accdc2ddbb5679e1964e85..3473bf4afb908a3cec2876434728f1ac04211dc0 100755 --- a/tools/hdi-gen/test/cpp_test/struct_test/v1_0/cpp_struct_test.cpp +++ b/tools/hdi-gen/test/cpp_test/struct_test/v1_0/cpp_struct_test.cpp @@ -8,14 +8,14 @@ #include #include +#include +#include +#include #include #include -#include -#include -#include -#include -#include -#include +#include "hdf_log.h" +#include "osal_mem.h" +#include "securec.h" #include "test/cpp_test/struct_test/v1_0/client/struct_test_proxy.h" using namespace OHOS; @@ -25,7 +25,7 @@ using namespace test::cpp_test::types::v1_0; static sptr g_testClient = nullptr; -class StructTest : public testing::Test { +class CppStructTest : public testing::Test { public: static void SetUpTestCase(); static void TearDownTestCase(){} @@ -33,44 +33,20 @@ public: void TearDown(){} }; -void StructTest::SetUpTestCase() +void CppStructTest::SetUpTestCase() { g_testClient = IStructTest::Get(); if (g_testClient == nullptr) { - printf("StructTest: get g_testClient failed.\n"); + printf("CppStructTest: get g_testClient failed.\n"); } } -HWTEST_F(StructTest, StructTest_001, TestSize.Level0) +HWTEST_F(CppStructTest, CppStructTest_001, TestSize.Level1) { ASSERT_NE(nullptr, g_testClient); } -static std::string ESampleToStr(ESample obj) -{ - switch (obj) { - case ESample::MEM_ONE: - return "MEM_ONE"; - case ESample::MEM_TWO: - return "MEM_TWO"; - case ESample::MEM_THREE: - return "MEM_THREE"; - default: - return "unknown"; - } -} - -static void PrintSSample(const SSample& obj) -{ - std::cout << "{"; - std::cout << "m1:" << (obj.m1 ? 1 : 0) << ", "; - std::cout << "m2:" << obj.m2 << ", "; - std::cout << "m3:" << obj.m3 << ", "; - std::cout << "m4:" << obj.m4; - std::cout << "}"; -} - -HWTEST_F(StructTest, StructTest_002, TestSize.Level0) +HWTEST_F(CppStructTest, CppStructTest_002, TestSize.Level1) { SSample srcObj = {true, 1, 1000.125, "hello world"}; @@ -83,33 +59,9 @@ HWTEST_F(StructTest, StructTest_002, TestSize.Level0) EXPECT_EQ(srcObj.m2, destObj.m2); EXPECT_DOUBLE_EQ(srcObj.m3, destObj.m3); EXPECT_EQ(srcObj.m4, destObj.m4); - - PrintSSample(srcObj); - std::cout << "\n"; - PrintSSample(destObj); - std::cout << "\n"; - std::cout << "----------------------------" << std::endl; -} - -static void PrintSSample2(const SSample2& obj) -{ - std::cout << "{"; - - std::cout << "m1:" << obj.m1 << ", "; - std::cout << "m2:" << (obj.m2 ? 1 : 0) << ", "; - std::cout << "m3:" << obj.m3 << ", "; - std::cout << "m4:" << obj.m4 << ", "; - std::cout << "m5:" << obj.m5 << ", "; - std::cout << "m6:" << obj.m6 << ", "; - std::cout << "m7:" << obj.m7 << ", "; - std::cout << "m8:" << obj.m8 << ", "; - std::cout << "m9:" << obj.m9 << ", "; - std::cout << "m10:" << obj.m10 << ", "; - std::cout << "m11:" << obj.m11; - std::cout << "}"; } -HWTEST_F(StructTest, StructTest_003, TestSize.Level0) +HWTEST_F(CppStructTest, CppStructTest_003, TestSize.Level1) { SSample2 srcObj = {true, 1, 2, 3, 4, 65, 20, 30, 40, 100.25, 1000.125}; @@ -129,28 +81,9 @@ HWTEST_F(StructTest, StructTest_003, TestSize.Level0) EXPECT_EQ(srcObj.m9, destObj.m9); EXPECT_FLOAT_EQ(srcObj.m10, destObj.m10); EXPECT_DOUBLE_EQ(srcObj.m11, destObj.m11); - - PrintSSample2(srcObj); - std::cout << "\n"; - PrintSSample2(destObj); - std::cout << "\n"; - std::cout << "----------------------------" << std::endl; -} - -static void PrintSSample3(const SSample3& obj) -{ - std::cout << "{"; - std::cout << "m1:" << obj.m1 << ", "; - std::cout << "m2:" << ESampleToStr(obj.m2) << ", "; - - std::cout << "m3:"; - PrintSSample2(obj.m3); - std::cout << ", "; - - std::cout << "m4:" << obj.m4; } -HWTEST_F(StructTest, StructTest_004, TestSize.Level0) +HWTEST_F(CppStructTest, CppStructTest_004, TestSize.Level1) { int fd = open("/fdtest3.txt", O_CREAT | O_RDWR | O_TRUNC, 0644); SSample3 srcObj = { @@ -166,7 +99,6 @@ HWTEST_F(StructTest, StructTest_004, TestSize.Level0) EXPECT_EQ(srcObj.m1, destObj.m1); EXPECT_EQ(srcObj.m2, destObj.m2); - EXPECT_EQ((srcObj.m3.m1 ? 1 : 0), (destObj.m3.m1 ? 1 : 0)); EXPECT_EQ(srcObj.m3.m2, destObj.m3.m2); EXPECT_EQ(srcObj.m3.m3, destObj.m3.m3); @@ -178,138 +110,12 @@ HWTEST_F(StructTest, StructTest_004, TestSize.Level0) EXPECT_EQ(srcObj.m3.m9, destObj.m3.m9); EXPECT_FLOAT_EQ(srcObj.m3.m10, destObj.m3.m10); EXPECT_DOUBLE_EQ(srcObj.m3.m11, destObj.m3.m11); - - PrintSSample3(srcObj); - std::cout << "\n"; - PrintSSample3(destObj); - std::cout << "\n"; - std::cout << "----------------------------" << std::endl; close(srcObj.m4); close(destObj.m4); } -static void PrintSSample4(const SSample4& obj) +static void CompareSSample4Part1(const SSample4& srcObj, const SSample4& destObj) const { - std::cout << "{\n"; - - std::cout << "m1:{"; - for (size_t i = 0; i < obj.m1.size(); i++) { - std::cout << (obj.m1[i] ? 1 : 0) << ", "; - } - std::cout << "},\n"; - - std::cout << "m2:{"; - for (size_t i = 0; i < obj.m2.size(); i++) { - std::cout << obj.m2[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m3:{"; - for (size_t i = 0; i < obj.m3.size(); i++) { - std::cout << obj.m3[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m4:{"; - for (size_t i = 0; i < obj.m4.size(); i++) { - std::cout << obj.m4[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m5:{"; - for (size_t i = 0; i < obj.m5.size(); i++) { - std::cout << obj.m5[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m6:{"; - for (size_t i = 0; i < obj.m6.size(); i++) { - std::cout << obj.m6[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m7:{"; - for (size_t i = 0; i < obj.m7.size(); i++) { - std::cout << obj.m7[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m8:{"; - for (size_t i = 0; i < obj.m8.size(); i++) { - std::cout << obj.m8[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m9:{"; - for (size_t i = 0; i < obj.m9.size(); i++) { - std::cout << obj.m9[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m10:{"; - for (size_t i = 0; i < obj.m10.size(); i++) { - std::cout << obj.m10[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m11:{"; - for (size_t i = 0; i < obj.m11.size(); i++) { - std::cout << obj.m11[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m12:{"; - for (size_t i = 0; i < obj.m12.size(); i++) { - std::cout << obj.m12[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m13:{"; - for (size_t i = 0; i < obj.m13.size(); i++) { - std::cout << ESampleToStr(obj.m13[i]) << ", "; - } - std::cout << "},\n"; - - std::cout << "m14:{"; - for (size_t i = 0; i < obj.m13.size(); i++) { - PrintSSample(obj.m14[i]); - std::cout << ", "; - } - std::cout << "},\n"; - - std::cout << "m15:{"; - for (size_t i = 0; i < obj.m15.size(); i++) { - std::cout << obj.m15[i] << ", "; - } - std::cout << "}"; - std::cout << "}\n"; -} - -HWTEST_F(StructTest, StructTest_005, TestSize.Level0) -{ - SSample4 srcObj = { - {true, false}, - {65, 66}, - {3, 4}, - {5, 6}, - {7, 8}, - {97, 98}, - {30, 40}, - {50, 60}, - {70, 80}, - {10.5, 20.5}, - {30.125, 30.125}, - {"hello", "world"}, - {ESample::MEM_ONE, ESample::MEM_THREE}, - {{true, 1, 1000.125, "hello"}, {false, 1, 1000.125, "world"}}, - {sptr(new SequenceData(1, 1.2, "hello")), sptr(new SequenceData(2, 2.2, "world"))}, - }; - - SSample4 destObj; - - int32_t ec = g_testClient->SSample4Test(srcObj, destObj); - ASSERT_EQ(ec, HDF_SUCCESS); - for (size_t i = 0; i < srcObj.m1.size(); i++) { EXPECT_EQ((srcObj.m1[i] ? 1 : 0), (destObj.m1[i] ? 1 : 0)); } @@ -329,7 +135,10 @@ HWTEST_F(StructTest, StructTest_005, TestSize.Level0) for (size_t i = 0; i < srcObj.m5.size(); i++) { EXPECT_EQ(srcObj.m5[i], destObj.m5[i]); } +} +static void CompareSSample4Part2(const SSample4& srcObj, const SSample4& destObj) const +{ for (size_t i = 0; i < srcObj.m6.size(); i++) { EXPECT_EQ(srcObj.m6[i], destObj.m6[i]); } @@ -353,7 +162,10 @@ HWTEST_F(StructTest, StructTest_005, TestSize.Level0) for (size_t i = 0; i < srcObj.m11.size(); i++) { EXPECT_DOUBLE_EQ(srcObj.m11[i], destObj.m11[i]); } +} +static void CompareSSample4Part3(const SSample4& srcObj, const SSample4& destObj) const +{ for (size_t i = 0; i < srcObj.m12.size(); i++) { EXPECT_EQ(srcObj.m12[i], destObj.m12[i]); } @@ -381,114 +193,18 @@ HWTEST_F(StructTest, StructTest_005, TestSize.Level0) std::cout << "var1 or var2 is nullptr" << std::endl; } } - - PrintSSample4(srcObj); - PrintSSample4(destObj); - std::cout << "\n"; - std::cout << "--------------------------------------\n"; } -static void PrintSSample5(const SSample5& obj) +static void CompareSSample4(const SSample4& srcObj, const SSample4& destObj) const { - std::cout << "{\n"; - - std::cout << "m1:{"; - for (size_t i = 0; i < obj.m1.size(); i++) { - std::cout << obj.m1[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m2:{"; - for (size_t i = 0; i < obj.m2.size(); i++) { - std::cout << obj.m2[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m3:{"; - for (size_t i = 0; i < obj.m3.size(); i++) { - std::cout << obj.m3[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m4:{"; - for (size_t i = 0; i < obj.m4.size(); i++) { - std::cout << obj.m4[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m5:{"; - for (size_t i = 0; i < obj.m5.size(); i++) { - std::cout << obj.m5[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m6:{"; - for (size_t i = 0; i < obj.m6.size(); i++) { - std::cout << obj.m6[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m7:{"; - for (size_t i = 0; i < obj.m7.size(); i++) { - std::cout << obj.m7[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m8:{"; - for (size_t i = 0; i < obj.m8.size(); i++) { - std::cout << obj.m8[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m9:{"; - for (size_t i = 0; i < obj.m9.size(); i++) { - std::cout << obj.m9[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m10:{"; - for (size_t i = 0; i < obj.m10.size(); i++) { - std::cout << obj.m10[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m11:{"; - for (size_t i = 0; i < obj.m11.size(); i++) { - std::cout << obj.m11[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m12:{"; - for (size_t i = 0; i < obj.m12.size(); i++) { - std::cout << obj.m12[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "m13:{"; - for (size_t i = 0; i < obj.m13.size(); i++) { - std::cout << ESampleToStr(obj.m13[i]) << ", "; - } - std::cout << "},\n"; - - std::cout << "m14:{"; - for (size_t i = 0; i < obj.m14.size(); i++) { - PrintSSample(obj.m14[i]); - std::cout << ", \n"; - } - std::cout << ",\n"; - - std::cout << "m13:{"; - for (size_t i = 0; i < obj.m15.size(); i++) { - std::cout << obj.m15[i] << ", "; - } - std::cout << "},\n"; - - std::cout << "}"; + CompareSSample4Part1(srcObj, destObj); + CompareSSample4Part2(srcObj, destObj); + CompareSSample4Part3(srcObj, destObj); } -HWTEST_F(StructTest, StructTest_006, TestSize.Level0) +HWTEST_F(CppStructTest, CppStructTest_005, TestSize.Level1) { - SSample5 srcObj = { + SSample4 srcObj = { {true, false}, {65, 66}, {3, 4}, @@ -506,11 +222,16 @@ HWTEST_F(StructTest, StructTest_006, TestSize.Level0) {sptr(new SequenceData(1, 1.2, "hello")), sptr(new SequenceData(2, 2.2, "world"))}, }; - SSample5 destObj; + SSample4 destObj; - int32_t ec = g_testClient->SSample5Test(srcObj, destObj); + int32_t ec = g_testClient->SSample4Test(srcObj, destObj); ASSERT_EQ(ec, HDF_SUCCESS); + CompareSSample4(srcObj, destObj); +} + +static void CompareSSample5Part1(const SSample5& srcObj, const SSample5& destObj) const +{ for (size_t i = 0; i < srcObj.m1.size(); i++) { EXPECT_EQ((srcObj.m1[i] ? 1 : 0), (destObj.m1[i] ? 1 : 0)); } @@ -530,7 +251,10 @@ HWTEST_F(StructTest, StructTest_006, TestSize.Level0) for (size_t i = 0; i < srcObj.m5.size(); i++) { EXPECT_EQ(srcObj.m5[i], destObj.m5[i]); } +} +static void CompareSSample5Part2(const SSample5& srcObj, const SSample5& destObj) const +{ for (size_t i = 0; i < srcObj.m6.size(); i++) { EXPECT_EQ(srcObj.m6[i], destObj.m6[i]); } @@ -554,7 +278,10 @@ HWTEST_F(StructTest, StructTest_006, TestSize.Level0) for (size_t i = 0; i < srcObj.m11.size(); i++) { EXPECT_DOUBLE_EQ(srcObj.m11[i], destObj.m11[i]); } +} +static void CompareSSample5Part3(const SSample5& srcObj, const SSample5& destObj) const +{ for (size_t i = 0; i < srcObj.m12.size(); i++) { EXPECT_EQ(srcObj.m12[i], destObj.m12[i]); } @@ -582,9 +309,39 @@ HWTEST_F(StructTest, StructTest_006, TestSize.Level0) std::cout << "var1 or var2 is nullptr" << std::endl; } } +} + +static void CompareSSample5(const SSample5& srcObj, const SSample5& destObj) const +{ + CompareSSample5Part1(srcObj, destObj); + CompareSSample5Part2(srcObj, destObj); + CompareSSample5Part3(srcObj, destObj); +} + +HWTEST_F(CppStructTest, CppStructTest_006, TestSize.Level1) +{ + SSample5 srcObj = { + {true, false}, + {65, 66}, + {3, 4}, + {5, 6}, + {7, 8}, + {97, 98}, + {30, 40}, + {50, 60}, + {70, 80}, + {10.5, 20.5}, + {30.125, 30.125}, + {"hello", "world"}, + {ESample::MEM_ONE, ESample::MEM_THREE}, + {{true, 1, 1000.125, "hello"}, {false, 1, 1000.125, "world"}}, + {sptr(new SequenceData(1, 1.2, "hello")), sptr(new SequenceData(2, 2.2, "world"))}, + }; + + SSample5 destObj; + + int32_t ec = g_testClient->SSample5Test(srcObj, destObj); + ASSERT_EQ(ec, HDF_SUCCESS); - PrintSSample5(srcObj); - PrintSSample5(destObj); - std::cout << "\n"; - std::cout << "--------------------------------------\n"; + CompareSSample5(srcObj, destObj); } \ No newline at end of file diff --git a/tools/hdi-gen/test/kernel_test/array_test/v1_0/ArrayTypes.idl b/tools/hdi-gen/test/kernel_test/array_test/v1_0/ArrayTypes.idl new file mode 100755 index 0000000000000000000000000000000000000000..404b2de00346cfbed4ad84c320b5dc3e8776b2c2 --- /dev/null +++ b/tools/hdi-gen/test/kernel_test/array_test/v1_0/ArrayTypes.idl @@ -0,0 +1,29 @@ +/* + * Copyright (c) 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. + */ + +package test.kernel_test.array_test.v1_0; + +enum AESample +{ + MEM_ONE, + MEM_TWO, + MEM_THREE, +}; + +struct ASSample +{ + boolean m1; + int m2; + String m4; +}; + +union AUSample +{ + boolean m1; + int m2; +}; \ No newline at end of file diff --git a/tools/hdi-gen/test/kernel_test/array_test/v1_0/IArrayTest.idl b/tools/hdi-gen/test/kernel_test/array_test/v1_0/IArrayTest.idl new file mode 100755 index 0000000000000000000000000000000000000000..b1e5720c1b56dcd32a68d1f769f4f8d00646a95e --- /dev/null +++ b/tools/hdi-gen/test/kernel_test/array_test/v1_0/IArrayTest.idl @@ -0,0 +1,40 @@ +/* + * Copyright (c) 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. + */ + +package test.kernel_test.array_test.v1_0; + +import test.kernel_test.array_test.v1_0.ArrayTypes; + +interface IArrayTest { + + BoolArrayTest([in] boolean[] param1, [out] boolean[] param2); + + ByteArrayTest([in] byte[] param1, [out] byte[] param2); + + ShortArrayTest([in] short[] param1, [out] short[] param2); + + IntArrayTest([in] int[] param1, [out] int[] param2); + + LongArrayTest([in] long[] param1, [out] long[] param2); + + UCharArrayTest([in] unsigned char[] param1, [out] unsigned char[] param2); + + UShortArrayTest([in] unsigned short[] param1, [out] unsigned short[] param2); + + UIntArrayTest([in] unsigned int[] param1, [out] unsigned int[] param2); + + ULongArrayTest([in] unsigned long[] param1, [out] unsigned long[] param2); + + StringArrayTest([in] String[] param1, [out] String[] param2); + + EnumArrayTest([in] enum AESample[] param1, [out] enum AESample[] param2); + + StructArrayTest([in] struct ASSample[] param1, [out] struct ASSample[] param2); + + UnionArrayTest([in] union AUSample[] param1, [out] union AUSample[] param2); +} \ No newline at end of file diff --git a/tools/hdi-gen/test/kernel_test/data_test/v1_0/DataTypes.idl b/tools/hdi-gen/test/kernel_test/data_test/v1_0/DataTypes.idl new file mode 100755 index 0000000000000000000000000000000000000000..08057e249d2f6f6dac693b0120860111f87bd18e --- /dev/null +++ b/tools/hdi-gen/test/kernel_test/data_test/v1_0/DataTypes.idl @@ -0,0 +1,29 @@ +/* + * Copyright (c) 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. + */ + +package test.kernel_test.data_test.v1_0; + +enum DESample +{ + MEM_ONE, + MEM_TWO, + MEM_THREE, +}; + +struct DSSample +{ + boolean m1; + int m2; + String m4; +}; + +union DUSample +{ + boolean m1; + int m2; +}; \ No newline at end of file diff --git a/tools/hdi-gen/test/kernel_test/data_test/v1_0/IDataTest.idl b/tools/hdi-gen/test/kernel_test/data_test/v1_0/IDataTest.idl new file mode 100755 index 0000000000000000000000000000000000000000..4424711473880134b78880473ab145f70e3bed9e --- /dev/null +++ b/tools/hdi-gen/test/kernel_test/data_test/v1_0/IDataTest.idl @@ -0,0 +1,40 @@ +/* + * Copyright (c) 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. + */ + +package test.kernel_test.data_test.v1_0; + +import test.kernel_test.data_test.v1_0.DataTypes; + +interface IDataTest { + + BoolTest([in] boolean param1, [out] boolean param2); + + ByteTest([in] byte param1, [out] byte param2); + + ShortTest([in] short param1, [out] short param2); + + IntTest([in] int param1, [out] int param2); + + LongTest([in] long param1, [out] long param2); + + UCharTest([in] unsigned char param1, [out] unsigned char param2); + + UShortTest([in] unsigned short param1, [out] unsigned short param2); + + UIntTest([in] unsigned int param1, [out] unsigned int param2); + + ULongTest([in] unsigned long param1, [out] unsigned long param2); + + StringTest([in] String param1, [out] String param2); + + EnumTest([in] enum DESample param1, [out] enum DESample param2); + + StructTest([in] struct DSSample param1, [out] struct DSSample param2); + + UnionTest([in] union DUSample param1, [out] union DUSample param2); +} \ No newline at end of file diff --git a/tools/hdi-gen/test/kernel_test/list_test/v1_0/IListTest.idl b/tools/hdi-gen/test/kernel_test/list_test/v1_0/IListTest.idl new file mode 100755 index 0000000000000000000000000000000000000000..ae68dc27144b04246e4b0f773f74445651135859 --- /dev/null +++ b/tools/hdi-gen/test/kernel_test/list_test/v1_0/IListTest.idl @@ -0,0 +1,40 @@ +/* + * Copyright (c) 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. + */ + +package test.kernel_test.list_test.v1_0; + +import test.kernel_test.list_test.v1_0.ListTypes; + +interface IListTest { + + BoolListTest([in] List param1, [out] List param2); + + ByteListTest([in] List param1, [out] List param2); + + ShortListTest([in] List param1, [out] List param2); + + IntListTest([in] List param1, [out] List param2); + + LongListTest([in] List param1, [out] List param2); + + UCharListTest([in] List param1, [out] List param2); + + UShortListTest([in] List param1, [out] List param2); + + UIntListTest([in] List param1, [out] List param2); + + ULongListTest([in] List param1, [out] List param2); + + StringListTest([in] List param1, [out] List param2); + + EnumListTest([in] List param1, [out] List param2); + + StructListTest([in] List param1, [out] List param2); + + UnionListTest([in] List param1, [out] List param2); +} \ No newline at end of file diff --git a/tools/hdi-gen/test/kernel_test/list_test/v1_0/ListTypes.idl b/tools/hdi-gen/test/kernel_test/list_test/v1_0/ListTypes.idl new file mode 100755 index 0000000000000000000000000000000000000000..f693a321ed89e7fa9a73bee26145b1c6bbd07970 --- /dev/null +++ b/tools/hdi-gen/test/kernel_test/list_test/v1_0/ListTypes.idl @@ -0,0 +1,29 @@ +/* + * Copyright (c) 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. + */ + +package test.kernel_test.list_test.v1_0; + +enum LESample +{ + MEM_ONE, + MEM_TWO, + MEM_THREE, +}; + +struct LSSample +{ + boolean m1; + int m2; + String m4; +}; + +union LUSample +{ + boolean m1; + int m2; +}; \ No newline at end of file diff --git a/tools/hdi-gen/test/kernel_test/struct_test/v1_0/IStructTest.idl b/tools/hdi-gen/test/kernel_test/struct_test/v1_0/IStructTest.idl new file mode 100755 index 0000000000000000000000000000000000000000..4580b0dbb73abaa8d2c51cc0484b8ef61571048b --- /dev/null +++ b/tools/hdi-gen/test/kernel_test/struct_test/v1_0/IStructTest.idl @@ -0,0 +1,20 @@ +/* + * Copyright (c) 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. + */ + +package test.kernel_test.struct_test.v1_0; + +import test.kernel_test.struct_test.v1_0.StructTypes; + +interface IStructTest { + SSampleTest([in] struct SSample param1, [out] struct SSample param2); + SSample2Test([in] struct SSample2 param1, [out] struct SSample2 param2); + SSample3Test([in] struct SSample3 param1, [out] struct SSample3 param2); + SSample4Test([in] struct SSample4 param1, [out] struct SSample4 param2); + SSample5Test([in] struct SSample5 param1, [out] struct SSample5 param2); + SSample6Test([in] struct SSample6 param1, [out] struct SSample6 param2); +} \ No newline at end of file diff --git a/tools/hdi-gen/test/kernel_test/struct_test/v1_0/StructTypes.idl b/tools/hdi-gen/test/kernel_test/struct_test/v1_0/StructTypes.idl new file mode 100755 index 0000000000000000000000000000000000000000..ebecca546e0b8806a6af8ebde0384fd95dc648ba --- /dev/null +++ b/tools/hdi-gen/test/kernel_test/struct_test/v1_0/StructTypes.idl @@ -0,0 +1,87 @@ +/* + * Copyright (c) 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. + */ + +package test.kernel_test.struct_test.v1_0; + +enum ESample +{ + MEM_ONE, + MEM_TWO, + MEM_THREE, +}; + +struct SSample +{ + boolean m1; + int m2; + String m4; +}; + +union USample +{ + boolean m1; + int m2; +}; + +struct SSample2 +{ + boolean m1; + byte m2; + short m3; + int m4; + long m5; + unsigned char m6; + unsigned short m7; + unsigned int m8; + unsigned long m9; +}; + +struct SSample3 +{ + String m1; + enum ESample m2; + struct SSample2 m3; +}; + +struct SSample4 +{ + boolean[] m1; + byte[] m2; + short[] m3; + int[] m4; + long[] m5; + unsigned char[] m6; + unsigned short[] m7; + unsigned int[] m8; + unsigned long[] m9; + String[] m12; + enum ESample[] m13; + struct SSample[] m14; +}; + +struct SSample5 +{ + List m1; + List m2; + List m3; + List m4; + List m5; + List m6; + List m7; + List m8; + List m9; + List m12; + List m13; + List m14; +}; + +struct SSample6 { + union USample m1; + union USample[] m2; + List m3; +}; \ No newline at end of file diff --git a/tools/hdi-gen/util/Makefile b/tools/hdi-gen/util/Makefile deleted file mode 100755 index dfae7c273627adf8eddf4746130861d1bda3d301..0000000000000000000000000000000000000000 --- a/tools/hdi-gen/util/Makefile +++ /dev/null @@ -1,14 +0,0 @@ -OBJS_DIR:=$(BUILD_DIR)/util -TARGET = $(OBJS_DIR)/util.a -SOURCE:=$(wildcard *.cpp) -OBJS:=$(patsubst %.cpp, $(OBJS_DIR)/%.o, $(SOURCE)) - - - -$(TARGET):$(OBJS) - $(Q) echo $(TARGET) - $(Q) ar -rc $@ $^ - -$(OBJS_DIR)/%.o:%.cpp - $(Q) mkdir -p $(dir $@) - $(Q) $(CXX) $(CXXFLAGS) $(INCLUDES) -c $^ -o $@ \ No newline at end of file diff --git a/tools/hdi-gen/util/file.cpp b/tools/hdi-gen/util/file.cpp index 72bb17381e23383006e426f7b8d3b691b041018e..faaa51d92870ad6e6e903678bf9ceaf0e1a0e528 100755 --- a/tools/hdi-gen/util/file.cpp +++ b/tools/hdi-gen/util/file.cpp @@ -114,7 +114,7 @@ int File::Read() return (count != 0) ? count : -1; } -bool File::ReadData(void* data, size_t size) +bool File::ReadData(void* data, size_t size) const { if (data == nullptr || size == 0) { return true; @@ -128,7 +128,7 @@ bool File::ReadData(void* data, size_t size) return count == 1; } -bool File::WriteData(const void* data, size_t size) +bool File::WriteData(const void* data, size_t size) const { if (data == nullptr || size == 0) { return true; @@ -182,16 +182,26 @@ bool File::CreateParentDir(const String& path) } int pos = 1; - while ((pos = path.IndexOf('/', pos)) != -1) { - String partPath = path.Substring(0, pos); +#ifndef __MINGW32__ + char Separator = '/'; +#else + char Separator = '\\'; +#endif + + while ((pos = path.IndexOf(Separator, pos)) != -1) { + String partPath = path.Substring(0, pos); struct stat st; if (stat(partPath.string(), &st) < 0) { if (errno != ENOENT) { return false; } +#ifndef __MINGW32__ if (mkdir(partPath.string(), S_IRWXU | S_IRWXG | S_IRWXO) < 0) { +#else + if (mkdir(partPath.string()) < 0) { +#endif return false; } } else if (!S_ISDIR(st.st_mode)) { @@ -202,6 +212,15 @@ bool File::CreateParentDir(const String& path) return true; } +String File::AdapterPath(const String& path) +{ +#ifndef __MINGW32__ + return path; +#else + return path.Replace('/', '\\'); +#endif +} + size_t File::GetHashKey() { StringBuilder fileStr; diff --git a/tools/hdi-gen/util/file.h b/tools/hdi-gen/util/file.h index 7120962cbbca54625716427afbd5eab8616f7155..94de48c835b88b33e83ffd6bb886e1c13fe0dc23 100755 --- a/tools/hdi-gen/util/file.h +++ b/tools/hdi-gen/util/file.h @@ -9,7 +9,6 @@ #ifndef OHOS_HDI_FILE_H #define OHOS_HDI_FILE_H -#include #include #include "util/string.h" @@ -47,9 +46,9 @@ public: return columnNo_; } - bool ReadData(void* data, size_t size); + bool ReadData(void* data, size_t size) const; - bool WriteData(const void* data, size_t size); + bool WriteData(const void* data, size_t size) const; void Flush(); @@ -61,6 +60,8 @@ public: static bool CreateParentDir(const String& path); + static String AdapterPath(const String& path); + size_t GetHashKey(); static constexpr unsigned int READ = 0x1; @@ -89,4 +90,4 @@ private: } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_FILE_H +#endif // OHOS_HDI_FILE_H \ No newline at end of file diff --git a/tools/hdi-gen/util/light_refcount_base.h b/tools/hdi-gen/util/light_refcount_base.h index b0ea254715572dc182c1f776e303b196ea51cee6..2afac227f57196239f746c8a0d778126d1c6c9e7 100755 --- a/tools/hdi-gen/util/light_refcount_base.h +++ b/tools/hdi-gen/util/light_refcount_base.h @@ -38,4 +38,4 @@ private: } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_LIGHTREFCOUNTBASE_H +#endif // OHOS_HDI_LIGHTREFCOUNTBASE_H \ No newline at end of file diff --git a/tools/hdi-gen/util/logger.h b/tools/hdi-gen/util/logger.h index c2d6ad9399acf92994713e5193de3e6d8d296a59..2ba473cb0ff09b2718b0eac8141e66844b04825d 100755 --- a/tools/hdi-gen/util/logger.h +++ b/tools/hdi-gen/util/logger.h @@ -46,4 +46,4 @@ private: } // namespace HDI } // namespace OHOS -#endif // OHOS_HDI_LOGGER_H +#endif // OHOS_HDI_LOGGER_H \ No newline at end of file diff --git a/tools/hdi-gen/util/options.cpp b/tools/hdi-gen/util/options.cpp index 8273ff67a1bdafe59e98294dc168feca66fca88c..42f7d62152abb24da4315bcf021282fbd4882e19 100755 --- a/tools/hdi-gen/util/options.cpp +++ b/tools/hdi-gen/util/options.cpp @@ -16,14 +16,17 @@ namespace OHOS { namespace HDI { -const char* Options::OPT_SUPPORT_ARGS = "c:d:"; +const char* Options::optSupportArgs = "c:d:"; static struct option g_longOpts[] = { {"help", no_argument, nullptr, 'h'}, {"version", no_argument, nullptr, 'v'}, {"gen-c", no_argument, nullptr, 'C'}, {"gen-cpp", no_argument, nullptr, 'P'}, {"gen-java", no_argument, nullptr, 'J'}, - {"hash", no_argument, nullptr, 'H'}, + {"gen-hash", no_argument, nullptr, 'H'}, + {"build-target", required_argument, nullptr, 'p'}, + {"module-name", required_argument, nullptr, 'N'}, + {"kernel", no_argument, nullptr, 'K'}, {"dump-ast", no_argument, nullptr, 'D'}, {nullptr, 0, nullptr, 0} }; @@ -34,57 +37,82 @@ Options& Options::GetInstance() return option; } -Options& Options::Parse(int argc, char** argv) +Options& Options::Parse(int argc, char* const argv[]) { program_ = argv[0]; opterr = 1; int op = 0; int optIndex = 0; - while ((op = getopt_long(argc, argv, OPT_SUPPORT_ARGS, g_longOpts, &optIndex)) != OPT_END) { - switch (op) { - case 'c': - doCompile_ = true; - sourceFilePath_ = optarg; - break; - case 'd': - doOutDir_ = true; - generationDirectory_ = optarg; - break; - case 'h': - doShowUsage_ = true; - break; - case 'v': - doShowVersion_ = true; - break; - case 'C': - doGenerateCode_ = true; - targetLanguage_ = "c"; - break; - case 'P': - doGenerateCode_ = true; - targetLanguage_ = "cpp"; - break; - case 'J': - doGenerateCode_ = true; - targetLanguage_ = "java"; - break; - case 'H': - doGetHashKey_ = true; - break; - case 'D': - doDumpAST_ = true; - break; - case '?': - default: - doShowUsage_ = true; - break; - } + while ((op = getopt_long(argc, argv, optSupportArgs, g_longOpts, &optIndex)) != OPT_END) { + SetOptionData(op); } CheckOptions(); return *this; } +void Options::SetOptionData(char op) +{ + switch (op) { + case 'c': + doCompile_ = true; + sourceFiles_.push_back(optarg); + break; + case 'd': + doOutDir_ = true; + generationDirectory_ = optarg; + break; + case 'h': + doShowUsage_ = true; + break; + case 'v': + doShowVersion_ = true; + break; + case 'K': + doModeKernel_ = true; + break; + case 'N': + doSetModuleName_ = true; + moduleName_ = optarg; + break; + case 'C': + SetLanguage("c"); + break; + case 'P': + SetLanguage("cpp"); + break; + case 'J': + SetLanguage("java"); + break; + case 'p': + SetCodePart(optarg); + break; + case 'H': + doGetHashKey_ = true; + break; + case 'D': + doDumpAST_ = true; + break; + case '?': + default: + doShowUsage_ = true; + break; + } +} + +void Options::SetLanguage(const String& language) +{ + doGenerateCode_ = true; + targetLanguage_ = language; +} + +void Options::SetCodePart(const String& part) +{ + // The default parameter is 'all', and the optional parameters is 'client' or 'server' + doGeneratePart_ = true; + codePart_ = part; +} + void Options::CheckOptions() { if (doShowUsage_ || doShowVersion_) { @@ -106,6 +134,12 @@ void Options::CheckOptions() errors_.push_back(String::Format("%s: no out directory.", program_.string())); return; } + + if (doGeneratePart_ && !codePart_.Equals("all") && !codePart_.Equals("client") && + !codePart_.Equals("server")) { + String errorLog = "The '--build-target' option parameter must be 'client' 'server' or 'all'."; + errors_.push_back(String::Format("%s: %s", program_.string(), errorLog.string())); + } } else { if (doGetHashKey_ || doDumpAST_ || doGenerateCode_ || doOutDir_) { errors_.push_back(String::Format("%s: no '-c' option.", program_.string())); @@ -134,15 +168,18 @@ void Options::ShowUsage() const printf("Compile a .idl file and generate C/C++ and Java codes.\n" "Usage: idl [options] file\n" "Options:\n" - " --help Display command line options\n" - " --version Display toolchain version information\n" - " --hash Display hash key of the idl file\n" - " --dump-ast Display the AST of the compiled file\n" - " -c Compile the .idl file\n" - " --gen-c Generate C codes\n" - " --gen-cpp Generate C++ codes\n" - " --gen-java Generate Java codes\n" - " -d Place generated codes into \n"); + " --help Display command line options\n" + " --version Display toolchain version information\n" + " --dump-ast Display the AST of the compiled file\n" + " -c <*.idl> Compile the .idl file\n" + " --gen-hash Generate hash key of the idl file\n" + " --gen-c Generate C code\n" + " --gen-cpp Generate C++ code\n" + " --gen-java Generate Java code\n" + " --kernel Generate kernel-mode ioservice stub code, default user-mode ioservice stub code\n" + " --module-name Set driver module name\n" + " --build-target Generate client code, server code or all code\n" + " -d Place generated codes into \n"); } } // namespace HDI } // namespace OHOS \ No newline at end of file diff --git a/tools/hdi-gen/util/options.h b/tools/hdi-gen/util/options.h index 1eee4583a765fb6609721b135d0ce554e1228fab..d33f1aece68f514a200879419f35a8cc7bcdd0c1 100755 --- a/tools/hdi-gen/util/options.h +++ b/tools/hdi-gen/util/options.h @@ -21,7 +21,7 @@ public: Options(const Options& other) = delete; Options operator=(const Options& other) = delete; - Options& Parse(int argc, char** argv); + Options& Parse(int argc, char* const argv[]); ~Options() = default; @@ -55,14 +55,19 @@ public: return doGenerateCode_; } + inline bool DoGenerateKernelCode() const + { + return doModeKernel_; + } + inline bool HasErrors() const { return !errors_.empty(); } - inline String GetSourceFile() const + inline std::vector GetSourceFiles() const { - return sourceFilePath_; + return sourceFiles_; } inline String GetTargetLanguage() const @@ -70,6 +75,16 @@ public: return targetLanguage_; } + inline String GetCodePart() const + { + return codePart_; + } + + inline String GetModuleName() const + { + return doSetModuleName_ ? moduleName_ : "sample"; + } + inline String GetGenerationDirectory() const { return generationDirectory_; @@ -83,8 +98,9 @@ public: private: Options() : program_(), - sourceFilePath_(), + sourceFiles_(0), targetLanguage_(), + codePart_("all"), generationDirectory_(), illegalOptions_(), errors_(), @@ -94,32 +110,46 @@ private: doDumpAST_(false), doGetHashKey_(false), doGenerateCode_(false), + doModeKernel_(false), + doGeneratePart_(false), + doSetModuleName_(false), doOutDir_(false) {} - + + void SetOptionData(char op); + + void SetLanguage(const String& language); + + void SetCodePart(const String& part); + void CheckOptions(); - static const char* OPT_SUPPORT_ARGS; + static const char* optSupportArgs; static constexpr int OPT_END = -1; static constexpr int VERSION_MAJOR = 0; static constexpr int VERSION_MINOR = 1; String program_; - String sourceFilePath_; + std::vector sourceFiles_; String targetLanguage_; + String codePart_; + String moduleName_; String generationDirectory_; String illegalOptions_; std::vector errors_; - bool doShowUsage_ = false; - bool doShowVersion_ = false; - bool doCompile_ = false; - bool doDumpAST_ = false; - bool doGetHashKey_ = false; - bool doGenerateCode_ = false; - bool doOutDir_ = false; + bool doShowUsage_; + bool doShowVersion_; + bool doCompile_; + bool doDumpAST_; + bool doGetHashKey_; + bool doGenerateCode_; + bool doModeKernel_; + bool doGeneratePart_; + bool doSetModuleName_; + bool doOutDir_; }; } // namespace HDI } // namespace OHOS -#endif // OHOS_HDIL_OPTION_H +#endif // OHOS_HDIL_OPTION_H \ No newline at end of file diff --git a/tools/hdi-gen/util/string.cpp b/tools/hdi-gen/util/string.cpp index 9be249aeba8db463e3ca97616683f91af7437628..3359e790590226642f7c7ed234667a21aade5447 100755 --- a/tools/hdi-gen/util/string.cpp +++ b/tools/hdi-gen/util/string.cpp @@ -196,6 +196,23 @@ bool String::Equals(const String& other) const return false; } +int String::Compare(const String& other) const +{ + if (string_ == nullptr) { + if (other.string_ == nullptr) { + return 0; + } else { + return -1; + } + } + + if (other.string_ == nullptr) { + return 1; + } + + return strcmp(string_, other.string_); +} + int String::GetHashCode() const { // BKDR Hash Function @@ -328,28 +345,31 @@ int String::LastIndexOfInternal(const char* string, int fromIndex) const int stringLastIndex = stringLen - 1; char stringLastChar = string[stringLastIndex]; - int min = stringLen - 1; - int i = min + fromIndex; + int leftIndex = stringLen - 1; + int index = leftIndex + fromIndex; -startSearchLastChar: while (true) { - while (i >= min && string_[i] != stringLastChar) { - i--; + while (index >= leftIndex && string_[index] != stringLastChar) { + index--; } - if (i < min) { + if (index < leftIndex) { return -1; } - int j = i - 1; - int start = j - (stringLen - 1); - int k = stringLastIndex - 1; - - while (j > start) { - if (string_[j--] != string[k--]) { - i--; - goto startSearchLastChar; + + int compareIndex = index - 1; + int start = compareIndex - (stringLen - 1); + int strIndex = stringLastIndex - 1; + + while (compareIndex > start) { + if (string_[compareIndex--] != string[strIndex--]) { + index--; + break; } } - return start + 1; + + if (compareIndex == start) { + return start + 1; + } } } diff --git a/tools/hdi-gen/util/string.h b/tools/hdi-gen/util/string.h index fc7acf67c0508334838a4f669ef3271b3578f58a..2330f88afa848145cab84e0e876bc944b09792a5 100755 --- a/tools/hdi-gen/util/string.h +++ b/tools/hdi-gen/util/string.h @@ -57,6 +57,8 @@ public: bool Equals(const String& other) const; + int Compare(const String& other) const; + int GetHashCode() const; int IndexOf(char c, int fromIndex = 0) const; diff --git a/ability/config/hcs_parser/include/hcs_blob_if.h b/utils/include/hcs_blob_if.h similarity index 100% rename from ability/config/hcs_parser/include/hcs_blob_if.h rename to utils/include/hcs_blob_if.h diff --git a/ability/config/hcs_parser/include/hcs_parser.h b/utils/include/hcs_parser.h similarity index 100% rename from ability/config/hcs_parser/include/hcs_parser.h rename to utils/include/hcs_parser.h diff --git a/ability/config/hcs_parser/include/hcs_tree_if.h b/utils/include/hcs_tree_if.h similarity index 100% rename from ability/config/hcs_parser/include/hcs_tree_if.h rename to utils/include/hcs_tree_if.h diff --git a/utils/include/hdf_block_buffer.h b/utils/include/hdf_block_buffer.h new file mode 100644 index 0000000000000000000000000000000000000000..43a6837dee99610d25372f2d2b5b621506460e61 --- /dev/null +++ b/utils/include/hdf_block_buffer.h @@ -0,0 +1,139 @@ +/* + * Copyright (c) 2021-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 BLOCK_BUFFER_H +#define BLOCK_BUFFER_H + +#include +#include "hdf_slist.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct HdfBlockBuffer { + struct HdfSList link; + uint16_t position; + uint16_t dataSize; + uint8_t data[1]; +}; + +struct HdfBlockBuffer *HdfBlockBufferNew(uint16_t size); + +void HdfBlockBufferFree(const struct BlockBuffer *buffer); + +uint16_t HdfBlockBufferGetDataSize(struct BlockBuffer *buffer); + +uint16_t HdfBlockBufferGetAvailableSize(struct BlockBuffer *buffer); + +uint16_t HdfBlockBufferSkipBytes(struct BlockBuffer *buffer, uint16_t bytes); + +uint8_t *HdfBlockBufferRead(struct BlockBuffer *buffer, uint16_t size); + +/* + * @brief read a byte value from buffer and move cursor to next. + * + * @param[in] buff the instance of gdk buffer. + * @param[in] ulOffset the offset from current cursor. + * + * @return the byte value that read from buffer. + */ +bool HdfBlockBufferGetc(struct BlockBuffer *buffer, uint8_t *outValue); + +/* + * @brief read a byte value from buffer and move cursor to next. + * + * @param[in] buff the instance of gdk buffer. + * @param[in] ulOffset the offset from current cursor. + * + * @return the byte value that read from buffer. + */ +bool HdfBlockBufferReadByteAt(struct BlockBuffer *buffer, uint16_t idx, uint8_t *outValue); + +/* + * @brief read a short value from buffer and move cursor to next. + * + * @param[in] buff the instance of gdk buffer. + * @param[in] ulOffset the offset from current cursor. + * + * @return the short value that read from buffer. + */ +bool HdfBlockBufferReadShort(struct BlockBuffer *buffer, uint16_t *value16); + +/* + * @brief read a short value from buffer and move cursor to next. + * + * @param[in] buff the instance of gdk buffer. + * @param[in] ulOffset the offset from current cursor. + * + * @return the short value that read from buffer. + */ +bool HdfBlockBufferReadShortAt(struct BlockBuffer *buffer, size_t idx, uint16_t *outValue); + +uint8_t *HdfBlockBufferGetData(struct BlockBuffer *buffer); + +/* + * @brief put a short value into buffer order with big endian. + * + * @param[in] buff the instance of gdk buffer. + * @param[in] short_value the short value that insert into buffer.. + * + * @return true if uint8 was write successfully, otherwise false. + */ +bool HdfBlockBufferWriteShort(struct BlockBuffer *buffer, uint16_t shortValue); + +/* + * @brief get buffer space size. + * + * @param[in] buff the instance of gdk buffer. + * @param[in] start the start index of duplicate buffer rang. + * @param[in] end the end index of duplicate buffer rang. + * + * @return the new instance of buff which contain specific packet. + */ +struct HdfBlockBuffer *HdfBlockBufferDuplicate(const struct HdfBlockBuffer *buffer, uint16_t start, uint16_t end); + +/* + * @brief append an byte array packet into buffer. + * + * @param[in] buff the instance of gdk buffer. + * @param[in] data the start address of byte array. + * @param[in] length the length of byte array. + * + * @return void + */ +void HdfBlockBufferRewind(struct HdfBlockBuffer *buffer); + +/* + * @brief put a byte into buffer. + * + * @param[in] buff -the instance of gdk buffer. + * @param[in] value -the byte value that insert into buffer.. + * + * @return true if uint8 was write successfully, otherwise false. + */ +bool HdfBlockBufferPutc(struct HdfBlockBuffer *buffer, uint8_t value); + +/* + * @brief append an byte array packet into buffer. + * + * @param[in] buff the instance of gdk buffer. + * @param[in] data the start address of byte array. + * @param[in] length the length of byte array. + * + * @return true if operation is success, otherwise false. + */ +bool HdfBlockBufferWriteData(struct HdfBlockBuffer *buffer, uint8_t *data, size_t length); + +bool HdfBlockBufferWriteBuff(struct HdfBlockBuffer *dst, struct HdfBlockBuffer *src); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* BLOCK_BUFFER_H */ diff --git a/utils/include/hdf_blocking_queue.h b/utils/include/hdf_blocking_queue.h new file mode 100644 index 0000000000000000000000000000000000000000..7b51f3a8d46e0601977ebc596adb9c7fbaba3849 --- /dev/null +++ b/utils/include/hdf_blocking_queue.h @@ -0,0 +1,53 @@ +/* + * Copyright (c) 2021-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 BLOCKING_QUEUE_H +#define BLOCKING_QUEUE_H + +#include "hdf_slist.h" +#include "osal_sem.h" +#include "osal_mutex.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct HdfBlockingQueue { + struct HdfSList list; + struct OsalSem sem; + struct OsalMutex mutex; +}; + +struct HdfSListEntry { + struct HdfSListNode node; + void *data; +}; + +void HdfBlockingQueue_Init(struct HdfBlockingQueue *queue); + +void HdfBlockingQueueDestroy(struct HdfBlockingQueue *queue); + +void HdfBlockingQueueFlush(struct HdfBlockingQueue *queue); + +void *HdfBlockingQueueTake(struct HdfBlockingQueue *queue); + +void *HdfBlockingQueueGet(struct HdfBlockingQueue *queue); + +void HdfBlockingQueueRemove(struct HdfBlockingQueue *queue, void *data); + +void *HdfBlockingQueuePoll(struct HdfBlockingQueue *queue, long timeout); + +void HdfBlockingQueueOffer(struct HdfBlockingQueue *queue, void *val); + +void *HdfBlockingQueueFind(struct HdfBlockingQueue *queue, long match_key, SlList_Comparer comparer); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* BLOCKING_QUEUE_H */ diff --git a/utils/include/hdf_cstring.h b/utils/include/hdf_cstring.h index 8e261c5f2e9b7153bb52bd11d161e78867c44ec8..a2374f300bb466b94550bd5dcba1063cdcf8522d 100644 --- a/utils/include/hdf_cstring.h +++ b/utils/include/hdf_cstring.h @@ -23,6 +23,7 @@ struct HdfCString { uint32_t HdfStringMakeHashKey(const char *key, uint32_t mask); struct HdfCString *HdfCStringObtain(const char *str); void HdfCStringRecycle(struct HdfCString *inst); +char *HdfStringCopy(const char *src); #ifdef __cplusplus } diff --git a/utils/include/hdf_object_alloc.h b/utils/include/hdf_object_alloc.h new file mode 100644 index 0000000000000000000000000000000000000000..bfc6d6d4553ce01adaef6caf6891fffff24a3ea4 --- /dev/null +++ b/utils/include/hdf_object_alloc.h @@ -0,0 +1,42 @@ +/* + * Copyright (c) 2021-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 OBJECT_ALLOC_H +#define OBJECT_ALLOC_H + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +struct HdfObjectChunkConfig { + uint32_t chunkSize; + uint32_t chunkCount; +}; + +struct HdfObjectPoolConfig { + char *buffer; + uint32_t bufferSize; + uint32_t numChunks; + const struct HdfObjectChunkConfig *chunks; +}; + +void *HdfObjectAllocAlloc(size_t size); + +void HdfObjectAllocFree(void *object); + +const struct HdfObjectPoolConfig *ObjectAllocGetConfig(void); +void HdfObjectAllocInit(); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* BLOCK_BUFFER_H */ + diff --git a/utils/include/hdf_ordered_list.h b/utils/include/hdf_ordered_list.h new file mode 100644 index 0000000000000000000000000000000000000000..6f9aa2ba6b3be9e1867a43ceefd93a93798e2e97 --- /dev/null +++ b/utils/include/hdf_ordered_list.h @@ -0,0 +1,58 @@ +/* + * Copyright (c) 2021-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_ORDERED_LIST_H +#define HDF_ORDERED_LIST_H + +#include "hdf_slist.h" +#include "osal_mutex.h" +#include "osal_sem.h" + +#ifdef __cplusplus +extern "C" { +#endif + +struct HdfOrderedList { + struct HdfSList head; + struct OsalSem sem; + struct OsalMutex mutex; +}; + +struct HdfOrderedListEntity { + struct HdfSListNode node; + long key; +}; + +typedef void (*HdfOrderedListEntityDeleter)(struct HdfOrderedListEntity *); + +typedef bool (*HdfOrderedListComparer)(long, void *); + +void HdfOrderedListInit(struct HdfOrderedList *list); + +void HdfOrderedListDestroy(struct HdfOrderedList *list); + +int HdfOrderedListIsEmpty(struct HdfOrderedList *list); + +void HdfOrderedListOffer(struct HdfOrderedList *list, struct HdfOrderedListEntity *newEntity); + +struct HdfOrderedListEntity *HdfOrderedListTake(struct HdfOrderedList *list); + +struct HdfOrderedListEntity *HdfOrderedListFetch( + struct HdfOrderedList *list, long match_key, HdfOrderedListComparer comparer); + +int HdfOrderedListWait(struct HdfOrderedList *list, long timeout); + +long HdfOrderedListPeekKey(struct HdfOrderedList *list); + +void HdfOrderedListFlush(struct HdfOrderedList *list, HdfOrderedListEntityDeleter deleter); + +#ifdef __cplusplus +} +#endif /* __cplusplus */ + +#endif /* HDF_ORDERED_LIST_H */ diff --git a/ability/sbuf/include/hdf_sbuf_impl.h b/utils/include/hdf_sbuf_impl.h similarity index 100% rename from ability/sbuf/include/hdf_sbuf_impl.h rename to utils/include/hdf_sbuf_impl.h diff --git a/utils/include/hdf_task_queue.h b/utils/include/hdf_task_queue.h new file mode 100755 index 0000000000000000000000000000000000000000..31faa1a9d668cd63098908526a7969017a57ccdd --- /dev/null +++ b/utils/include/hdf_task_queue.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 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_TASK_QUEUE_H +#define HDF_TASK_QUEUE_H + +#include "hdf_dlist.h" +#include "osal_sem.h" +#include "osal_mutex.h" +#include "osal_thread.h" + +struct HdfTaskType; +typedef int32_t (*HdfTaskFunc)(struct HdfTaskType *para); + +struct HdfTaskType { + struct DListHead node; + HdfTaskFunc func; +}; + +struct HdfTaskQueue { + struct OsalSem sem; + struct OsalMutex mutex; + struct DListHead head; + struct OsalThread thread; + bool threadRunFlag; + HdfTaskFunc queueFunc; + const char *queueName; +}; + +void HdfTaskEnqueue(struct HdfTaskQueue *queue, struct HdfTaskType *task); +struct HdfTaskQueue *HdfTaskQueueCreate(HdfTaskFunc queueFunc, const char *name); +void HdfTaskQueueDestroy(struct HdfTaskQueue *queue); + +#endif /* HDF_TASK_QUEUE_H */ \ No newline at end of file diff --git a/ability/config/device_resource_if.c b/utils/src/hcs_parser/device_resource_if.c similarity index 100% rename from ability/config/device_resource_if.c rename to utils/src/hcs_parser/device_resource_if.c diff --git a/ability/config/hcs_parser/src/hcs_blob_if.c b/utils/src/hcs_parser/hcs_blob_if.c similarity index 100% rename from ability/config/hcs_parser/src/hcs_blob_if.c rename to utils/src/hcs_parser/hcs_blob_if.c diff --git a/utils/src/hcs_parser/hcs_buildin_parser.c b/utils/src/hcs_parser/hcs_buildin_parser.c new file mode 100644 index 0000000000000000000000000000000000000000..b0bc91c4887d1faa240c04b04273ccce6f504d58 --- /dev/null +++ b/utils/src/hcs_parser/hcs_buildin_parser.c @@ -0,0 +1,56 @@ +/* + * 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 "hcs_parser.h" +#include "hcs_blob_if.h" +#include "hcs_generate_tree.h" +#include "hdf_log.h" +#include "osal_mem.h" + +#define HDF_LOG_TAG hcs_parser + +#include "hcs_blob_if.h" +#include "hcs_parser.h" +#include "hcs_tree_if.h" +#include "hdf_base.h" +#include "hdf_log.h" + +static struct DeviceResourceNode *g_hcsTreeRoot = NULL; + +void __attribute__((weak)) HdfGetBuildInConfigData(const unsigned char **data, unsigned int *size); + +static bool BuildHcsTree(void) +{ + uint32_t length; + const unsigned char *hcsBlob = NULL; + if (HdfGetBuildInConfigData == NULL) { + HDF_LOGE("no build-in hdf config"); + return false; + } + HdfGetBuildInConfigData(&hcsBlob, &length); + if (!HcsCheckBlobFormat((const char *)hcsBlob, length)) { + return false; + } + if (!HcsDecompile((const char *)hcsBlob, HBC_HEADER_LENGTH, &g_hcsTreeRoot)) { + return false; + } + return true; +} + +const struct DeviceResourceNode *HcsGetRootNode(void) +{ + if (g_hcsTreeRoot == NULL && !BuildHcsTree()) { + HDF_LOGE("failed to rebuild config tree"); + return NULL; + } + + if (g_hcsTreeRoot == NULL) { + HDF_LOGE("failed to get build-in hcs root node"); + } + return g_hcsTreeRoot; +} \ No newline at end of file diff --git a/ability/config/hcs_parser/src/hcs_generate_tree.c b/utils/src/hcs_parser/hcs_generate_tree.c similarity index 92% rename from ability/config/hcs_parser/src/hcs_generate_tree.c rename to utils/src/hcs_parser/hcs_generate_tree.c index c3306ed641349815762c3144de5a3dd2bf6f0e3f..672c29db530e47377638467e9f7394963355be79 100644 --- a/ability/config/hcs_parser/src/hcs_generate_tree.c +++ b/utils/src/hcs_parser/hcs_generate_tree.c @@ -31,12 +31,13 @@ static struct DeviceResourceNode *CreateTreeNode(const char *start, int32_t offs struct DeviceResourceNode *parentNode, char **treeMem) { struct DeviceResourceNode *newNode = (struct DeviceResourceNode *)(*treeMem); + struct DeviceResourceNode *curNode = NULL; *treeMem += sizeof(struct DeviceResourceNode); newNode->name = start + offset + HCS_PREFIX_LENGTH; newNode->hashValue = offset + sizeof(struct HbcHeader); if (parentNode != NULL) { newNode->parent = parentNode; - struct DeviceResourceNode *curNode = parentNode->child; + curNode = parentNode->child; while ((curNode != NULL) && (curNode->sibling != NULL)) { curNode = curNode->sibling; } @@ -64,15 +65,17 @@ static bool UpdateTreeStack(struct TreeStack **treeStack, int32_t *treeLayer, st static bool AddAttrInNode(const char *start, struct DeviceResourceNode *parentNode, char **treeMem) { + struct DeviceResourceAttr *newAttr = NULL; + struct DeviceResourceAttr *curAttr = NULL; if (parentNode == NULL) { HDF_LOGE("%s failed, the parentNode is NULL", __func__); return false; } - struct DeviceResourceAttr *newAttr = (struct DeviceResourceAttr *)(*treeMem); + newAttr = (struct DeviceResourceAttr *)(*treeMem); *treeMem += sizeof(struct DeviceResourceAttr); newAttr->name = start + HCS_PREFIX_LENGTH; newAttr->value = start + HCS_PREFIX_LENGTH + HCS_STRING_LENGTH(newAttr->name); - struct DeviceResourceAttr *curAttr = parentNode->attrData; + curAttr = parentNode->attrData; parentNode->attrData = newAttr; newAttr->next = curAttr; return true; @@ -82,12 +85,14 @@ static int32_t ParseByteCode(const char *treeStart, int32_t offset, char **treeM struct TreeStack **treeStack, int32_t *treeLayerOrMemLen) { int32_t termOffset = HcsGetNodeOrAttrLength(treeStart + offset); + struct DeviceResourceNode *parentOrCurNode = NULL; + struct DeviceResourceNode *newNode = NULL; + uint32_t newNodeOffset; if (termOffset <= 0) { HDF_LOGE("%s failed, HcsGetNodeOrAttrLength error, errno: %d", __func__, termOffset); return HDF_FAILURE; } - struct DeviceResourceNode *parentOrCurNode = NULL; switch (HcsGetPrefix(treeStart + offset)) { case CONFIG_NODE: if (*treeMem == NULL) { @@ -95,8 +100,7 @@ static int32_t ParseByteCode(const char *treeStart, int32_t offset, char **treeM break; } parentOrCurNode = GetParentNode(offset, *treeStack, treeLayerOrMemLen, termOffset); - struct DeviceResourceNode *newNode = CreateTreeNode(treeStart, offset, parentOrCurNode, treeMem); - uint32_t newNodeOffset; + newNode = CreateTreeNode(treeStart, offset, parentOrCurNode, treeMem); (void)HcsSwapToUint32(&newNodeOffset, treeStart + offset + HCS_STRING_LENGTH(newNode->name) + HCS_PREFIX_LENGTH, CONFIG_DWORD); newNodeOffset += offset + termOffset; diff --git a/ability/config/hcs_parser/include/hcs_generate_tree.h b/utils/src/hcs_parser/hcs_generate_tree.h similarity index 100% rename from ability/config/hcs_parser/include/hcs_generate_tree.h rename to utils/src/hcs_parser/hcs_generate_tree.h diff --git a/ability/config/hcs_parser/src/hcs_parser.c b/utils/src/hcs_parser/hcs_parser.c similarity index 82% rename from ability/config/hcs_parser/src/hcs_parser.c rename to utils/src/hcs_parser/hcs_parser.c index 29596bd54ed0908814af88e9ba0f9a9a62a320df..b12380ff7bae5fe96ebb9b8158a37255f20fb98e 100644 --- a/ability/config/hcs_parser/src/hcs_parser.c +++ b/utils/src/hcs_parser/hcs_parser.c @@ -22,23 +22,26 @@ static int32_t GetHcsTreeSize(const char *blob, int32_t nodeLength) bool HcsDecompile(const char *hcsBlob, uint32_t offset, struct DeviceResourceNode **root) { int32_t nodeLength = HcsGetNodeLength(hcsBlob + offset); + int32_t treeMemLength; + char *treeMem = NULL; + int32_t treeLayer; if (nodeLength < 0) { HDF_LOGE("%s failed, HcsGetNodeLength error", __func__); return false; } - int32_t treeMemLength = GetHcsTreeSize(hcsBlob + offset, nodeLength); + treeMemLength = GetHcsTreeSize(hcsBlob + offset, nodeLength); if (treeMemLength <= 0) { HDF_LOGE("%s failed, GetHcsTreeSize error, treeMemLength = %d", __func__, treeMemLength); return false; } - char *treeMem = (char *)OsalMemCalloc(treeMemLength); + treeMem = (char *)OsalMemCalloc(treeMemLength); if (treeMem == NULL) { HDF_LOGE("%s failed, OsalMemCalloc error", __func__); return false; } - int32_t treeLayer = GenerateCfgTree(hcsBlob + offset, nodeLength, treeMem, root); + treeLayer = GenerateCfgTree(hcsBlob + offset, nodeLength, treeMem, root); if (treeLayer <= 0) { HDF_LOGE("%s failed, the treeLayer is %d", __func__, treeLayer); OsalMemFree(treeMem); diff --git a/ability/config/hcs_parser/src/hcs_tree_if.c b/utils/src/hcs_parser/hcs_tree_if.c similarity index 100% rename from ability/config/hcs_parser/src/hcs_tree_if.c rename to utils/src/hcs_parser/hcs_tree_if.c diff --git a/ability/config/test/unittest/common/hdf_config_test.cpp b/utils/src/hcs_parser/test/unittest/common/hdf_config_test.cpp similarity index 78% rename from ability/config/test/unittest/common/hdf_config_test.cpp rename to utils/src/hcs_parser/test/unittest/common/hdf_config_test.cpp index 75f6541c1630cedc0d43a85b99a0ab2be52d84ef..1a5df911c08f7d21a8d7b0aea4c0345f1de7d887 100644 --- a/ability/config/test/unittest/common/hdf_config_test.cpp +++ b/utils/src/hcs_parser/test/unittest/common/hdf_config_test.cpp @@ -64,6 +64,20 @@ enum HdfTestCaseCmd { HDF_GET_STRING_ARRAY_ELEM_ATTR_VALUE_002, HDF_GET_NODE_BY_ATTR_REF_001, HDF_GET_NODE_BY_ATTR_REF_002, + HDF_MACRO_GET_ONE_NODE, + HDF_MACRO_CHECK_NODE_EXISTS, + HDF_MACRO_CHECK_NODE_NOT_EXISTS, + HDF_MACRO_GET_ONE_NODE_PROP, + HDF_MACRO_CHECK_NODE_PROP_EXISTS, + HDF_MACRO_CHECK_NODE_PROP_NOT_EXISTS, + HDF_MACRO_TRAVERSAL_ONE_NODE, + HDF_MACRO_GET_ARRAY_SIZE, + HDF_MACRO_GET_ONE_ARRAY_ELEMENT, + HDF_MACRO_TRAVERSAL_ONE_ARRAY, + HDF_MACRO_TRAVERSAL_ALL_ARRAY, + HDF_MACRO_TRAVERSAL_NODE_CHILD, + HDF_MACRO_TRAVERSAL_NODE_CHILD_VARGS, + HDF_MACRO_GET_ONE_FILE, }; class HdfConfigTest : public testing::Test { @@ -582,7 +596,176 @@ HWTEST_F(HdfConfigTest, HslTestGetNodeAttrRefSuccess001, TestSize.Level1) HWTEST_F(HdfConfigTest, HslTestGetNodeAttrRefFail001, TestSize.Level1) { struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_GET_NODE_BY_ATTR_REF_002, HDF_MSG_RESULT_DEFAULT}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HslTestMacroGetOneNode + * @tc.desc: HDF_MACRO_GET_ONE_NODE test + * @tc.type: FUNC + * @tc.require: AR000GGTQK + */ +HWTEST_F(HdfConfigTest, HslTestMacroGetOneNode, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_MACRO_GET_ONE_NODE, HDF_MSG_RESULT_DEFAULT}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HslTestMacroGetOneNode + * @tc.desc: HDF_MACRO_CHECK_NODE_EXISTS test + * @tc.type: FUNC + * @tc.require: AR000GGTQK + */ +HWTEST_F(HdfConfigTest, HslTestMacroCheckNodeExists, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_MACRO_CHECK_NODE_EXISTS, HDF_MSG_RESULT_DEFAULT}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HslTestMacroGetOneNode + * @tc.desc: HDF_MACRO_CHECK_NODE_NOT_EXISTS test + * @tc.type: FUNC + * @tc.require: AR000GGTQK + */ +HWTEST_F(HdfConfigTest, HslTestMacroCheckNodeNotExists, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_MACRO_CHECK_NODE_NOT_EXISTS, HDF_MSG_RESULT_DEFAULT}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HslTestMacroGetOneNode + * @tc.desc: HDF_MACRO_GET_ONE_NODE_PROP test + * @tc.type: FUNC + * @tc.require: AR000GGTQK + */ +HWTEST_F(HdfConfigTest, HslTestMacroGetOneNodeProp, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_MACRO_GET_ONE_NODE_PROP, HDF_MSG_RESULT_DEFAULT}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HslTestMacroGetOneNode + * @tc.desc: HDF_MACRO_CHECK_NODE_PROP_EXISTS test + * @tc.type: FUNC + * @tc.require: AR000GGTQK + */ +HWTEST_F(HdfConfigTest, HslTestMacroCheckNodePropExists, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_MACRO_CHECK_NODE_PROP_EXISTS, HDF_MSG_RESULT_DEFAULT}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HslTestMacroGetOneNode + * @tc.desc: HDF_MACRO_CHECK_NODE_PROP_NOT_EXISTS test + * @tc.type: FUNC + * @tc.require: AR000GGTQK + */ +HWTEST_F(HdfConfigTest, HslTestMacroCheckNodePropNotExists, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_MACRO_CHECK_NODE_PROP_NOT_EXISTS, HDF_MSG_RESULT_DEFAULT}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HslTestMacroGetOneNode + * @tc.desc: HDF_MACRO_TRAVERSAL_ONE_NODE test + * @tc.type: FUNC + * @tc.require: AR000GGTQK + */ +HWTEST_F(HdfConfigTest, HslTestMacroTraversalOneNode, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_MACRO_TRAVERSAL_ONE_NODE, HDF_MSG_RESULT_DEFAULT}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HslTestMacroGetOneNode + * @tc.desc: HDF_MACRO_GET_ARRAY_SIZE test + * @tc.type: FUNC + * @tc.require: AR000GGTQK + */ +HWTEST_F(HdfConfigTest, HslTestMacroGetArraySize, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_MACRO_GET_ARRAY_SIZE, HDF_MSG_RESULT_DEFAULT}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HslTestMacroGetOneNode + * @tc.desc: HDF_MACRO_GET_ONE_ARRAY_ELEMENT test + * @tc.type: FUNC + * @tc.require: AR000GGTQK + */ +HWTEST_F(HdfConfigTest, HslTestMacroGetOneArrayElevent, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_MACRO_GET_ONE_ARRAY_ELEMENT, HDF_MSG_RESULT_DEFAULT}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HslTestMacroGetOneNode + * @tc.desc: HDF_MACRO_TRAVERSAL_ONE_ARRAY test + * @tc.type: FUNC + * @tc.require: AR000GGTQK + */ +HWTEST_F(HdfConfigTest, HslTestMacroTraversalOneArray, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_MACRO_TRAVERSAL_ONE_ARRAY, HDF_MSG_RESULT_DEFAULT}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HslTestMacroGetOneNode + * @tc.desc: HDF_MACRO_TRAVERSAL_ALL_ARRAY test + * @tc.type: FUNC + * @tc.require: AR000GGTQK + */ +HWTEST_F(HdfConfigTest, HslTestMacroTraversalAllArray, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_MACRO_TRAVERSAL_ALL_ARRAY, HDF_MSG_RESULT_DEFAULT}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HslTestMacroGetOneNode + * @tc.desc: HDF_MACRO_TRAVERSAL_NODE_CHILD test + * @tc.type: FUNC + * @tc.require: AR000GGTQK + */ +HWTEST_F(HdfConfigTest, HslTestMacroTraversalNodeChild, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_MACRO_TRAVERSAL_NODE_CHILD, HDF_MSG_RESULT_DEFAULT}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HslTestMacroGetOneNode + * @tc.desc: HDF_MACRO_TRAVERSAL_NODE_CHILD_VARGS test + * @tc.type: FUNC + * @tc.require: SR000GGTQI + */ +HWTEST_F(HdfConfigTest, HslTestMacroTraversalNodeChildVargs, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_MACRO_TRAVERSAL_NODE_CHILD_VARGS, HDF_MSG_RESULT_DEFAULT}; + EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); +} + +/** + * @tc.name: HslTestMacroGetOneNode + * @tc.desc: HDF_MACRO_GET_ONE_FILE test + * @tc.type: FUNC + * @tc.require: SR000GGTQI + */ +HWTEST_F(HdfConfigTest, HslTestMacroTraversalOneFile, TestSize.Level1) +{ + struct HdfTestMsg msg = {TEST_CONFIG_TYPE, HDF_MACRO_GET_ONE_FILE, HDF_MSG_RESULT_DEFAULT}; printf("HdfConfigTest last enter\n\r"); EXPECT_EQ(0, HdfTestSendMsgToService(&msg)); } + }; diff --git a/utils/src/hdf_block_buffer.c b/utils/src/hdf_block_buffer.c new file mode 100644 index 0000000000000000000000000000000000000000..e5deb0387360bb390561b71cb93137e9a42d769d --- /dev/null +++ b/utils/src/hdf_block_buffer.c @@ -0,0 +1,218 @@ +/* + * 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_block_buffer.h" +#include "osal_mem.h" +#include "securec.h" + +static const unsigned int OFFSET = 8; + +struct HdfHdfBlockBuffer *HdfHdfBlockBufferNew(const uint8_t *data, uint16_t size) +{ + uint16_t wantedSize; + struct HdfBlockBuffer *buffer = NULL; + if (size == 0) { + return NULL; + } + wantedSize = sizeof(struct HdfBlockBuffer) + size; + buffer = (struct HdfBlockBuffer *)OsalMemAlloc(wantedSize); + if (buffer == NULL) { + return NULL; + } + buffer->dataSize = size; + buffer->position = 0; + if (data != NULL) { + if (memcpy_s(buffer->data, buffer->dataSize, data, size) != EOK) { + OsalMemFree(buffer); + return NULL; + } + } + return buffer; +} + +void HdfBlockBufferFree(const struct HdfBlockBuffer *buffer) +{ + if (buffer != NULL) { + OsalMemFree(buffer); + } +} + +uint16_t HdfBlockBufferGetDataSize(struct HdfBlockBuffer *buffer) +{ + return (buffer == NULL) ? 0 : buffer->dataSize; +} + +uint16_t HdfBlockBufferGetAvailableSize(struct HdfBlockBuffer *buffer) +{ + return (buffer == NULL) ? 0 : (buffer->dataSize - buffer->position); +} + +uint8_t *HdfBlockBufferRead(struct HdfBlockBuffer *buffer, uint16_t size) +{ + uint8_t *dataPtr = NULL; + if ((buffer == NULL) || (buffer->dataSize - buffer->position < size)) { + return NULL; + } + dataPtr = &buffer->data[buffer->position]; + buffer->position += size; + return dataPtr; +} + +uint8_t *HdfBlockBufferGetData(struct HdfBlockBuffer *buffer) +{ + return (buffer == NULL) ? NULL : &buffer->data[0]; +} + +uint16_t HdfBlockBufferGetPoistion(struct HdfBlockBuffer *buffer) +{ + return (buffer == NULL) ? 0 : buffer->position; +} + + +uint16_t HdfBlockBufferSkipBytes(struct HdfBlockBuffer *buffer, uint16_t bytes) +{ + if (buffer == NULL) { + return 0; + } + if (buffer->position + bytes <= buffer->dataSize) { + buffer->position += bytes; + return buffer->dataSize - buffer->position; + } else { + buffer->position = buffer->dataSize; + return 0; + } +} + +bool HdfBlockBufferReadUint8(struct HdfBlockBuffer *buffer, uint8_t *outValue) +{ + if (buffer == NULL) { + return false; + } + if (buffer->position + BYTES_UINT8 <= buffer->dataSize) { + *outValue = buffer->data[buffer->position++]; + return true; + } + return false; +} + +bool HdfBlockBufferReadUint8At(struct HdfBlockBuffer *buffer, uint16_t idx, uint8_t *outValue) +{ + if (buffer == NULL) { + return false; + } + if (idx + BYTES_UINT8 <= buffer->dataSize) { + *outValue = buffer->data[idx]; + return true; + } + return false; +} + +bool HdfBlockBufferReadUint16(struct HdfBlockBuffer *buffer, uint16_t *outValue) +{ + if (buffer == NULL) { + return false; + } + if (buffer->position + BYTES_UINT16 <= buffer->dataSize) { + *outValue = read_be16(buffer->data, buffer->position); + buffer->position += BYTES_UINT16; + return true; + } + return false; +} + +bool HdfBlockBufferReadUint16At(struct HdfBlockBuffer *buffer, size_t idx, uint16_t *outValue) +{ + if (buffer == NULL) { + return false; + } + if (idx + BYTES_UINT16 <= buffer->dataSize) { + *outValue = read_be16(buffer->data, idx); + return true; + } + return false; +} + +void HdfBlockBufferRewind(struct HdfBlockBuffer *buffer) +{ + if (buffer != NULL) { + buffer->position = 0; + } +} + +bool HdfBlockBufferWriteUint8(struct HdfBlockBuffer *buffer, uint8_t value) +{ + if (buffer == NULL) { + return false; + } + if (buffer->position + sizeof(uint8_t) <= buffer->dataSize) { + buffer->data[buffer->position++] = value; + return true; + } + return false; +} + +bool HdfBlockBufferWriteUint16(struct HdfBlockBuffer *buffer, uint16_t inValue) +{ + if (buffer == NULL) { + return false; + } + if (buffer->position + BYTES_UINT16 <= buffer->dataSize) { + buffer->data[buffer->position++] = (uint8_t) (inValue >> OFFSET); + buffer->data[buffer->position++] = (uint8_t) (inValue & 0xFF); + return true; + } + return false; +} + +bool HdfBlockBufferWriteData(struct HdfBlockBuffer *buffer, uint8_t *data, size_t length) +{ + uint16_t residualSize; + if (buffer == NULL) { + return false; + } + residualSize = buffer->dataSize - buffer->position; + if (memcpy_s(buffer->data + buffer->position, residualSize, data, length) != EOK) { + return false; + } + buffer->position += length; + return true; +} + +struct HdfBlockBuffer *HdfBlockBufferDuplicate(const struct HdfBlockBuffer *buffer, uint16_t start, uint16_t end) +{ + uint16_t bufferSize = HdfBlockBufferGetDataSize(buffer); + uint16_t newBufferSize; + struct HdfBlockBuffer *newBuffer = NULL; + if ((buffer == NULL) || (start > end)) { + return NULL; + } + if ((end > bufferSize) || (start > bufferSize)) { + return NULL; + } + newBufferSize = end - start + 1; + newBuffer = HdfBlockBufferNew(newBufferSize); + if (newBuffer == NULL) { + return NULL; + } + if (memcpy_s(newBuffer->data, newBufferSize, buffer->data + start, newBufferSize) != EOK) { + OsalMemFree(newBuffer); + return NULL; + } + + return newBuffer; +} + +bool HdfBlockBufferWriteBuff(struct HdfBlockBuffer *dst, struct HdfBlockBuffer *src) +{ + if (memcpy_s(&dst->data[dst->position], dst->dataSize - dst->position, src->data, src->dataSize) != EOK) { + return false; + } + dst->position += src->dataSize; + return true; +} + diff --git a/utils/src/hdf_blocking_queue.c b/utils/src/hdf_blocking_queue.c new file mode 100644 index 0000000000000000000000000000000000000000..ed419b58caa730a23f9294d78ea4fef9784bb00a --- /dev/null +++ b/utils/src/hdf_blocking_queue.c @@ -0,0 +1,125 @@ +/* + * Copyright (c) 2021-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 "blocking_queue.h" + +void HdfBlockingQueueInit(struct HdfBlockingQueue *queue) +{ + HdfSListInit(&queue->list); + OsalSemInit(&queue->sem); + OsalMutexInit(&queue->mutex); +} + +void HdfBlockingQueueDestroy(struct HdfBlockingQueue *queue) +{ + HdfSListInit(&queue->list); + OsalSemDestroy(&queue->sem); + OsalMutexDestroy(&queue->mutex); +} + +void HdfBlockingQueueFlush(struct HdfBlockingQueue *queue) +{ + OsalMutexLock(&queue->mutex); + HdfSListFlush(&queue->list, HdfSListRemove); + OsalMutexUnlock(&queue->mutex); + OsalSemPost(&queue->sem); +} + +void *HdfBlockingQueueTake(struct HdfBlockingQueue *queue) +{ + void *data = HdfBlockingQueueGet(queue); + if (data == NULL) { + OsalSemWait(&queue->sem, OSAL_WAIT_FOREVER); + data = HdfBlockingQueueGet(queue); + } + return data; +} + +void *HdfBlockingQueueGet(struct HdfBlockingQueue *queue) +{ + void *data = NULL; + struct HdfSListEntry *entry; + OsalMutexLock(&queue->mutex); + entry = (struct HdfSListEntry *)HdfSListPeek(&queue->list); + OsalMutexUnlock(&queue->mutex); + if (entry != NULL) { + data = entry->data; + HdfSListEntryFree(entry); + } + return data; +} + + +void *HdfBlockingQueueFind(struct HdfBlockingQueue *queue, long matchKey, SlList_Comparer comparer) +{ + void *matchData = NULL; + struct HdfSListIterator it; + struct HdfSListEntry *entry = NULL; + if (comparer == NULL) { + return NULL; + } + OsalMutexLock(&queue->mutex); + HdfSListIteratorInit(&it, &queue->list); + while (HdfSListIteratorHasNext(&it)) { + entry = (struct HdfSListEntry *) HdfSListIteratorNext(&it); + if (comparer(matchKey, entry->data)) { + matchData = entry->data; + break; + } + } + OsalMutexUnlock(&queue->mutex); + return matchData; +} + +void HdfBlockingQueueRemove(struct HdfBlockingQueue *queue, void *data) +{ + bool targetListChanged = false; + struct HdfSListIterator it; + struct HdfSListEntry *entry = NULL; + OsalMutexLock(&queue->mutex); + HdfSListIteratorInit(&it, &queue->list); + while (HdfSListIteratorHasNext(&it)) { + entry = (struct HdfSListEntry *)HdfSListIteratorNext(&it); + if (entry->data == data) { + HdfSListIteratorRemove(&it); + HdfSListEntryFree(entry); + targetListChanged = true; + break; + } + } + OsalMutexUnlock(&queue->mutex); + if (targetListChanged) { + OsalSemPost(&queue->sem); + } +} + +void *HdfBlockingQueuePoll(struct HdfBlockingQueue *queue, long timeout) +{ + void *data = HdfBlockingQueueGet(queue); + if (data == NULL) { + OsalSemWait(&queue->sem, timeout); + data = HdfBlockingQueueGet(queue); + } + return data; +} + +int HdfBlockingQueueOffer(struct HdfBlockingQueue *queue, void *val, long timeout) +{ + struct HdfSListEntry *entry = NULL; + if (OsalSemWait(&queue->sem, timeout) != 0) { + return -1; + } + entry = HdfSListEntryNew(val); + if (entry != NULL) { + OsalMutexLock(&queue->mutex); + HdfSListAddTail(&queue->list, &entry->node); + OsalMutexUnlock(&queue->mutex); + } + OsalSemPost(&queue->sem); +} + diff --git a/utils/src/hdf_cstring.c b/utils/src/hdf_cstring.c index 761e216594189958f4df009e5c485fa75ff9a938..a5d503fd8a5cfd40c95a57c6dcfb5e19fde4862b 100644 --- a/utils/src/hdf_cstring.c +++ b/utils/src/hdf_cstring.c @@ -26,12 +26,13 @@ uint32_t HdfStringMakeHashKey(const char *key, uint32_t mask) struct HdfCString *HdfCStringObtain(const char *str) { struct HdfCString *instance = NULL; + size_t size; if (str != NULL) { size_t strLen = strlen(str); if (strLen > CSTRING_MAX) { return NULL; } - size_t size = sizeof(struct HdfCString) + strLen + 1; + size = sizeof(struct HdfCString) + strLen + 1; instance = (struct HdfCString *)OsalMemCalloc(size); if (instance == NULL) { HDF_LOGE("HdfCStringObtain failed, alloc memory failed"); @@ -53,3 +54,27 @@ void HdfCStringRecycle(struct HdfCString *inst) OsalMemFree(inst); } } + +char *HdfStringCopy(const char *src) +{ + char *newStr = NULL; + size_t srcSize; + size_t dstSize; + + if (src == NULL) { + return NULL; + } + srcSize = strlen(src); + dstSize = srcSize + 1; + newStr = OsalMemAlloc(dstSize); + if (newStr == NULL) { + return NULL; + } + + if (strncpy_s(newStr, dstSize, src, srcSize) != EOK) { + OsalMemFree(newStr); + newStr = NULL; + } + + return newStr; +} diff --git a/utils/src/hdf_map.c b/utils/src/hdf_map.c index 67e14f4516c9a8f7261f72bc0262ff0f333023dd..627c9e66e2c599b8e92248ebea68641643391f28 100644 --- a/utils/src/hdf_map.c +++ b/utils/src/hdf_map.c @@ -119,6 +119,7 @@ static struct MapNode *MapCreateNode(const char *key, uint32_t hash, int32_t MapSet(Map *map, const char *key, const void *value, uint32_t valueSize) { struct MapNode *node = NULL; + uint32_t hash; if (map == NULL || key == NULL || value == NULL || valueSize == 0) { return HDF_ERR_INVALID_PARAM; @@ -126,7 +127,7 @@ int32_t MapSet(Map *map, const char *key, const void *value, uint32_t valueSize) if (valueSize > HDF_MAP_KEY_MAX_SIZE || strlen(key) > HDF_MAP_VALUE_MAX_SIZE) { return HDF_ERR_INVALID_PARAM; } - uint32_t hash = MapHash(key); + hash = MapHash(key); if (map->nodeSize > 0 && map->nodes != NULL) { uint32_t idx = MapHashIdx(map, hash); node = map->nodes[idx]; @@ -167,13 +168,17 @@ int32_t MapSet(Map *map, const char *key, const void *value, uint32_t valueSize) void* MapGet(const Map *map, const char *key) { + uint32_t hash; + uint32_t idx; + struct MapNode *node = NULL; + if (map == NULL || key == NULL || map->nodeSize == 0 || map->nodes == NULL) { return NULL; } - uint32_t hash = MapHash(key); - uint32_t idx = MapHashIdx(map, hash); - struct MapNode *node = map->nodes[idx]; + hash = MapHash(key); + idx = MapHashIdx(map, hash); + node = map->nodes[idx]; while (node != NULL) { if (node->hash == hash && node->key != NULL && !strcmp(node->key, key)) { @@ -188,14 +193,19 @@ void* MapGet(const Map *map, const char *key) int32_t MapErase(Map *map, const char *key) { + uint32_t hash; + uint32_t idx; + struct MapNode *node = NULL; + struct MapNode *prev = NULL; + if (map == NULL || key == NULL || map->nodeSize == 0 || map->nodes == NULL) { return HDF_ERR_INVALID_PARAM; } - uint32_t hash = MapHash(key); - uint32_t idx = MapHashIdx(map, hash); - struct MapNode *node = map->nodes[idx]; - struct MapNode *prev = node; + hash = MapHash(key); + idx = MapHashIdx(map, hash); + node = map->nodes[idx]; + prev = node; while (node != NULL) { if (node->hash == hash && node->key != NULL && !strcmp(node->key, key)) { diff --git a/utils/src/hdf_object_alloc.c b/utils/src/hdf_object_alloc.c new file mode 100644 index 0000000000000000000000000000000000000000..1d310b3266c335e851d7a55b40aa295fa12f4314 --- /dev/null +++ b/utils/src/hdf_object_alloc.c @@ -0,0 +1,189 @@ +/* + * 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_object_alloc.h" +#include "hdf_slist.h" +#include "osal_mutex.h" + +struct HdfChunkLink { + uint32_t buffSize; + uint8_t *buffer; +}; + +struct HdfObjectNode { + struct HdfSListNode entry; + uint32_t chunkCount; + uint32_t freeCount; + uint32_t chunkSize; + struct HdfChunkLink **chunkStack; +}; + +struct HdfObjectAlloc { + struct HdfSList nodes; + struct OsalMutex mutex; + bool isConstructed; +}; +static const unsigned int ALIGN_MASK = 3; +#define ALIGN4(x) (uint32_t)(((uintptr_t)(x) + ALIGN_MASK) & (~ALIGN_MASK)) + +#define OBJECT_NODE_SIZE sizeof(struct ObjectNode) +#define OBJECT_CHUNK_COOKIE_SIZE (sizeof(struct ChunkLink) + sizeof(void *)) + +void HdfObjectAllocConstruct(struct HdfObjectAlloc *alloc) +{ + HdfSListInit(&alloc->nodes); + OsalMutexInit(&alloc->mutex); + alloc->isConstructed = true; +} +struct HdfObjectAlloc *HdfObjectAllocGetInstance() +{ + static struct HdfObjectAlloc instance = { 0 }; + + if (!instance.isConstructed) { + HdfObjectAllocConstruct(&instance); + } + + return &instance; +} + +struct HdfObjectNode *HdfObjectAllocFindSuitableChunk( + struct HdfObjectAlloc *alloc, size_t size) +{ + struct HdfSListIterator it; + struct HdfObjectNode *bestFitNode = NULL; + struct HdfObjectNode *objectNode = NULL; + HdfSListIteratorInit(&it, &alloc->nodes); + + while (HdfSListIteratorHasNext(&it)) { + objectNode = (struct HdfObjectNode *)HdfSListIteratorNext(&it); + if (size == objectNode->chunkSize) { + bestFitNode = objectNode; + break; + } else if (size < objectNode->chunkSize) { + bestFitNode = objectNode; + } + } + + return bestFitNode; +} + +static void HdfObjectAllocPushObjectNode( + struct HdfObjectAlloc *alloc, struct HdfObjectNode *node) +{ + struct HdfSListIterator it; + struct HdfObjectNode *objectNode = NULL; + HdfSListIteratorInit(&it, &alloc->nodes); + + while (HdfSListIteratorHasNext(&it)) { + objectNode = (struct HdfObjectNode *)HdfSListIteratorNext(&it); + if (node->chunkSize >= objectNode->chunkSize) { + break; + } + } + + HdfSListIteratorInsert(&it, &node->entry); +} + +static void HdfObjectAllocPreloadChunk( + void *chunkBuf, uint32_t buffSize, uint32_t chunkSize) +{ + struct HdfObjectAlloc *allocator = HdfObjectAllocGetInstance(); + + if (buffSize > OBJECT_NODE_SIZE) { + uint32_t idx; + struct ChunkLink *chunkLink; + struct ObjectNode *node; + uint32_t alignedSize = ALIGN4(chunkSize); + uint32_t alignedBufSize = ALIGN4(buffSize); + uint32_t blockSize = alignedSize + sizeof(struct ChunkLink); + uint8_t *alignedBuff = (uint8_t *)(uintptr_t)ALIGN4(chunkBuf); + node = (struct ObjectNode *)(alignedBuff + alignedBufSize - OBJECT_NODE_SIZE); + node->freeCount = 0; + node->chunkSize = alignedSize; + node->chunkCount = ((uint8_t *)node - alignedBuff) / (blockSize + sizeof(void *)); + node->chunkStack = (struct ChunkLink **)(alignedBuff + node->chunkCount * blockSize); + + for (idx = 0; idx < node->chunkCount; idx++) { + chunkLink = (struct ChunkLink *)&alignedBuff[idx * blockSize]; + chunkLink->buffSize = node->chunkSize; + node->chunkStack[node->freeCount++] = chunkLink; + chunkLink->buffer = (uint8_t *)(chunkLink + 1); + } + + HdfObjectAllocPushObjectNode(allocator, node); + } +} + +void HdfObjectAllocLoadConfigs(const struct HdfObjectPoolConfig *configs) +{ + uint32_t idx; + char *chunkBuffBegin = configs->buffer; + char *chunkBuffEnd = configs->buffer + configs->bufferSize; + + for (idx = 0; (idx < configs->numChunks) && (chunkBuffBegin < chunkBuffEnd); idx++) { + const struct ObjectChunkConfig *chunkConfig = &configs->chunks[idx]; + size_t chunkBufSize = OBJECT_NODE_SIZE + \ + (OBJECT_CHUNK_COOKIE_SIZE + chunkConfig->chunkSize) * chunkConfig->chunkCount; + + if (chunkBuffBegin + chunkBufSize <= chunkBuffEnd) { + HdfObjectAllocPreloadChunk(chunkBuffBegin, chunkBufSize, chunkConfig->chunkSize); + } + + chunkBuffBegin += chunkBufSize; + } +} + +void HdfObjectAllocInit() +{ + const struct HdfObjectPoolConfig *config = HdfObjectAllocGetConfig(); + + if (config != NULL) { + HdfObjectAllocLoadConfigs(config); + } +} + +void *HdfObjectAllocAlloc(size_t size) +{ + struct HdfChunkLink *chunkLink = NULL; + struct HdfObjectNode *objectNode = NULL; + struct HdfObjectAlloc *allocator = HdfObjectAllocGetInstance(); + OsalMutexLock(&allocator->mutex); + objectNode = HdfObjectAllocFindSuitableChunk(allocator, size); + if ((objectNode != NULL) && (objectNode->freeCount == 0)) { + goto finished; + } + + if (objectNode->freeCount > objectNode->chunkCount) { + if (objectNode->freeCount > objectNode->chunkCount) { + } + } + + chunkLink = (struct ChunkLink *)objectNode->chunkStack[--objectNode->freeCount]; +finished: + OsalMutexUnlock(&allocator->mutex); + return chunkLink ? chunkLink->buffer : NULL; +} + +void HdfObjectAllocFree(void *object) +{ + struct HdfChunkLink *chunkLink = container_of(void, object, struct ChunkLink, buffer); + struct HdfObjectNode *objectNode = NULL; + struct HdfObjectAlloc *allocator = HdfObjectAllocGetInstance(); + OsalMutexLock(&allocator->mutex); + objectNode = HdfObjectAllocFindSuitableChunk(allocator, chunkLink->buffSize); + if (objectNode != NULL) { + objectNode->chunkStack[objectNode->freeCount++] = chunkLink; + + if (objectNode->freeCount > objectNode->chunkCount) { + HDF_LOGE("exception: count,free:%d,total %d", objectNode->freeCount, objectNode->chunkCount); + } + } + + OsalMutexUnlock(&allocator->mutex); +} + diff --git a/utils/src/hdf_ordered_list.c b/utils/src/hdf_ordered_list.c new file mode 100644 index 0000000000000000000000000000000000000000..3f45ac33b4cad3f717a2b9a1d8cbc6685bb0503e --- /dev/null +++ b/utils/src/hdf_ordered_list.c @@ -0,0 +1,121 @@ +/* + * 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_ordered_list.h" + +void HdfOrderedListInit(struct HdfOrderedList *list) +{ + OsalMutexInit(&list->mutex); + OsalSemInit(&list->sem); + HdfSListInit(&list->head); +} + +void HdfOrderedListDestroy(struct HdfOrderedList *list) +{ + HdfSListInit(&list->head); + OsalSemDestroy(&list->sem); + OsalMutexDestroy(&list->mutex); +} + +int HdfOrderedListIsEmpty(struct HdfOrderedList *list) +{ + return HdfSListIsEmpty(&list->head); +} + +void HdfOrderedListOffer(struct HdfOrderedList *list, struct HdfOrderedListEntity *newEntity) +{ + struct HdfSListIterator it; + struct HdfOrderedListEntity *matchEntity; + if ((list == NULL) || (newEntity == NULL)) { + return; + } + OsalMutexLock(&list->mutex); + if (HdfSListIsEmpty(&list->head)) { + HdfSListAdd(&list->head, &newEntity->node); + goto finished; + } + HdfSListIteratorInit(&it, &list->head); + while (HdfSListIteratorHasNext(&it)) { + matchEntity = (struct HdfOrderedListEntity *)HdfSListIteratorNext(&it); + if (newEntity->key > matchEntity->key) { + HdfSListIteratorInsert(&it, &newEntity->node); + break; + } + } +finished: + OsalMutexUnlock(&list->mutex); + OsalSemPost(&list->sem); +} + +struct HdfOrderedListEntity *HdfOrderedListGet(struct HdfOrderedList *list) +{ + struct HdfOrderedListEntity *entity; + OsalMutexLock(&list->mutex); + entity = (struct HdfOrderedListEntity *)HdfSListPeek(&list->head); + OsalMutexUnlock(&list->mutex); + return entity; +} + +struct HdfOrderedListEntity *HdfOrderedListTake(struct HdfOrderedList *list) +{ + struct HdfOrderedListEntity *entity = HdfOrderedListGet(list); + while (entity == NULL) { + OsalSemWait(&list->sem, OSAL_WAIT_FOREVER); + entity = HdfOrderedListGet(list); + } + return entity; +} + +long HdfOrderedListPeekKey(struct HdfOrderedList *list) +{ + long orderedKey = 0; + struct HdfOrderedListEntity *firstEntity; + OsalMutexLock(&list->mutex); + firstEntity = (struct HdfOrderedListEntity *)HdfSListPeek(&list->head); + if (firstEntity != NULL) { + orderedKey = firstEntity->key; + } + OsalMutexUnlock(&list->mutex); + return orderedKey; +} + +struct HdfOrderedListEntity *HdfOrderedListFetch( + struct HdfOrderedList *list, long matchKey, HdfOrderedListComparer comparer) +{ + struct HdfSListIterator it; + struct HdfOrderedListEntity *matchEntity = NULL; + if (comparer == NULL) { + return matchEntity; + } + OsalMutexLock(&list->mutex); + HdfSListIteratorInit(&it, &list->head); + while (HdfSListIteratorHasNext(&it)) { + struct OrderedListEntity *searchEntity = + (struct OrderedListEntity *)HdfSListIteratorNext(&it); + if (comparer(matchKey, searchEntity)) { + HdfSListIteratorRemove(&it); + matchEntity = searchEntity; + break; + } + } + OsalMutexUnlock(&list->mutex); + return matchEntity; +} + +void HdfOrderedListFlush(struct HdfOrderedList *list, HdfOrderedListEntityDeleter deleter) +{ + OsalMutexLock(&list->mutex); + HdfSListFlush(&list->head, (HdfSListDeleter)deleter); + OsalMutexUnlock(&list->mutex); + OsalSemPost(&list->sem); +} + +int HdfOrderedListWait(struct HdfOrderedList *list, long timeout) +{ + OsalSemWait(&list->sem, timeout); +} diff --git a/ability/sbuf/src/hdf_sbuf.c b/utils/src/hdf_sbuf.c similarity index 100% rename from ability/sbuf/src/hdf_sbuf.c rename to utils/src/hdf_sbuf.c diff --git a/ability/sbuf/src/hdf_sbuf_impl_raw.c b/utils/src/hdf_sbuf_impl_raw.c similarity index 92% rename from ability/sbuf/src/hdf_sbuf_impl_raw.c rename to utils/src/hdf_sbuf_impl_raw.c index 051eacb46660c8f230eef50d93171b13d7cf65ed..24423d11238c635dc2cf15e5f4e8f3d691a8ea68 100644 --- a/ability/sbuf/src/hdf_sbuf_impl_raw.c +++ b/utils/src/hdf_sbuf_impl_raw.c @@ -67,11 +67,12 @@ static size_t SbufRawImplGetLeftReadSize(struct HdfSBufRaw *sbuf) static bool SbufRawImplWriteRollback(struct HdfSbufImpl *impl, uint32_t size) { struct HdfSBufRaw *sbuf = SBUF_RAW_CAST(impl); + size_t alignSize; if (sbuf == NULL) { return false; } - size_t alignSize = SbufRawImplGetAlignSize(size); + alignSize = SbufRawImplGetAlignSize(size); if (sbuf->writePos < alignSize) { return false; } @@ -83,11 +84,12 @@ static bool SbufRawImplWriteRollback(struct HdfSbufImpl *impl, uint32_t size) static bool SbufRawImplReadRollback(struct HdfSbufImpl *impl, uint32_t size) { struct HdfSBufRaw *sbuf = SBUF_RAW_CAST(impl); + size_t alignSize; if (sbuf == NULL) { return false; } - size_t alignSize = SbufRawImplGetAlignSize(size); + alignSize = SbufRawImplGetAlignSize(size); if (sbuf->readPos < alignSize) { return false; } @@ -141,12 +143,14 @@ static size_t SbufRawImplGetDataSize(const struct HdfSbufImpl *impl) static bool SbufRawImplGrow(struct HdfSBufRaw *sbuf, uint32_t growSize) { + uint32_t newSize; + uint8_t *newData = NULL; if (sbuf->isBind) { HDF_LOGE("%s: binded sbuf oom", __func__); return false; } - uint32_t newSize = SbufRawImplGetAlignSize(sbuf->capacity + growSize); + newSize = SbufRawImplGetAlignSize(sbuf->capacity + growSize); if (newSize < sbuf->capacity) { HDF_LOGE("%s: grow size overflow", __func__); return false; @@ -156,7 +160,7 @@ static bool SbufRawImplGrow(struct HdfSBufRaw *sbuf, uint32_t growSize) return false; } - uint8_t *newData = OsalMemCalloc(newSize); + newData = OsalMemCalloc(newSize); if (newData == NULL) { HDF_LOGE("%s: oom", __func__); return false; @@ -179,6 +183,10 @@ static bool SbufRawImplGrow(struct HdfSBufRaw *sbuf, uint32_t growSize) static bool SbufRawImplWrite(struct HdfSbufImpl *impl, const uint8_t *data, uint32_t size) { struct HdfSBufRaw *sbuf = SBUF_RAW_CAST(impl); + size_t alignSize; + size_t writeableSize; + uint8_t *dest = NULL; + if (sbuf == NULL || sbuf->data == NULL || data == NULL) { return false; } @@ -187,13 +195,13 @@ static bool SbufRawImplWrite(struct HdfSbufImpl *impl, const uint8_t *data, uint return true; } - size_t alignSize = SbufRawImplGetAlignSize(size); + alignSize = SbufRawImplGetAlignSize(size); // in case of desireCapacity overflow if (alignSize < size) { HDF_LOGE("desireCapacity overflow"); return false; } - size_t writeableSize = SbufRawImplGetLeftWriteSize(sbuf); + writeableSize = SbufRawImplGetLeftWriteSize(sbuf); if (alignSize > writeableSize) { size_t growSize = (alignSize > HDF_SBUF_GROW_SIZE_DEFAULT) ? (alignSize + HDF_SBUF_GROW_SIZE_DEFAULT) : HDF_SBUF_GROW_SIZE_DEFAULT; @@ -203,7 +211,7 @@ static bool SbufRawImplWrite(struct HdfSbufImpl *impl, const uint8_t *data, uint writeableSize = SbufRawImplGetLeftWriteSize(sbuf); } - uint8_t *dest = sbuf->data + sbuf->writePos; + dest = sbuf->data + sbuf->writePos; if (memcpy_s(dest, writeableSize, data, size) != EOK) { return false; /* never hits */ } @@ -215,6 +223,7 @@ static bool SbufRawImplWrite(struct HdfSbufImpl *impl, const uint8_t *data, uint static bool SbufRawImplRead(struct HdfSbufImpl *impl, uint8_t *data, uint32_t readSize) { struct HdfSBufRaw *sbuf = SBUF_RAW_CAST(impl); + size_t alignSize; if (sbuf == NULL || sbuf->data == NULL || data == NULL) { return false; } @@ -223,7 +232,7 @@ static bool SbufRawImplRead(struct HdfSbufImpl *impl, uint8_t *data, uint32_t re return true; } - size_t alignSize = SbufRawImplGetAlignSize(readSize); + alignSize = SbufRawImplGetAlignSize(readSize); if (alignSize > SbufRawImplGetLeftReadSize(sbuf)) { HDF_LOGE("Read out of buffer range"); return false; @@ -350,12 +359,13 @@ static bool SbufRawImplReadInt8(struct HdfSbufImpl *impl, int8_t *value) static bool SbufRawImplReadBuffer(struct HdfSbufImpl *impl, const uint8_t **data, uint32_t *readSize) { struct HdfSBufRaw *sbuf = SBUF_RAW_CAST(impl); + int buffSize = 0; + size_t alignSize; if (sbuf == NULL || sbuf->data == NULL || data == NULL || readSize == NULL) { HDF_LOGE("%s: input invalid", __func__); return false; } - int buffSize = 0; if (!SbufRawImplReadInt32(impl, &buffSize)) { return false; } @@ -365,7 +375,7 @@ static bool SbufRawImplReadBuffer(struct HdfSbufImpl *impl, const uint8_t **data *readSize = 0; return true; } - size_t alignSize = SbufRawImplGetAlignSize(buffSize); + alignSize = SbufRawImplGetAlignSize(buffSize); if (alignSize > SbufRawImplGetLeftReadSize(sbuf)) { HDF_LOGE("%s:readBuff out of range", __func__); (void)SbufRawImplReadRollback(impl, sizeof(int32_t)); @@ -381,22 +391,24 @@ static bool SbufRawImplReadBuffer(struct HdfSbufImpl *impl, const uint8_t **data static const char *SbufRawImplReadString(struct HdfSbufImpl *impl) { struct HdfSBufRaw *sbuf = SBUF_RAW_CAST(impl); + int32_t strLen = 0; + size_t alignSize; + char *str = NULL; if (sbuf == NULL || sbuf->data == NULL) { HDF_LOGE("%s: input null", __func__); return NULL; } /* This length contains the '\0' at the end of the string. */ - int32_t strLen = 0; if (!SbufRawImplReadInt32(impl, &strLen) || strLen <= 0) { return NULL; } - size_t alignSize = SbufRawImplGetAlignSize(strLen); + alignSize = SbufRawImplGetAlignSize(strLen); if (strLen > INT16_MAX || alignSize > SbufRawImplGetLeftReadSize(sbuf)) { (void)SbufRawImplReadRollback(impl, sizeof(int32_t)); return NULL; } - char *str = (char *)(sbuf->data + sbuf->readPos); + str = (char *)(sbuf->data + sbuf->readPos); sbuf->readPos += alignSize; /* Set '\0' at end of the string forcibly. */ str[strLen - 1] = '\0'; @@ -406,11 +418,12 @@ static const char *SbufRawImplReadString(struct HdfSbufImpl *impl) static struct HdfSbufImpl *SbufRawImplCopy(const struct HdfSbufImpl *impl) { struct HdfSBufRaw *sbuf = SBUF_RAW_CAST(impl); + struct HdfSBufRaw *new = NULL; if (sbuf == NULL || sbuf->data == NULL) { return NULL; } - struct HdfSBufRaw *new = SbufRawImplNewInstance(sbuf->capacity); + new = SbufRawImplNewInstance(sbuf->capacity); if (new == NULL) { return NULL; } @@ -428,11 +441,12 @@ static struct HdfSbufImpl *SbufRawImplCopy(const struct HdfSbufImpl *impl) static struct HdfSbufImpl *SbufRawImplMove(struct HdfSbufImpl *impl) { struct HdfSBufRaw *sbuf = SBUF_RAW_CAST(impl); + struct HdfSBufRaw *new = NULL; if (sbuf == NULL || sbuf->isBind) { return NULL; } - struct HdfSBufRaw *new = OsalMemCalloc(sizeof(struct HdfSBufRaw)); + new = OsalMemCalloc(sizeof(struct HdfSBufRaw)); if (new == NULL) { return NULL; } @@ -494,11 +508,12 @@ static void SbufInterfaceAssign(struct HdfSbufImpl *inf) static struct HdfSBufRaw *SbufRawImplNewInstance(size_t capacity) { + struct HdfSBufRaw *sbuf = NULL; if (capacity > HDF_SBUF_MAX_SIZE) { HDF_LOGE("%s: Sbuf size exceeding max limit", __func__); return NULL; } - struct HdfSBufRaw *sbuf = (struct HdfSBufRaw *)OsalMemCalloc(sizeof(struct HdfSBufRaw)); + sbuf = (struct HdfSBufRaw *)OsalMemCalloc(sizeof(struct HdfSBufRaw)); if (sbuf == NULL) { HDF_LOGE("Sbuf instance failure"); return NULL; @@ -529,6 +544,7 @@ struct HdfSbufImpl *SbufObtainRaw(size_t capacity) struct HdfSbufImpl *SbufBindRaw(uintptr_t base, size_t size) { + struct HdfSBufRaw *sbuf = NULL; if (base == 0 || size == 0) { return NULL; } @@ -537,7 +553,7 @@ struct HdfSbufImpl *SbufBindRaw(uintptr_t base, size_t size) HDF_LOGE("Base not in 4-byte alignment"); return NULL; } - struct HdfSBufRaw *sbuf = (struct HdfSBufRaw *)OsalMemAlloc(sizeof(struct HdfSBufRaw)); + sbuf = (struct HdfSBufRaw *)OsalMemAlloc(sizeof(struct HdfSBufRaw)); if (sbuf == NULL) { HDF_LOGE("%s: oom", __func__); return NULL; diff --git a/utils/src/hdf_slist.c b/utils/src/hdf_slist.c index 1aeb396c5eaf711adf7a37aa2fb9d817f1e5bf46..7780110ab35e86975f26d3b7cac8b9352ca5d2b4 100644 --- a/utils/src/hdf_slist.c +++ b/utils/src/hdf_slist.c @@ -180,11 +180,11 @@ struct HdfSListNode *HdfSListNext(struct HdfSListNode *link) struct HdfSListNode *HdfSListPop(struct HdfSList *list) { + struct HdfSListNode *first = NULL; if (list == NULL || list->root == NULL) { return NULL; } - - struct HdfSListNode *first = list->root; + first = list->root; list->root = first->next; return first; } @@ -225,7 +225,7 @@ bool HdfSListIteratorHasNext(struct HdfSListIterator *iterator) struct HdfSListNode *HdfSListIteratorNext(struct HdfSListIterator *iterator) { - if ((iterator == NULL) || (iterator->curr == NULL) || (iterator->prev == NULL)) { + if (iterator == NULL || iterator->curr == NULL || iterator->prev == NULL) { return NULL; } @@ -246,7 +246,7 @@ struct HdfSListNode *HdfSListIteratorNext(struct HdfSListIterator *iterator) void HdfSListIteratorRemove(struct HdfSListIterator *iterator) { - if ((iterator == NULL) || (iterator->curr == NULL) || (iterator->prev == NULL)) { + if (iterator == NULL || iterator->curr == NULL || iterator->prev == NULL) { return; } diff --git a/utils/src/hdf_task_queue.c b/utils/src/hdf_task_queue.c new file mode 100755 index 0000000000000000000000000000000000000000..a6ed089d338d47f802f638c0523825101f4d9d06 --- /dev/null +++ b/utils/src/hdf_task_queue.c @@ -0,0 +1,203 @@ +/* + * Copyright (c) 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_task_queue.h" +#include "hdf_log.h" +#include "osal_mem.h" +#include "securec.h" + +static int32_t HdfThreadTasker(void *data); + +#define HDF_LOG_TAG hdf_task_queue + +static int32_t HdfCreateThread(struct HdfTaskQueue *queue) +{ + int32_t ret; + + ret = OsalThreadCreate(&queue->thread, (OsalThreadEntry)HdfThreadTasker, queue); + if (ret != HDF_SUCCESS) { + HDF_LOGE("HdfCreateThread: create thread fail!"); + } + + return ret; +} + +struct HdfTaskQueue *HdfTaskQueueCreate(HdfTaskFunc func, const char *name) +{ + int32_t ret; + struct HdfTaskQueue *queue = NULL; + + queue = (struct HdfTaskQueue *)OsalMemCalloc(sizeof(*queue)); + if (queue == NULL) { + HDF_LOGE("%s malloc fail", __func__); + return queue; + } + + DListHeadInit(&queue->head); + + ret = OsalMutexInit(&queue->mutex); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s OsalMutexInit fail", __func__); + OsalMemFree(queue); + return NULL; + } + + ret = OsalSemInit(&queue->sem, 0); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s OsalSemInit fail", __func__); + OsalMutexDestroy(&queue->mutex); + OsalMemFree(queue); + return NULL; + } + + ret = HdfCreateThread(queue); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s HdfCreateThread fail", __func__); + (void)OsalMutexDestroy(&queue->mutex); + (void)OsalSemDestroy(&queue->sem); + OsalMemFree(queue); + return NULL; + } + + queue->queueName = name; + queue->threadRunFlag = false; + + if (func != NULL) { + queue->queueFunc = func; + } + + return queue; +} + +static void hdfQueueStopThread(struct HdfTaskQueue *queue) +{ + int32_t ret; + + if (queue == NULL) { + HDF_LOGE("%s queue ptr is null", __func__); + return; + } + + queue->threadRunFlag = false; + + ret = OsalSemPost(&queue->sem); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s OsalSemPost fail", __func__); + } +} + +void HdfTaskQueueDestroy(struct HdfTaskQueue *queue) +{ + if (queue == NULL) { + HDF_LOGE("%s queue ptr is null", __func__); + return; + } + hdfQueueStopThread(queue); +} + +static void hdfQueueStartThread(struct HdfTaskQueue *queue) +{ + int32_t ret; + struct OsalThreadParam param; + + (void)memset_s(¶m, sizeof(param), 0, sizeof(param)); + param.name = (char *)queue->queueName; + param.priority = OSAL_THREAD_PRI_HIGH; + queue->threadRunFlag = true; + + ret = OsalThreadStart(&queue->thread, ¶m); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s OsalThreadStart fail", __func__); + } +} + +void HdfTaskEnqueue(struct HdfTaskQueue *queue, struct HdfTaskType *task) +{ + int32_t ret; + + if (queue == NULL || task == NULL) { + HDF_LOGE("%s ptr is null", __func__); + return; + } + + ret = OsalMutexLock(&queue->mutex); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s OsalMutexLock fail", __func__); + return; + } + + if (!queue->threadRunFlag) { + hdfQueueStartThread(queue); + } + + DListInsertTail(&task->node, &queue->head); + + ret = OsalMutexUnlock(&queue->mutex); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s OsalMutexUnlock fail", __func__); + return; + } + + ret = OsalSemPost(&queue->sem); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s OsalSemPost fail", __func__); + } +} + +static struct HdfTaskType *HdfTaskDequeue(struct HdfTaskQueue *queue) +{ + struct HdfTaskType *task = NULL; + + if (!DListIsEmpty(&queue->head)) { + task = DLIST_FIRST_ENTRY(&queue->head, struct HdfTaskType, node); + DListRemove(&task->node); + } + + return task; +} + +static int32_t HdfThreadTasker(void *data) +{ + int32_t ret; + struct HdfTaskType *task = NULL; + struct HdfTaskQueue *queue = (struct HdfTaskQueue *)data; + + while (queue->threadRunFlag) { + ret = OsalSemWait(&queue->sem, HDF_WAIT_FOREVER); + if (ret != HDF_SUCCESS) { + continue; + } + ret = OsalMutexLock(&queue->mutex); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s OsalMutexLock fail", __func__); + continue; + } + task = HdfTaskDequeue(queue); + while (task != NULL) { + if (task->func) { + task->func(task); + } else if (queue->queueFunc) { + queue->queueFunc(task); + } else { + HDF_LOGE("%s no task and queue function", __func__); + } + task = HdfTaskDequeue(queue); + } + ret = OsalMutexUnlock(&queue->mutex); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s OsalMutexUnlock fail", __func__); + } + } + + (void)OsalMutexDestroy(&queue->mutex); + (void)OsalSemDestroy(&queue->sem); + OsalMemFree(queue); + HDF_LOGI("%s thread exit", __func__); + + return HDF_SUCCESS; +}