From b80435879ac66f0ccab3acb573baf4e95112a107 Mon Sep 17 00:00:00 2001 From: jifengfei Date: Tue, 24 Aug 2021 20:19:00 +0800 Subject: [PATCH] add sensor hall driver Signed-off-by: jifengfei --- .../sensor/driver/chipset/hall/hall_ak8789.c | 88 ++++ .../sensor/driver/chipset/hall/hall_ak8789.h | 17 + model/sensor/driver/hall/sensor_hall_driver.c | 453 ++++++++++++++++++ model/sensor/driver/hall/sensor_hall_driver.h | 53 ++ 4 files changed, 611 insertions(+) create mode 100755 model/sensor/driver/chipset/hall/hall_ak8789.c create mode 100755 model/sensor/driver/chipset/hall/hall_ak8789.h create mode 100755 model/sensor/driver/hall/sensor_hall_driver.c create mode 100755 model/sensor/driver/hall/sensor_hall_driver.h diff --git a/model/sensor/driver/chipset/hall/hall_ak8789.c b/model/sensor/driver/chipset/hall/hall_ak8789.c new file mode 100755 index 000000000..e0eed99be --- /dev/null +++ b/model/sensor/driver/chipset/hall/hall_ak8789.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. + */ + +//新的3516D上hall传感器使用的gpio号有两个24和25，24指向北极中断，25指向南极中断，采用中断下降沿，靠近hall器件时，会出发中断。 +#include "securec.h" +#include "hall_ak8789.h" +#include "osal_time.h" +#include "sensor_hall_driver.h" +#include "sensor_config_controller.h" +#include "sensor_device_manager.h" +#include "osal_irq.h" + +/* IO config for int-pin and Gpio-pin */ +#define SENSOR_HALL_DATA_REG_ADDR 0x114f0040 +#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; + uint8_t status = 0; + OsalTimespec time; + struct SensorReportEvent event; + + (void)memset_s(&event, sizeof(event), 0, sizeof(event)); + (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; + } + + 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); + 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) { + HDF_LOGE("%s: Data write mux pin failed", __func__); + return HDF_FAILURE; + } + if (SetSensorPinMux(SENSOR_HALL_CLK_REG_ADDR, SENSOR_ADDR_WIDTH_4_BYTE, SENSOR_HALL_REG_CFG) != HDF_SUCCESS) { + HDF_LOGE("%s: Clk write mux pin failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +int32_t DetectHallAk8789Chip(struct SensorCfgData *data) +{ + int32_t ret; + struct HallOpsCall ops; + CHECK_NULL_PTR_RETURN_VALUE(data, HDF_ERR_INVALID_PARAM); + + if (strcmp(HALL_CHIP_NAME_AK8789, data->sensorAttr.chipName) != 0) { + return HDF_SUCCESS; + } + ret = InitHallPreConfig(); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: init AK8789 bus mux config", __func__); + return HDF_FAILURE; + } + ops.Init = NULL; + ops.ReadData = ReadAk8789Data; + ret = RegisterHallChipOps(&ops); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: register AK8789 hall failed", __func__); + return HDF_FAILURE; + } + return HDF_SUCCESS; +} diff --git a/model/sensor/driver/chipset/hall/hall_ak8789.h b/model/sensor/driver/chipset/hall/hall_ak8789.h new file mode 100755 index 000000000..003c89fb4 --- /dev/null +++ b/model/sensor/driver/chipset/hall/hall_ak8789.h @@ -0,0 +1,17 @@ +/* + * 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 HALL_AK8789_H +#define HALL_AK8789_H + +#include "sensor_config_parser.h" + +int32_t DetectHallAk8789Chip(struct SensorCfgData *data); +int32_t ReadAk8789Data(struct SensorCfgData *data); + +#endif /* HALL_AK8789_H */ diff --git a/model/sensor/driver/hall/sensor_hall_driver.c b/model/sensor/driver/hall/sensor_hall_driver.c new file mode 100755 index 000000000..5957ac2de --- /dev/null +++ b/model/sensor/driver/hall/sensor_hall_driver.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 "securec.h" +#include "hall_ak8789.h" +#include "hdf_base.h" +#include "hdf_device_desc.h" +#include "osal_math.h" +#include "osal_mem.h" +#include "sensor_hall_driver.h" +#include "sensor_config_controller.h" +#include "sensor_device_manager.h" +#include "sensor_platform_if.h" +#include "osal_irq.h" +#include "gpio_if.h" + +#define HDF_LOG_TAG sensor_hall_driver_c +#define HDF_HALL_WORK_QUEUE_NAME "hdf_hall_work_queue" + +static struct HallDetectIfList g_hallDetectIfList[] = { + {HALL_CHIP_NAME_AK8789, DetectHallAk8789Chip}, +}; + +static struct HallDrvData *g_hallDrvData = NULL; + +static struct HallDrvData *HallGetDrvData(void) +{ + return g_hallDrvData; +} + + int32_t RegisterHallChipOps(const struct HallOpsCall *ops) +{ + struct HallDrvData *drvData = NULL; + CHECK_NULL_PTR_RETURN_VALUE(ops, HDF_ERR_INVALID_PARAM); + drvData = HallGetDrvData(); + 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 HallDataWorkEntry(void *arg) +{ + int32_t ret; + struct HallDrvData *drvData = (struct HallDrvData *)arg; + CHECK_NULL_PTR_RETURN(drvData); + CHECK_NULL_PTR_RETURN(drvData->ops.ReadData); + + ret = drvData->ops.ReadData(drvData->hallCfg); + if (ret != HDF_SUCCESS) { + HDF_LOGE("%s: hall read data failed", __func__); + return; + } +} + +static int32_t HallNorthPolarityIrqFunc(uint16_t gpio, void *data) +{ + (void)gpio; + + HDF_LOGE("%s: trigger north polarity irq rasing", __func__); + + 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__); + } + + return HDF_SUCCESS; +} + +static int32_t HallSouthPolarityIrqFunc(uint16_t gpio, void *data) +{ + (void)gpio; + + HDF_LOGE("%s: trigger south polarity irq rasing", __func__); + + 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__); + } + + return HDF_SUCCESS; +} + + +static int32_t InitHallData(void) +{ + struct HallDrvData *drvData = HallGetDrvData(); + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + if (drvData->initStatus) { + return HDF_SUCCESS; + } + + if (HdfWorkQueueInit(&drvData->hallWorkQueue, HDF_HALL_WORK_QUEUE_NAME) != HDF_SUCCESS) { + HDF_LOGE("%s: hall init work queue failed", __func__); + return HDF_FAILURE; + } + + if (HdfWorkInit(&drvData->hallWork, HallDataWorkEntry, drvData) != HDF_SUCCESS) { + HDF_LOGE("%s: hall create thread failed", __func__); + return HDF_FAILURE; + } + + //CHECK_NULL_PTR_RETURN_VALUE(drvData->ops.Init, HDF_ERR_INVALID_PARAM); + + drvData->interval = SENSOR_TIMER_MIN_TIME; + drvData->initStatus = true; + drvData->enable = false; + + return HDF_SUCCESS; +} + +static int32_t SetHallEnable(void) +{ + int32_t ret; + struct HallDrvData *drvData = HallGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + if (drvData->enable) { + HDF_LOGE("%s: hall sensor is enabled", __func__); + return HDF_SUCCESS; + } + + if(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO] >= 0) { + ret = GpioSetIrq(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO], OSAL_IRQF_TRIGGER_FALLING, HallNorthPolarityIrqFunc, drvData); + if(ret != 0 ) { + HDF_LOGE("%s: gpio set north irq failed", __func__); + } + ret = GpioEnableIrq(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO]); + if(ret != 0 ) { + HDF_LOGE("%s: gpio enable north irq failed", __func__); + } + } + + if(drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO] >= 0) { + ret = GpioSetIrq(drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO], OSAL_IRQF_TRIGGER_FALLING, HallSouthPolarityIrqFunc, drvData); + if(ret != 0 ) { + HDF_LOGE("%s: gpio set south irq failed", __func__); + } + ret = GpioEnableIrq(drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO]); + if(ret != 0 ) { + HDF_LOGE("%s: gpio enable south irq failed", __func__); + } + } + + drvData->enable = true; + + return HDF_SUCCESS; +} + +static int32_t SetHallDisable(void) +{ + int32_t ret; + struct HallDrvData *drvData = HallGetDrvData(); + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + if (!drvData->enable) { + HDF_LOGE("%s: hall sensor had disable", __func__); + return HDF_SUCCESS; + } + + if(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO] >= 0) { + ret = GpioUnSetIrq(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO]); + if(ret != 0 ) { + HDF_LOGE("%s: gpio unset north irq failed", __func__); + } + ret = GpioDisableIrq(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO]); + 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(ret != 0 ) { + HDF_LOGE("%s: gpio unset south irq failed", __func__); + } + ret = GpioDisableIrq(drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO]); + if(ret != 0 ) { + HDF_LOGE("%s: gpio disable south irq failed", __func__); + } + + } + + drvData->enable = false; + return HDF_SUCCESS; +} + +static int32_t SetHallBatch(int64_t samplingInterval, int64_t interval) +{ + return HDF_SUCCESS; +} + +static int32_t SetHallMode(int32_t mode) +{ + return (mode == SENSOR_WORK_MODE_ON_CHANGE) ? HDF_SUCCESS : HDF_FAILURE; +} + +static int32_t SetHallOption(uint32_t option) +{ + (void)option; + return HDF_SUCCESS; +} + +static int32_t DispatchHall(struct HdfDeviceIoClient *client, + int cmd, struct HdfSBuf *data, struct HdfSBuf *reply) +{ + (void)client; + (void)cmd; + (void)data; + (void)reply; + + return HDF_SUCCESS; +} + +int32_t BindHallDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + HDF_LOGI("%s: hall sensor bind success", __func__); + + struct HallDrvData *drvData = (struct HallDrvData *)OsalMemCalloc(sizeof(*drvData)); + if (drvData == NULL) { + HDF_LOGE("%s: malloc hall drv data fail!", __func__); + return HDF_ERR_MALLOC_FAIL; + } + + drvData->ioService.Dispatch = DispatchHall; + drvData->device = device; + device->service = &drvData->ioService; + g_hallDrvData = drvData; + return HDF_SUCCESS; +} + +static int32_t InitHallOps(struct SensorDeviceInfo *deviceInfo) +{ + struct HallDrvData *drvData = HallGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + deviceInfo->ops.Enable = SetHallEnable; + deviceInfo->ops.Disable = SetHallDisable; + deviceInfo->ops.SetBatch = SetHallBatch; + deviceInfo->ops.SetMode = SetHallMode; + deviceInfo->ops.SetOption = SetHallOption; + + if (memcpy_s(&deviceInfo->sensorInfo, sizeof(deviceInfo->sensorInfo), + &drvData->hallCfg->sensorInfo, sizeof(drvData->hallCfg->sensorInfo)) != EOK) { + HDF_LOGE("%s: copy sensor info failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t InitHallAfterConfig(void) +{ + struct SensorDeviceInfo deviceInfo; + + if (InitHallData() != HDF_SUCCESS) { + HDF_LOGE("%s: init hall config failed", __func__); + return HDF_FAILURE; + } + + if (InitHallOps(&deviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: init hall ops failed", __func__); + return HDF_FAILURE; + } + + if (AddSensorDevice(&deviceInfo) != HDF_SUCCESS) { + HDF_LOGE("%s: add hall device failed", __func__); + return HDF_FAILURE; + } + + return HDF_SUCCESS; +} + +static int32_t DetectHallChip(void) +{ + int32_t num; + int32_t ret; + int32_t loop; + struct HallDrvData *drvData = HallGetDrvData(); + + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + CHECK_NULL_PTR_RETURN_VALUE(drvData->hallCfg, HDF_ERR_INVALID_PARAM); + + num = sizeof(g_hallDetectIfList) / sizeof(g_hallDetectIfList[0]); + for (loop = 0; loop < num; ++loop) { + if (g_hallDetectIfList[loop].DetectChip != NULL) { + ret = g_hallDetectIfList[loop].DetectChip(drvData->hallCfg); + if (ret == HDF_SUCCESS) { + drvData->detectFlag = true; + return HDF_SUCCESS; + } + } + } + + HDF_LOGE("%s: detect hall device failed", __func__); + drvData->detectFlag = false; + return HDF_FAILURE; +} + +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", &drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO], 0); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "NorthPolarityGpio"); + ret = parser->GetUint32(pinNode, "SouthPolarityGpio", &drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO], 0); + CHECK_PARSER_RESULT_RETURN_VALUE(ret, "SouthPolarityGpio"); + + return HDF_SUCCESS; +} + + + +int32_t InitHallDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM); + HDF_LOGI("%s: hall sensor init success", __func__); + struct HallDrvData *drvData = (struct HallDrvData *)device->service; + CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM); + + if (drvData->detectFlag) { + HDF_LOGE("%s: hall sensor have detected", __func__); + return HDF_SUCCESS; + } + + drvData->hallCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->hallCfg)); + if (drvData->hallCfg == NULL) { + HDF_LOGE("%s: malloc sensor config data failed", __func__); + return HDF_FAILURE; + } + + if (GetSensorBaseConfigData(device->property, drvData->hallCfg) != HDF_SUCCESS) { + HDF_LOGE("%s: get sensor base config failed", __func__); + + goto BASE_CONFIG_EXIT; + } + + if (ParserHallPinConfigData(device->property, drvData) != HDF_SUCCESS) { + HDF_LOGE("%s: get hall pin config failed", __func__); + + goto PIN_CONFIG_EXIT; + } + + HDF_LOGI("%s,%s,%s,%s,%d,%d,%d,%d,%d",drvData->hallCfg->sensorInfo.sensorName, + drvData->hallCfg->sensorInfo.vendorName, + drvData->hallCfg->sensorInfo.firmwareVersion, + drvData->hallCfg->sensorInfo.hardwareVersion, + drvData->hallCfg->sensorInfo.sensorTypeId, + drvData->hallCfg->sensorInfo.sensorId, + drvData->hallCfg->sensorInfo.maxRange, + drvData->hallCfg->sensorInfo.accuracy, + drvData->hallCfg->sensorInfo.power + ); + + if(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO] >= 0) { + int ret = GpioSetDir(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO], GPIO_DIR_IN); + if (ret != 0) { + HDF_LOGE("%s:%d HALL north gpio failed", __func__, __LINE__); + } + } + + if(drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO] >= 0) { + int ret = GpioSetDir(drvData->GpioIrq[HALL_SOUTH_POLARITY_GPIO], GPIO_DIR_IN); + if (ret != 0) { + HDF_LOGE("%s:%d HALL south gpio failed", __func__, __LINE__); + } + } + + // if return failure, hdf framework go to next detect sensor + if (DetectHallChip() != HDF_SUCCESS) { + HDF_LOGE("%s: hall sensor detect device no exist", __func__); + goto DETECT_CHIP_EXIT; + } + drvData->detectFlag = true; + + if (InitHallAfterConfig() != HDF_SUCCESS) { + HDF_LOGE("%s: init hall after config failed", __func__); + goto INIT_EXIT; + } + + HDF_LOGI("%s: init hall driver success", __func__); + return HDF_SUCCESS; + +INIT_EXIT: + (void)DeleteSensorDevice(&drvData->hallCfg->sensorInfo); +DETECT_CHIP_EXIT: + drvData->detectFlag = false; +BASE_CONFIG_EXIT: + drvData->hallCfg->root = NULL; + OsalMemFree(drvData->hallCfg); + drvData->hallCfg = NULL; + return HDF_FAILURE; +PIN_CONFIG_EXIT: + OsalMemFree(drvData); + drvData = NULL; + return HDF_FAILURE; +} + +void ReleaseHallDriver(struct HdfDeviceObject *device) +{ + CHECK_NULL_PTR_RETURN(device); + HDF_LOGI("%s: hall sensor release success", __func__); + + struct HallDrvData *drvData = (struct HallDrvData *)device->service; + CHECK_NULL_PTR_RETURN(drvData); + + (void)DeleteSensorDevice(&drvData->hallCfg->sensorInfo); + drvData->detectFlag = false; + + if (drvData->hallCfg != NULL) { + drvData->hallCfg->root = NULL; + OsalMemFree(drvData->hallCfg); + drvData->hallCfg = NULL; + } + + drvData->initStatus = false; +} + +struct HdfDriverEntry g_sensorHallDevEntry = { + .moduleVersion = 1, + .moduleName = "HDF_SENSOR_HALL", + .Bind = BindHallDriver, + .Init = InitHallDriver, + .Release = ReleaseHallDriver, +}; + +HDF_INIT(g_sensorHallDevEntry); + diff --git a/model/sensor/driver/hall/sensor_hall_driver.h b/model/sensor/driver/hall/sensor_hall_driver.h new file mode 100755 index 000000000..fbd8f147a --- /dev/null +++ b/model/sensor/driver/hall/sensor_hall_driver.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 SENSOR_HALL_DRIVER_H +#define SENSOR_HALL_DRIVER_H + +#include "hdf_workqueue.h" +//#include "osal_mutex.h" +//#include "osal_timer.h" +#include "sensor_config_parser.h" +#include "sensor_platform_if.h" +//#include "gpio_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 HallDetectIfList { + char *chipName; + int32_t (*DetectChip)(struct SensorCfgData *data); +}; + +struct HallOpsCall { + int32_t (*Init)(struct SensorCfgData *data); + int32_t (*ReadData)(struct SensorCfgData *data); +}; + +struct HallDrvData { + struct IDeviceIoService ioService; + struct HdfDeviceObject *device; + HdfWorkQueue hallWorkQueue; + HdfWork hallWork; + bool detectFlag; + bool enable; + bool initStatus; + int64_t interval; + struct SensorCfgData *hallCfg; + struct HallOpsCall ops; + int32_t GpioIrq[HALL_POLARITY_GPIO_MAX]; +}; + +int32_t RegisterHallChipOps(const struct HallOpsCall *ops); + +#endif /* SENSOR_HALL_DRIVER_H */ -- Gitee