modify sensor model driver

Signed-off-by: kevin <liufeihu@huawei.com>
Change-Id: I0f773de2029daabcfa61381eb1b787d3b096dcd2

model/sensor/driver/accel/sensor_accel_driver.c

@@ -12,7 +12,6 @@
 #include "hdf_device_desc.h"
 #include "osal_math.h"
 #include "osal_mem.h"
-#include "osal_time.h"
 #include "sensor_accel_driver.h"
 #include "sensor_config_controller.h"
 #include "sensor_device_manager.h"
@@ -20,20 +19,17 @@
 
 #define HDF_LOG_TAG    sensor_accel_driver_c
 
+#define HDF_ACCEL_WORK_QUEUE_NAME    "hdf_accel_work_queue"
+
 static struct AccelDetectIfList g_accelDetectIfList[] = {
     {ACCEL_CHIP_NAME_BMI160, DetectAccelBim160Chip},
 };
 
+static struct AccelDrvData *g_accelDrvData = NULL;
+
 static struct AccelDrvData *AccelGetDrvData(void)
 {
-    static struct AccelDrvData accelDrvData = {
+    return g_accelDrvData;
-        .threadStatus = SENSOR_THREAD_NONE,
-        .initStatus = false,
-        .detectFlag = false,
-        .interval = ACC_DEFAULT_SAMPLING_200_MS,
-    };
-
-    return &accelDrvData;
 }
 
 static struct SensorRegCfgGroupNode *g_regCfgGroup[SENSOR_GROUP_MAX] = { NULL };
@@ -45,61 +41,62 @@ int32_t RegisterAccelChipOps(const struct AccelOpsCall *ops)
     CHECK_NULL_PTR_RETURN_VALUE(ops, HDF_ERR_INVALID_PARAM);
 
     drvData = AccelGetDrvData();
+    CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
     drvData->ops.Init = ops->Init;
     drvData->ops.ReadData = ops->ReadData;
     return HDF_SUCCESS;
 }
 
-static int32_t ReadAccelDataThreadWorker(void *arg)
+static void AccelDataWorkEntry(void *arg)
 {
-    (void)arg;
+    int32_t ret;
-    int64_t interval;
+    struct AccelDrvData *drvData = (struct AccelDrvData *)arg;
-    struct AccelDrvData *drvData = NULL;
+    CHECK_NULL_PTR_RETURN(drvData);
+    CHECK_NULL_PTR_RETURN(drvData->ops.ReadData);
 
-    drvData = AccelGetDrvData();
+    ret = drvData->ops.ReadData(drvData->accelCfg);
-    drvData->threadStatus = SENSOR_THREAD_START;
+    if (ret != HDF_SUCCESS) {
-    while (true) {
+        HDF_LOGE("%s: accel read data failed", __func__);
-        if (drvData->threadStatus == SENSOR_THREAD_RUNNING) {
+        return;
-            if (drvData->ops.ReadData != NULL) {
-                (void)drvData->ops.ReadData(drvData->accelCfg);
-            }
-
-            interval = OsalDivS64(drvData->interval, (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT));
-            OsalMSleep(interval);
-        } else if (drvData->threadStatus == SENSOR_THREAD_STOPPING) {
-            drvData->threadStatus = SENSOR_THREAD_STOPPED;
-            break;
-        } else {
-            OsalMSleep(ACC_DEFAULT_SAMPLING_200_MS / SENSOR_CONVERT_UNIT / SENSOR_CONVERT_UNIT);
-        }
-
-        if ((!drvData->initStatus) || (drvData->interval < 0) || drvData->threadStatus != SENSOR_THREAD_RUNNING) {
-            continue;
-        }
     }
-
-    HDF_LOGD("%s: accel thread have exited", __func__);
-    return HDF_SUCCESS;
 }
 
-static int32_t InitAccelConfig(void)
+static void AccelTimerEntry(uintptr_t arg)
+{
+    int64_t interval;
+    int32_t ret;
+    struct AccelDrvData *drvData = (struct AccelDrvData *)arg;
+    CHECK_NULL_PTR_RETURN(drvData);
+
+    if (!HdfAddWork(&drvData->accelWorkQueue, &drvData->accelWork)) {
+        HDF_LOGE("%s: accel 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->accelTimer, interval);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: accel modify time failed", __func__);
+    }
+}
+
+static int32_t InitAccelData(void)
 {
     struct AccelDrvData *drvData = AccelGetDrvData();
     int32_t ret;
+    CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
 
     if (drvData->initStatus) {
         return HDF_SUCCESS;
     }
 
-    if (drvData->threadStatus != SENSOR_THREAD_NONE && drvData->threadStatus != SENSOR_THREAD_DESTROY) {
+    if (HdfWorkQueueInit(&drvData->accelWorkQueue, HDF_ACCEL_WORK_QUEUE_NAME) != HDF_SUCCESS) {
-        HDF_LOGE("%s: accel thread have created", __func__);
+        HDF_LOGE("%s: accel init work queue failed", __func__);
-        return HDF_SUCCESS;
+        return HDF_FAILURE;
     }
 
-    ret = CreateSensorThread(&drvData->thread, ReadAccelDataThreadWorker, "hdf_sensor_accel", drvData);
+    if (HdfWorkInit(&drvData->accelWork, AccelDataWorkEntry, drvData) != HDF_SUCCESS) {
-    if (ret != HDF_SUCCESS) {
         HDF_LOGE("%s: accel create thread failed", __func__);
-        drvData->threadStatus = SENSOR_THREAD_STOPPING;
         return HDF_FAILURE;
     }
 
@@ -108,17 +105,12 @@ static int32_t InitAccelConfig(void)
     ret = drvData->ops.Init(drvData->accelCfg);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("%s: accel create thread failed", __func__);
-        drvData->threadStatus = SENSOR_THREAD_STOPPING;
         return HDF_FAILURE;
     }
+
+    drvData->interval = SENSOR_TIMER_MIN_TIME;
     drvData->initStatus = true;
-
+    drvData->enable = false;
-    return HDF_SUCCESS;
-}
-
-static int32_t SetAccelInfo(struct SensorBasicInfo *info)
-{
-    (void)info;
 
     return HDF_SUCCESS;
 }
@@ -128,14 +120,32 @@ static int32_t SetAccelEnable(void)
     int32_t ret;
     struct AccelDrvData *drvData = AccelGetDrvData();
 
+    CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
     CHECK_NULL_PTR_RETURN_VALUE(drvData->accelCfg, HDF_ERR_INVALID_PARAM);
+
+    if (drvData->enable) {
+        HDF_LOGE("%s: accel sensor is enabled", __func__);
+        return HDF_SUCCESS;
+    }
+
     ret = SetSensorRegCfgArray(&drvData->accelCfg->busCfg, drvData->accelCfg->regCfgGroup[SENSOR_ENABLE_GROUP]);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("%s: accel sensor enable config failed", __func__);
-        return HDF_FAILURE;
+        return ret;
     }
 
-    drvData->threadStatus = SENSOR_THREAD_RUNNING;
+    ret = OsalTimerCreate(&drvData->accelTimer, SENSOR_TIMER_MIN_TIME, AccelTimerEntry, (uintptr_t)drvData);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: accel create timer failed[%d]", __func__, ret);
+        return ret;
+    }
+
+    ret = OsalTimerStartLoop(&drvData->accelTimer);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: accel start timer failed[%d]", __func__, ret);
+        return ret;
+    }
+    drvData->enable = true;
 
     return HDF_SUCCESS;
 }
@@ -145,16 +155,26 @@ static int32_t SetAccelDisable(void)
     int32_t ret;
     struct AccelDrvData *drvData = AccelGetDrvData();
 
+    CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
     CHECK_NULL_PTR_RETURN_VALUE(drvData->accelCfg, HDF_ERR_INVALID_PARAM);
 
+    if (!drvData->enable) {
+        HDF_LOGE("%s: accel sensor had disable", __func__);
+        return HDF_SUCCESS;
+    }
+
     ret = SetSensorRegCfgArray(&drvData->accelCfg->busCfg, drvData->accelCfg->regCfgGroup[SENSOR_DISABLE_GROUP]);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("%s: accel sensor disable config failed", __func__);
-        return HDF_FAILURE;
+        return ret;
     }
 
-    drvData->threadStatus = SENSOR_THREAD_STOPPED;
+    ret = OsalTimerDelete(&drvData->accelTimer);
-
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: accel delete timer failed", __func__);
+        return ret;
+    }
+    drvData->enable = false;
     return HDF_SUCCESS;
 }
 
@@ -165,6 +185,8 @@ static int32_t SetAccelBatch(int64_t samplingInterval, int64_t interval)
     struct AccelDrvData *drvData = NULL;
 
     drvData = AccelGetDrvData();
+    CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
+
     drvData->interval = samplingInterval;
 
     return HDF_SUCCESS;
@@ -196,12 +218,16 @@ int32_t BindAccelDriver(struct HdfDeviceObject *device)
 {
     CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
 
-    static struct IDeviceIoService service = {
+    struct AccelDrvData *drvData = (struct AccelDrvData *)OsalMemCalloc(sizeof(*drvData));
-        .object = {0},
+    if (drvData == NULL) {
-        .Dispatch = DispatchAccel,
+        HDF_LOGE("%s: malloc accel drv data fail!", __func__);
-    };
+        return HDF_ERR_MALLOC_FAIL;
-    device->service = &service;
+    }
 
+    drvData->ioService.Dispatch = DispatchAccel;
+    drvData->device = device;
+    device->service = &drvData->ioService;
+    g_accelDrvData = drvData;
     return HDF_SUCCESS;
 }
 
@@ -209,7 +235,8 @@ static int32_t InitAccelOps(struct SensorDeviceInfo *deviceInfo)
 {
     struct AccelDrvData *drvData = AccelGetDrvData();
 
-    deviceInfo->ops.GetInfo = SetAccelInfo;
+    CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
+
     deviceInfo->ops.Enable = SetAccelEnable;
     deviceInfo->ops.Disable = SetAccelDisable;
     deviceInfo->ops.SetBatch = SetAccelBatch;
@@ -222,9 +249,6 @@ static int32_t InitAccelOps(struct SensorDeviceInfo *deviceInfo)
         return HDF_FAILURE;
     }
 
-    drvData->accelCfg->sensorInfo.sensorTypeId = SENSOR_TAG_ACCELEROMETER;
-    drvData->accelCfg->sensorInfo.sensorId = SENSOR_TAG_ACCELEROMETER;
-
     return HDF_SUCCESS;
 }
 
@@ -232,7 +256,7 @@ static int32_t InitAccelAfterConfig(void)
 {
     struct SensorDeviceInfo deviceInfo;
 
-    if (InitAccelConfig() != HDF_SUCCESS) {
+    if (InitAccelData() != HDF_SUCCESS) {
         HDF_LOGE("%s: init accel config failed", __func__);
         return HDF_FAILURE;
     }
@@ -256,6 +280,8 @@ static int32_t DetectAccelChip(void)
     int32_t ret;
     int32_t loop;
     struct AccelDrvData *drvData = AccelGetDrvData();
+
+    CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
     CHECK_NULL_PTR_RETURN_VALUE(drvData->accelCfg, HDF_ERR_INVALID_PARAM);
 
     num = sizeof(g_accelDetectIfList) / sizeof(g_accelDetectIfList[0]);
@@ -264,30 +290,27 @@ static int32_t DetectAccelChip(void)
             ret = g_accelDetectIfList[loop].DetectChip(drvData->accelCfg);
             if (ret == HDF_SUCCESS) {
                 drvData->detectFlag = true;
-                break;
+                return HDF_SUCCESS;
             }
         }
     }
 
-    if (loop == num) {
+    HDF_LOGE("%s: detect accel device failed", __func__);
-        HDF_LOGE("%s: detect accel device failed", __func__);
+    drvData->detectFlag = false;
-        drvData->detectFlag = false;
+    return HDF_FAILURE;
-        return HDF_FAILURE;
-    }
-    return HDF_SUCCESS;
 }
 
 int32_t InitAccelDriver(struct HdfDeviceObject *device)
 {
-    struct AccelDrvData *drvData = AccelGetDrvData();
+    CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
+    struct AccelDrvData *drvData = (struct AccelDrvData *)device->service;
+    CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
 
     if (drvData->detectFlag) {
         HDF_LOGE("%s: accel sensor have detected", __func__);
         return HDF_SUCCESS;
     }
 
-    CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
-
     drvData->accelCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->accelCfg));
     if (drvData->accelCfg == NULL) {
         HDF_LOGE("%s: malloc sensor config data failed", __func__);
@@ -322,8 +345,7 @@ int32_t InitAccelDriver(struct HdfDeviceObject *device)
     return HDF_SUCCESS;
 
 INIT_EXIT:
-    DestroySensorThread(&drvData->thread, &drvData->threadStatus);
+    (void)DeleteSensorDevice(&drvData->accelCfg->sensorInfo);
-    (void)DeleteSensorDevice(SENSOR_TAG_ACCELEROMETER);
 REG_CONFIG_EXIT:
     ReleaseSensorAllRegConfig(drvData->accelCfg);
     (void)ReleaseSensorBusHandle(&drvData->accelCfg->busCfg);
@@ -339,12 +361,12 @@ BASE_CONFIG_EXIT:
 
 void ReleaseAccelDriver(struct HdfDeviceObject *device)
 {
-    (void)device;
+    CHECK_NULL_PTR_RETURN(device);
-    struct AccelDrvData *drvData = NULL;
 
-    drvData = AccelGetDrvData();
+    struct AccelDrvData *drvData = (struct AccelDrvData *)device->service;
-    (void)DestroySensorThread(&drvData->thread, &drvData->threadStatus);
+    CHECK_NULL_PTR_RETURN(drvData);
-    (void)DeleteSensorDevice(SENSOR_TAG_ACCELEROMETER);
+
+    (void)DeleteSensorDevice(&drvData->accelCfg->sensorInfo);
     drvData->detectFlag = false;
 
     if (drvData->accelCfg != NULL) {

model/sensor/driver/accel/sensor_accel_driver.h

@@ -9,7 +9,9 @@
 #ifndef SENSOR_ACCEL_DRIVER_H
 #define SENSOR_ACCEL_DRIVER_H
 
-#include "osal_thread.h"
+#include "hdf_workqueue.h"
+#include "osal_mutex.h"
+#include "osal_timer.h"
 #include "sensor_config_parser.h"
 #include "sensor_platform_if.h"
 
@@ -50,12 +52,16 @@ struct AccelOpsCall {
 };
 
 struct AccelDrvData {
+    struct IDeviceIoService ioService;
+    struct HdfDeviceObject *device;
+    HdfWorkQueue accelWorkQueue;
+    HdfWork accelWork;
+    OsalTimer accelTimer;
     bool detectFlag;
-    uint8_t threadStatus;
+    bool enable;
-    uint8_t initStatus;
+    bool initStatus;
     int64_t interval;
     struct SensorCfgData *accelCfg;
-    struct OsalThread thread;
     struct AccelOpsCall ops;
 };
 

model/sensor/driver/common/include/sensor_device_manager.h

@@ -9,21 +9,24 @@
 #ifndef SENSOR_DEVICE_MANAGER_H
 #define SENSOR_DEVICE_MANAGER_H
 
+#include "hdf_workqueue.h"
 #include "osal_mutex.h"
 #include "sensor_device_type.h"
 #include "sensor_device_if.h"
 
+#define HDF_SENSOR_EVENT_QUEUE_NAME    "hdf_sensor_event_queue"
+
 enum SensorCmd {
     SENSOR_CMD_GET_INFO_LIST = 0,
     SENSOR_CMD_OPS           = 1,
     SENSOR_CMD_END,
 };
 enum SensorOpsCmd {
-    SENSOR_OPS_CMD_ENABLE        = 1,
+    SENSOR_OPS_CMD_ENABLE        = 0,
-    SENSOR_OPS_CMD_DISABLE       = 2,
+    SENSOR_OPS_CMD_DISABLE       = 1,
-    SENSOR_OPS_CMD_SET_BATCH     = 3,
+    SENSOR_OPS_CMD_SET_BATCH     = 2,
-    SENSOR_OPS_CMD_SET_MODE      = 4,
+    SENSOR_OPS_CMD_SET_MODE      = 3,
-    SENSOR_OPS_CMD_SET_OPTION    = 5,
+    SENSOR_OPS_CMD_SET_OPTION    = 4,
     SENSOR_OPS_CMD_BUTT,
 };
 

model/sensor/driver/common/src/sensor_device_manager.c

@@ -28,63 +28,63 @@ static struct SensorDevMgrData *GetSensorDeviceManager(void)
 
 int32_t AddSensorDevice(const struct SensorDeviceInfo *deviceInfo)
 {
-    bool existSensor = false;
     struct SensorDevInfoNode *pos = NULL;
-    struct SensorDevInfoNode *tmp = NULL;
     struct SensorDevInfoNode *devInfoNode = NULL;
     struct SensorDevMgrData *manager = GetSensorDeviceManager();
 
     CHECK_NULL_PTR_RETURN_VALUE(deviceInfo, HDF_ERR_INVALID_PARAM);
     CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_ERR_INVALID_PARAM);
 
-    (void)OsalMutexLock(&manager->mutex);
+    DLIST_FOR_EACH_ENTRY(pos, &manager->sensorDevInfoHead, struct SensorDevInfoNode, node) {
-    DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->sensorDevInfoHead, struct SensorDevInfoNode, node) {
+        if ((deviceInfo->sensorInfo.sensorId == pos->devInfo.sensorInfo.sensorId) &&
-        if (deviceInfo->sensorInfo.sensorId == pos->devInfo.sensorInfo.sensorId) {
+            (strcmp(deviceInfo->sensorInfo.sensorName, pos->devInfo.sensorInfo.sensorName) == 0)) {
-            HDF_LOGE("%s: sensor chip[0x%x] had existed", __func__, deviceInfo->sensorInfo.sensorId);
+            HDF_LOGE("%{public}s: sensor id[%{public}d] had existed", __func__, deviceInfo->sensorInfo.sensorId);
-            existSensor = true;
+            return HDF_FAILURE;
-            break;
         }
     }
 
-    if (!existSensor) {
+    (void)OsalMutexLock(&manager->mutex);
-        devInfoNode = (struct SensorDevInfoNode*)OsalMemCalloc(sizeof(*devInfoNode));
+    devInfoNode = (struct SensorDevInfoNode*)OsalMemCalloc(sizeof(*devInfoNode));
-        if (devInfoNode == NULL) {
+    if (devInfoNode == NULL) {
-            (void)OsalMutexUnlock(&manager->mutex);
+        (void)OsalMutexUnlock(&manager->mutex);
-            return HDF_FAILURE;
+        return HDF_FAILURE;
-        }
-        if (memcpy_s(&devInfoNode->devInfo, sizeof(devInfoNode->devInfo),
-            (void *)deviceInfo, sizeof(*deviceInfo)) != EOK) {
-            HDF_LOGE("%s: copy sensor info failed", __func__);
-            OsalMemFree(devInfoNode);
-            (void)OsalMutexUnlock(&manager->mutex);
-            return HDF_FAILURE;
-        }
-        DListInsertTail(&devInfoNode->node, &manager->sensorDevInfoHead);
-        HDF_LOGI("%s: register sensor device name[%s] success", __func__, deviceInfo->sensorInfo.sensorName);
     }
+    if (memcpy_s(&devInfoNode->devInfo, sizeof(devInfoNode->devInfo),
+        (void *)deviceInfo, sizeof(*deviceInfo)) != EOK) {
+        HDF_LOGE("%{public}s: copy sensor info failed", __func__);
+        OsalMemFree(devInfoNode);
+        (void)OsalMutexUnlock(&manager->mutex);
+        return HDF_FAILURE;
+    }
+    DListInsertTail(&devInfoNode->node, &manager->sensorDevInfoHead);
     (void)OsalMutexUnlock(&manager->mutex);
+    HDF_LOGI("%{public}s: register sensor name[%{private}s] success", __func__, deviceInfo->sensorInfo.sensorName);
 
     return HDF_SUCCESS;
 }
 
-int32_t DeleteSensorDevice(int32_t sensorId)
+int32_t DeleteSensorDevice(const struct SensorBasicInfo *sensorBaseInfo)
 {
     struct SensorDevInfoNode *pos = NULL;
     struct SensorDevInfoNode *tmp = NULL;
     struct SensorDevMgrData *manager = GetSensorDeviceManager();
 
+    CHECK_NULL_PTR_RETURN_VALUE(sensorBaseInfo, HDF_ERR_INVALID_PARAM);
     CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_ERR_INVALID_PARAM);
+
     (void)OsalMutexLock(&manager->mutex);
     DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->sensorDevInfoHead, struct SensorDevInfoNode, node) {
-        if (sensorId == pos->devInfo.sensorInfo.sensorId) {
+        if ((sensorBaseInfo->sensorId == pos->devInfo.sensorInfo.sensorId) &&
+            (strcmp(sensorBaseInfo->sensorName, pos->devInfo.sensorInfo.sensorName) == 0)) {
             DListRemove(&pos->node);
             OsalMemFree(pos);
-            break;
+            (void)OsalMutexUnlock(&manager->mutex);
+            return HDF_SUCCESS;
         }
     }
     (void)OsalMutexUnlock(&manager->mutex);
-
+    HDF_LOGE("%{public}s: delete sensor id invalid para", __func__);
-    return HDF_SUCCESS;
+    return HDF_FAILURE;
 }
 
 int32_t ReportSensorEvent(const struct SensorReportEvent *events)
@@ -132,7 +132,6 @@ static int32_t GetAllSensorInfo(struct HdfSBuf *data, struct HdfSBuf *reply)
 {
     (void)data;
     struct SensorDevInfoNode *pos = NULL;
-    struct SensorDevInfoNode *tmp = NULL;
     struct SensorBasicInfo *sensorInfo = NULL;
     struct SensorDevMgrData *manager = GetSensorDeviceManager();
     int32_t count = 0;
@@ -140,14 +139,12 @@ static int32_t GetAllSensorInfo(struct HdfSBuf *data, struct HdfSBuf *reply)
     CHECK_NULL_PTR_RETURN_VALUE(reply, HDF_ERR_INVALID_PARAM);
     CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_ERR_INVALID_PARAM);
 
-    DLIST_FOR_EACH_ENTRY_SAFE(pos, tmp, &manager->sensorDevInfoHead, struct SensorDevInfoNode, node) {
+    DLIST_FOR_EACH_ENTRY(pos, &manager->sensorDevInfoHead, struct SensorDevInfoNode, node) {
         sensorInfo = &(pos->devInfo.sensorInfo);
         if (!HdfSbufWriteBuffer(reply, sensorInfo, sizeof(*sensorInfo))) {
-
             HDF_LOGE("%s: write sbuf failed", __func__);
             return HDF_FAILURE;
         }
-        pos->devInfo.ops.GetInfo(NULL);
 
         count++;
         if ((count + 1) * sizeof(*sensorInfo) > HDF_SENSOR_INFO_MAX_BUF) {
@@ -240,25 +237,25 @@ static struct SensorCmdHandleList g_sensorCmdHandle[] = {
 
 static int32_t DispatchCmdHandle(struct SensorDeviceInfo *deviceInfo, struct HdfSBuf *data, struct HdfSBuf *reply)
 {
-    int32_t methodCmd;
+    int32_t opsCmd;
     int32_t loop;
     int32_t count;
 
     CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM);
 
-    if (!HdfSbufReadInt32(data, &methodCmd)) {
+    if (!HdfSbufReadInt32(data, &opsCmd)) {
-        HDF_LOGE("%s: sbuf read methodCmd failed", __func__);
+        HDF_LOGE("%s: sbuf read opsCmd failed", __func__);
         return HDF_FAILURE;
     }
 
-    if (methodCmd >= SENSOR_OPS_CMD_BUTT || methodCmd <= 0) {
+    if ((opsCmd >= SENSOR_OPS_CMD_BUTT) || (opsCmd < SENSOR_OPS_CMD_ENABLE)) {
-        HDF_LOGE("%s: invalid cmd = %d", __func__, methodCmd);
+        HDF_LOGE("%s: invalid cmd = %d", __func__, opsCmd);
         return HDF_FAILURE;
     }
 
     count = sizeof(g_sensorCmdHandle) / sizeof(g_sensorCmdHandle[0]);
     for (loop = 0; loop < count; ++loop) {
-        if ((methodCmd == g_sensorCmdHandle[loop].cmd) && (g_sensorCmdHandle[loop].func != NULL)) {
+        if ((opsCmd == g_sensorCmdHandle[loop].cmd) && (g_sensorCmdHandle[loop].func != NULL)) {
             return g_sensorCmdHandle[loop].func(deviceInfo, data, reply);
         }
     }
@@ -272,29 +269,38 @@ static int32_t DispatchSensor(struct HdfDeviceIoClient *client,
     struct SensorDevMgrData *manager = GetSensorDeviceManager();
     struct SensorDevInfoNode *pos = NULL;
     int32_t sensorId;
-    int32_t ret = HDF_FAILURE;
+    int32_t ret;
 
     CHECK_NULL_PTR_RETURN_VALUE(manager, HDF_ERR_INVALID_PARAM);
     CHECK_NULL_PTR_RETURN_VALUE(client, HDF_ERR_INVALID_PARAM);
 
+    if (cmd >= SENSOR_CMD_END) {
+        HDF_LOGE("%s: sensor cmd invalid para", __func__);
+        return HDF_ERR_INVALID_PARAM;
+    }
+
     if (cmd == SENSOR_CMD_GET_INFO_LIST) {
         return GetAllSensorInfo(data, reply);
     }
 
     (void)OsalMutexLock(&manager->mutex);
+    if (!HdfSbufReadInt32(data, &sensorId)) {
+        HDF_LOGE("%s: sbuf read sensorId failed", __func__);
+        (void)OsalMutexUnlock(&manager->mutex);
+        return HDF_ERR_INVALID_PARAM;
+    }
+
     DLIST_FOR_EACH_ENTRY(pos, &manager->sensorDevInfoHead, struct SensorDevInfoNode, node) {
-        if (!HdfSbufReadInt32(data, &sensorId)) {
-            HDF_LOGE("%s: sbuf read sensorId failed", __func__);
-            continue;
-        }
         if (sensorId == pos->devInfo.sensorInfo.sensorId) {
             ret = DispatchCmdHandle(&pos->devInfo, data, reply);
-            break;
+            (void)OsalMutexUnlock(&manager->mutex);
+            return ret;
         }
     }
     (void)OsalMutexUnlock(&manager->mutex);
 
-    return ret;
+    HDF_LOGE("%s: not find sensor[%d] handle function", __func__, sensorId);
+    return HDF_FAILURE;
 }
 
 int32_t BindSensorDevManager(struct HdfDeviceObject *device)

model/sensor/driver/common/src/sensor_platform_if.c

@@ -8,7 +8,6 @@
 
 #include "securec.h"
 #include "osal_io.h"
-#include "osal_thread.h"
 #include "osal_time.h"
 #include "sensor_platform_if.h"
 
@@ -119,55 +118,3 @@ int32_t SetSensorPinMux(uint32_t regAddr, int32_t regSize, uint32_t regValue)
 
     return HDF_SUCCESS;
 }
-
-int32_t CreateSensorThread(struct OsalThread *thread, OsalThreadEntry threadEntry, char *name, void *entryPara)
-{
-    struct OsalThreadParam config = {
-        .name = name,
-        .priority = OSAL_THREAD_PRI_DEFAULT,
-        .stackSize = SENSOR_STACK_SIZE,
-    };
-
-    CHECK_NULL_PTR_RETURN_VALUE(thread, HDF_ERR_INVALID_PARAM);
-    CHECK_NULL_PTR_RETURN_VALUE(threadEntry, HDF_ERR_INVALID_PARAM);
-    CHECK_NULL_PTR_RETURN_VALUE(name, HDF_ERR_INVALID_PARAM);
-    CHECK_NULL_PTR_RETURN_VALUE(entryPara, HDF_ERR_INVALID_PARAM);
-
-    int32_t status = OsalThreadCreate(thread, threadEntry, entryPara);
-    if (status != HDF_SUCCESS) {
-        HDF_LOGE("%s: sensor create thread failed!status=%d", __func__, status);
-        return HDF_FAILURE;
-    }
-
-    status = OsalThreadStart(thread, &config);
-    if (status != HDF_SUCCESS) {
-        HDF_LOGE("%s: sensor start thread failed!status=%d", __func__, status);
-        OsalThreadDestroy(thread);
-        return HDF_FAILURE;
-    }
-    return HDF_SUCCESS;
-}
-
-void DestroySensorThread(struct OsalThread *thread, uint8_t *status)
-{
-    int count = 0;
-    CHECK_NULL_PTR_RETURN(thread);
-    CHECK_NULL_PTR_RETURN(status);
-
-    if (*status == SENSOR_THREAD_NONE || *status == SENSOR_THREAD_DESTROY) {
-        HDF_LOGE("%s,delete thread not need!", __func__);
-        return;
-    }
-
-    if (*status != SENSOR_THREAD_STOPPED) {
-        *status = SENSOR_THREAD_STOPPING;
-        /* wait until thread worker exit */
-        while ((*status != SENSOR_THREAD_STOPPED) && (count < MAX_SENSOR_EXIT_THREAD_COUNT)) {
-            OsalMSleep(MAX_SENSOR_WAIT_THREAD_TIME);
-            count++;
-        }
-    }
-
-    OsalThreadDestroy(thread);
-    *status = SENSOR_THREAD_DESTROY;
-}

model/sensor/driver/include/sensor_device_if.h

@@ -12,7 +12,6 @@
 #include "sensor_device_type.h"
 
 struct SensorOps {
-    int32_t (*GetInfo)(struct SensorBasicInfo *sensorInfo);
     int32_t (*Enable)(void);
     int32_t (*Disable)(void);
     int32_t (*SetBatch)(int64_t samplingInterval, int64_t reportInterval);
@@ -26,7 +25,7 @@ struct SensorDeviceInfo {
 };
 
 int32_t AddSensorDevice(const struct SensorDeviceInfo *deviceInfo);
-int32_t DeleteSensorDevice(int32_t sensorId);
+int32_t DeleteSensorDevice(const struct SensorBasicInfo *sensorBaseInfo);
 int32_t ReportSensorEvent(const struct SensorReportEvent *events);
 
 #endif /* SENSOR_DEVICE_IF_H */

model/sensor/driver/include/sensor_platform_if.h

@@ -40,15 +40,14 @@
 
 #define SENSOR_ADDR_WIDTH_1_BYTE        1 // 8 bit
 #define SENSOR_ADDR_WIDTH_2_BYTE        2 // 16 bit
-#define SENSOR_ADDR_WIDTH_4_BYTE        4 // 32 bit
+#define SENSOR_ADDR_WIDTH_4_BYTE        4 // 16 bit
 #define SENSOR_DATA_WIDTH_8_BIT         8 // 8 bit
 #define SENSOR_CONVERT_UNIT             1000
 #define SENSOR_1K_UNIT                  1024
 #define SENSOR_SPI_MAX_SPEED             115200
 #define SENSOR_SECOND_CONVERT_NANOSECOND    (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT)
 
-#define MAX_SENSOR_EXIT_THREAD_COUNT    10
+#define SENSOR_TIMER_MIN_TIME    20
-#define MAX_SENSOR_WAIT_THREAD_TIME     100 // 100MS
 
 enum SensorBusType {
     SENSOR_BUS_I2C = 0,
@@ -96,7 +95,5 @@ enum SENSORConfigValueIndex {
 int32_t ReadSensor(struct SensorBusCfg *busCfg, uint16_t regAddr, uint8_t *data, uint16_t dataLen);
 int32_t WriteSensor(struct SensorBusCfg *busCfg, uint8_t *writeData, uint16_t len);
 int32_t SetSensorPinMux(uint32_t regAddr, int32_t regSize, uint32_t regValue);
-int32_t CreateSensorThread(struct OsalThread *thread, OsalThreadEntry threadEntry, char *name, void *entryPara);
-void DestroySensorThread(struct OsalThread *thread, uint8_t *status);
 
 #endif /* SENSOR_PLATFORM_IF_H */

test/unittest/sensor/hdf_sensor_test.c

@@ -12,7 +12,6 @@
 #include "hdf_sensor_test.h"
 #include "osal_math.h"
 #include "osal_time.h"
-#include "osal_timer.h"
 #include "sensor_platform_if.h"
 #include "sensor_device_manager.h"
 #include "sensor_device_type.h"
@@ -22,18 +21,19 @@
 #define HDF_SENSOR_TEST_VALUE    1024000000 // 1g = 9.8m/s^2
 #define SENSOR_TEST_MAX_RANGE    8
 #define SENSOR_TEST_MAX_POWER    230
+#define HDF_SENSOR_TEST_WORK_QUEUE_NAME    "hdf_sensor_test_work_queue"
 
 static struct SensorTestDrvData *GetSensorTestDrvData(void)
 {
     static struct SensorTestDrvData sensorTestDrvData = {
-        .threadStatus = SENSOR_THREAD_NONE,
+        .enable = false,
         .initStatus = false,
         .interval = SENSOR_TEST_SAMPLING_200_MS,
     };
 
     return &sensorTestDrvData;
 }
-static void SensorReadTestData(void)
+static void SensorTestDataWorkEntry(void *arg)
 {
     int32_t value = HDF_SENSOR_TEST_VALUE;
     struct SensorReportEvent event;
@@ -52,75 +52,89 @@ static void SensorReadTestData(void)
     ReportSensorEvent(&event);
 }
 
-static int32_t SensorReadDataThreadTestWorker(void *arg)
+static void SensorTestTimerEntry(uintptr_t arg)
 {
-    (void)arg;
     int64_t interval;
-    CHECK_NULL_PTR_RETURN_VALUE(arg, HDF_ERR_INVALID_PARAM);
+    struct SensorTestDrvData *drvData = (struct SensorTestDrvData *)arg;
-    struct SensorTestDrvData *drvData = GetSensorTestDrvData();
+    CHECK_NULL_PTR_RETURN(drvData);
 
-    drvData->threadStatus = SENSOR_THREAD_START;
+    if (!HdfAddWork(&drvData->workQueue, &drvData->work)) {
-    while (true) {
+        HDF_LOGE("%s: sensor test add work queue failed", __func__);
-        if (drvData->threadStatus == SENSOR_THREAD_RUNNING) {
-            SensorReadTestData();
-            interval = OsalDivS64(drvData->interval, (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT));
-            OsalMSleep(interval);
-        } else if (drvData->threadStatus == SENSOR_THREAD_STOPPING) {
-            drvData->threadStatus = SENSOR_THREAD_STOPPED;
-            break;
-        } else {
-            OsalMSleep(SENSOR_TEST_SAMPLING_200_MS / SENSOR_CONVERT_UNIT / SENSOR_CONVERT_UNIT);
-        }
-
-        if ((!drvData->initStatus) || (drvData->interval < 0) || drvData->threadStatus != SENSOR_THREAD_RUNNING) {
-            continue;
-        }
     }
 
-    HDF_LOGE("%s: Sensor test thread have exited", __func__);
+    interval = OsalDivS64(drvData->interval, (SENSOR_CONVERT_UNIT * SENSOR_CONVERT_UNIT));
-    return HDF_SUCCESS;
+    interval = (interval < SENSOR_TIMER_MIN_TIME) ? SENSOR_TIMER_MIN_TIME : interval;
+
+    if (OsalTimerSetTimeout(&drvData->timer, interval) != HDF_SUCCESS) {
+        HDF_LOGE("%s: sensor test modify time failed", __func__);
+    }
 }
 
 static int32_t SensorInitTestConfig(void)
 {
     struct SensorTestDrvData *drvData = GetSensorTestDrvData();
 
-    if (drvData->threadStatus != SENSOR_THREAD_NONE && drvData->threadStatus != SENSOR_THREAD_DESTROY) {
+    if (HdfWorkQueueInit(&drvData->workQueue, HDF_SENSOR_TEST_WORK_QUEUE_NAME) != HDF_SUCCESS) {
-        HDF_LOGE("%s: Sensor test thread have created", __func__);
+        HDF_LOGE("%s: sensor test init work queue failed", __func__);
-        return HDF_SUCCESS;
-    }
-
-    int32_t ret = CreateSensorThread(&drvData->thread, SensorReadDataThreadTestWorker, "hdf_sensor_test", drvData);
-    if (ret != HDF_SUCCESS) {
-        HDF_LOGE("%s: Sensor test create thread failed", __func__);
-        drvData->threadStatus = SENSOR_THREAD_NONE;
         return HDF_FAILURE;
     }
+
+    if (HdfWorkInit(&drvData->work, SensorTestDataWorkEntry, drvData) != HDF_SUCCESS) {
+        HDF_LOGE("%s: sensor test create thread failed", __func__);
+        return HDF_FAILURE;
+    }
+
+    drvData->enable = false;
     drvData->initStatus = true;
 
     return HDF_SUCCESS;
 }
 
-static int32_t SensorGetInfoTest(struct SensorBasicInfo *info)
-{
-    (void)info;
-
-    return HDF_SUCCESS;
-}
-
 static int32_t SensorEnableTest(void)
 {
+    int32_t ret;
     struct SensorTestDrvData *drvData = GetSensorTestDrvData();
 
-    drvData->threadStatus = SENSOR_THREAD_RUNNING;
+    if (drvData->enable) {
+        HDF_LOGE("%{public}s: sensor test had enable", __func__);
+        return HDF_SUCCESS;
+    }
+
+    ret = OsalTimerCreate(&drvData->timer, SENSOR_TIMER_MIN_TIME, SensorTestTimerEntry, (uintptr_t)drvData);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%{public}s: sensor test create timer failed[%{public}d]", __func__, ret);
+        return ret;
+    }
+
+    ret = OsalTimerStartLoop(&drvData->timer);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%{public}s: sensor test start timer failed[%{public}d]", __func__, ret);
+        return ret;
+    }
+    drvData->enable = true;
+
     return HDF_SUCCESS;
 }
 
 static int32_t SensorDisableTest(void)
 {
+    int32_t ret;
     struct SensorTestDrvData *drvData = GetSensorTestDrvData();
 
-    drvData->threadStatus = SENSOR_THREAD_STOPPED;
+    if (!drvData->enable) {
+        HDF_LOGE("%s: sensor test had disable", __func__);
+        return HDF_SUCCESS;
+    }
+
+    if (drvData->timer.realTimer != NULL) {
+        ret = OsalTimerDelete(&drvData->timer);
+        if (ret != HDF_SUCCESS) {
+            HDF_LOGE("%s: sensor test delete timer failed", __func__);
+            return ret;
+        }
+    }
+
+    drvData->enable = false;
 
     return HDF_SUCCESS;
 }
@@ -172,7 +186,6 @@ int32_t InitSensorDriverTest(struct HdfDeviceObject *device)
 {
     int32_t ret;
     (void)device;
-    struct SensorTestDrvData *drvData = GetSensorTestDrvData();
 
     struct SensorDeviceInfo deviceInfo = {
         .sensorInfo = {
@@ -187,7 +200,6 @@ int32_t InitSensorDriverTest(struct HdfDeviceObject *device)
             .power = SENSOR_TEST_MAX_POWER,
         },
         .ops = {
-            .GetInfo = SensorGetInfoTest,
             .Enable = SensorEnableTest,
             .Disable = SensorDisableTest,
             .SetBatch = SensorSetBatchTest,
@@ -199,14 +211,13 @@ int32_t InitSensorDriverTest(struct HdfDeviceObject *device)
     ret = SensorInitTestConfig();
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("%s: sensor test config failed", __func__);
-        return HDF_FAILURE;
+        return ret;
     }
 
     ret = AddSensorDevice(&deviceInfo);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("%s: sensor test register failed", __func__);
-        (void)DestroySensorThread(&drvData->thread, &drvData->threadStatus);
+        return ret;
-        return HDF_FAILURE;
     }
 
     HDF_LOGI("%s: init sensor test driver success", __func__);
@@ -216,10 +227,29 @@ int32_t InitSensorDriverTest(struct HdfDeviceObject *device)
 void ReleaseSensorDriverTest(struct HdfDeviceObject *device)
 {
     (void)device;
+    int32_t ret;
     struct SensorTestDrvData *drvData = GetSensorTestDrvData();
+    struct SensorDeviceInfo deviceInfo = {
+        .sensorInfo = {
+            .sensorName = "sensor_test",
+            .vendorName = "default",
+            .firmwareVersion = "1.0",
+            .hardwareVersion = "1.0",
+            .sensorTypeId = SENSOR_TAG_NONE,
+            .sensorId = SENSOR_TAG_NONE,
+            .maxRange = SENSOR_TEST_MAX_RANGE,
+            .accuracy = 1,
+            .power = SENSOR_TEST_MAX_POWER,
+        }
+    };
+    (void)DeleteSensorDevice(&deviceInfo.sensorInfo);
 
-    (void)DestroySensorThread(&drvData->thread, &drvData->threadStatus);
+    if (drvData->timer.realTimer != NULL) {
-    (void)DeleteSensorDevice(SENSOR_TAG_NONE);
+        ret = OsalTimerDelete(&drvData->timer);
+        if (ret != HDF_SUCCESS) {
+            HDF_LOGE("%s: sensor test delete timer failed", __func__);
+        }
+    }
 }
 
 struct HdfDriverEntry g_sensorTestDevEntry = {

test/unittest/sensor/hdf_sensor_test.h

@@ -9,15 +9,18 @@
 #ifndef HDF_SENSOR_DRIVER_TEST_H
 #define HDF_SENSOR_DRIVER_TEST_H
 
-#include "osal_thread.h"
+#include "hdf_workqueue.h"
+#include "osal_timer.h"
 
 #define SENSOR_TEST_SAMPLING_200_MS    200000000
 
 struct SensorTestDrvData {
-    uint8_t threadStatus;
     uint8_t initStatus;
     int64_t interval;
-    struct OsalThread thread;
+    HdfWorkQueue workQueue;
+    HdfWork work;
+    OsalTimer timer;
+    bool enable;
 };
 
 #endif // HDF_SENSOR_DRIVER_TEST_H