openharmony/drivers_framework
1
0
Fork 0
mirror of https://github.com/openharmony/drivers_framework.git synced 2026-08-26 18:17:07 -04:00
Code Issues Packages Projects Releases Wiki Activity

modify code

Browse Source 
Signed-off-by: jifengfei <jifengfei2@huawei.com>
This commit is contained in:
jifengfei
2021-09-04 19:57:59 +08:00
parent 2c3f7be421
commit 58905cd6be
4 changed files with 650 additions and 650 deletions
Download Patch File Download Diff File Expand all files Collapse all files
model/sensor/driver/chipset/hall/hall_ak8789.c
+154 -154
View File
@@ -1,155 +1,155 @@
/*
* 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 "hall_ak8789.h"
#include <securec.h>
#include "osal_irq.h"
#include "osal_mem.h"
#include "osal_time.h"
#include "sensor_config_controller.h"
#include "sensor_device_manager.h"
#include "sensor_hall_driver.h"
#define HDF_LOG_TAG hall_ak8789_c
static struct Ak8789DrvData *g_ak8789DrvData = NULL;
struct Ak8789DrvData *Ak8789GetDrvData(void)
{
return g_ak8789DrvData;
}
/* 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;
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) {
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;
}
static int32_t DispatchAK8789(struct HdfDeviceIoClient *client,
int cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
{
(void)client;
(void)cmd;
(void)data;
(void)reply;
return HDF_SUCCESS;
}
int32_t Ak8789BindDriver(struct HdfDeviceObject *device)
{
CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
struct Ak8789DrvData *drvData = (struct Ak8789DrvData *)OsalMemCalloc(sizeof(*drvData));
if (drvData == NULL) {
HDF_LOGE("%s: Malloc Ak8789 drv data fail", __func__);
return HDF_ERR_MALLOC_FAIL;
}
drvData->ioService.Dispatch = DispatchAK8789;
drvData->device = device;
device->service = &drvData->ioService;
g_ak8789DrvData = drvData;
return HDF_SUCCESS;
}
int32_t AK8789InitDriver(struct HdfDeviceObject *device)
{
int32_t ret;
struct HallOpsCall ops;
CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
struct Ak8789DrvData *drvData = (struct Ak8789DrvData *)device->service;
CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
ret = InitHallPreConfig();
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: Init AK8789 bus mux config", __func__);
return HDF_FAILURE;
}
drvData->sensorCfg = HallCreateCfgData(device->property);
if (drvData->sensorCfg == NULL) {
return HDF_ERR_NOT_SUPPORT;
}
ops.Init = NULL;
ops.ReadData = ReadAk8789Data;
ret = HallRegisterChipOps(&ops);
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: Register AK8789 hall failed", __func__);
return HDF_FAILURE;
}
return HDF_SUCCESS;
}
void Ak8789ReleaseDriver(struct HdfDeviceObject *device)
{
CHECK_NULL_PTR_RETURN(device);
struct Ak8789DrvData *drvData = (struct Ak8789DrvData *)device->service;
CHECK_NULL_PTR_RETURN(drvData);
HallReleaseCfgData(drvData->sensorCfg);
drvData->sensorCfg = NULL;
OsalMemFree(drvData);
}
struct HdfDriverEntry g_hallAk8789DevEntry = {
.moduleVersion = 1,
.moduleName = "HDF_SENSOR_HALL_AK8789",
.Bind = Ak8789BindDriver,
.Init = AK8789InitDriver,
.Release = Ak8789ReleaseDriver,
};
/*
* 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 "hall_ak8789.h"
#include <securec.h>
#include "osal_irq.h"
#include "osal_mem.h"
#include "osal_time.h"
#include "sensor_config_controller.h"
#include "sensor_device_manager.h"
#include "sensor_hall_driver.h"
#define HDF_LOG_TAG hall_ak8789_c
static struct Ak8789DrvData *g_ak8789DrvData = NULL;
struct Ak8789DrvData *Ak8789GetDrvData(void)
{
return g_ak8789DrvData;
}
/* 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;
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) {
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;
}
static int32_t DispatchAK8789(struct HdfDeviceIoClient *client,
int cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
{
(void)client;
(void)cmd;
(void)data;
(void)reply;
return HDF_SUCCESS;
}
int32_t Ak8789BindDriver(struct HdfDeviceObject *device)
{
CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
struct Ak8789DrvData *drvData = (struct Ak8789DrvData *)OsalMemCalloc(sizeof(*drvData));
if (drvData == NULL) {
HDF_LOGE("%s: Malloc Ak8789 drv data fail", __func__);
return HDF_ERR_MALLOC_FAIL;
}
drvData->ioService.Dispatch = DispatchAK8789;
drvData->device = device;
device->service = &drvData->ioService;
g_ak8789DrvData = drvData;
return HDF_SUCCESS;
}
int32_t AK8789InitDriver(struct HdfDeviceObject *device)
{
int32_t ret;
struct HallOpsCall ops;
CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
struct Ak8789DrvData *drvData = (struct Ak8789DrvData *)device->service;
CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
ret = InitHallPreConfig();
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: Init AK8789 bus mux config", __func__);
return HDF_FAILURE;
}
drvData->sensorCfg = HallCreateCfgData(device->property);
if (drvData->sensorCfg == NULL) {
return HDF_ERR_NOT_SUPPORT;
}
ops.Init = NULL;
ops.ReadData = ReadAk8789Data;
ret = HallRegisterChipOps(&ops);
if (ret != HDF_SUCCESS) {
HDF_LOGE("%s: Register AK8789 hall failed", __func__);
return HDF_FAILURE;
}
return HDF_SUCCESS;
}
void Ak8789ReleaseDriver(struct HdfDeviceObject *device)
{
CHECK_NULL_PTR_RETURN(device);
struct Ak8789DrvData *drvData = (struct Ak8789DrvData *)device->service;
CHECK_NULL_PTR_RETURN(drvData);
HallReleaseCfgData(drvData->sensorCfg);
drvData->sensorCfg = NULL;
OsalMemFree(drvData);
}
struct HdfDriverEntry g_hallAk8789DevEntry = {
.moduleVersion = 1,
.moduleName = "HDF_SENSOR_HALL_AK8789",
.Bind = Ak8789BindDriver,
.Init = AK8789InitDriver,
.Release = Ak8789ReleaseDriver,
};
HDF_INIT(g_hallAk8789DevEntry);
model/sensor/driver/chipset/hall/hall_ak8789.h
+23 -23
View File
@@ -1,24 +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.
*/
#ifndef HALL_AK8789_H
#define HALL_AK8789_H
#include "sensor_config_parser.h"
#include "sensor_hall_driver.h"
int32_t DetectHallAk8789Chip(struct SensorCfgData *data);
int32_t ReadAk8789Data(struct SensorCfgData *data);
struct Ak8789DrvData {
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 HALL_AK8789_H
#define HALL_AK8789_H
#include "sensor_config_parser.h"
#include "sensor_hall_driver.h"
int32_t DetectHallAk8789Chip(struct SensorCfgData *data);
int32_t ReadAk8789Data(struct SensorCfgData *data);
struct Ak8789DrvData {
struct IDeviceIoService ioService;
struct HdfDeviceObject *device;
struct SensorCfgData *sensorCfg;
};
#endif /* HALL_AK8789_H */
model/sensor/driver/hall/sensor_hall_driver.c
+427 -427
View File
@@ -1,428 +1,428 @@
/*
* 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_hall_driver.h"
#include <securec.h>
#include "gpio_if.h"
#include "hall_ak8789.h"
#include "hdf_base.h"
#include "hdf_device_desc.h"
#include "osal_irq.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_hall_driver_c
#define HDF_HALL_WORK_QUEUE_NAME "hdf_hall_work_queue"
static struct HallDrvData *g_hallDrvData = NULL;
static struct HallDrvData *HallGetDrvData(void)
{
return g_hallDrvData;
}
int32_t HallRegisterChipOps(const struct HallOpsCall *ops)
{
struct HallDrvData *drvData = HallGetDrvData();
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 HallDataWorkEntry(void *arg)
{
struct HallDrvData *drvData = NULL;
drvData = (struct HallDrvData *)arg;
CHECK_NULL_PTR_RETURN(drvData);
if (drvData->ops.ReadData == NULL) {
HDF_LOGI("%s: Hall ReadData function NULL", __func__);
return;
}
if (drvData->ops.ReadData(drvData->hallCfg) != HDF_SUCCESS) {
HDF_LOGE("%s: Hall read data failed", __func__);
}
}
static int32_t HallNorthPolarityIrqFunc(uint16_t gpio, void *data)
{
(void)gpio;
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;
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(struct HallDrvData *drvData)
{
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;
}
drvData->interval = SENSOR_TIMER_MIN_TIME;
drvData->enable = false;
drvData->detectFlag = 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("Gpio set north irq failed: %d", ret);
}
ret = GpioEnableIrq(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO]);
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,
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 HallBindDriver(struct HdfDeviceObject *device)
{
CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
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 SensorCfgData *config, struct SensorDeviceInfo *deviceInfo)
{
CHECK_NULL_PTR_RETURN_VALUE(config, 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),
&config->sensorInfo, sizeof(config->sensorInfo)) != EOK) {
HDF_LOGE("%s: Copy sensor info failed", __func__);
return HDF_FAILURE;
}
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;
CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM);
CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
if (InitHallOps(drvData->hallCfg, &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;
}
if (ParserHallPinConfigData(node, drvData) != HDF_SUCCESS) {
HDF_LOGE("%s: get hall pin 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 (ret != 0) {
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 (ret != 0) {
HDF_LOGE("%s:%d south south gpio dir failed", __func__, __LINE__);
return HDF_FAILURE;
}
}
return HDF_SUCCESS;
}
struct SensorCfgData *HallCreateCfgData(const struct DeviceResourceNode *node)
{
struct HallDrvData *drvData = HallGetDrvData();
if (drvData == NULL || node == NULL) {
HDF_LOGE("%s: Hall node pointer NULL", __func__);
return NULL;
}
if (drvData->detectFlag) {
HDF_LOGE("%s: Hall sensor have detected", __func__);
return NULL;
}
if (drvData->hallCfg == NULL) {
HDF_LOGE("%s: Hall hallCfg pointer NULL", __func__);
return NULL;
}
if (GetSensorBaseConfigData(node, drvData->hallCfg) != HDF_SUCCESS) {
HDF_LOGE("%s: Get sensor base config failed", __func__);
goto BASE_CONFIG_EXIT;
}
if (SetHallGpioPin(drvData) != HDF_SUCCESS) {
HDF_LOGE("%s: set hall gpio pin failed", __func__);
goto BASE_CONFIG_EXIT;
}
if (DetectSensorDevice(drvData->hallCfg) != HDF_SUCCESS) {
HDF_LOGI("%s: Hall sensor detect device no exist", __func__);
drvData->detectFlag = false;
goto BASE_CONFIG_EXIT;
}
drvData->detectFlag = true;
if (InitHallAfterDetected(node, drvData) != HDF_SUCCESS) {
HDF_LOGE("%s: Hall sensor detect device no exist", __func__);
goto BASE_CONFIG_EXIT;
}
return drvData->hallCfg;
BASE_CONFIG_EXIT:
drvData->hallCfg->root = NULL;
(void)memset_s(&drvData->hallCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo));
(void)memset_s(&drvData->hallCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr));
return NULL;
}
void HallReleaseCfgData(struct SensorCfgData *hallCfg)
{
CHECK_NULL_PTR_RETURN(hallCfg);
(void)DeleteSensorDevice(&hallCfg->sensorInfo);
hallCfg->root = NULL;
(void)memset_s(&hallCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo));
(void)memset_s(&hallCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr));
}
int32_t HallInitDriver(struct HdfDeviceObject *device)
{
CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
struct HallDrvData *drvData = (struct HallDrvData *)device->service;
CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
if (InitHallData(drvData) != HDF_SUCCESS) {
HDF_LOGE("%s: Init hall config failed", __func__);
return HDF_FAILURE;
}
drvData->hallCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->hallCfg));
if (drvData->hallCfg == NULL) {
HDF_LOGE("%s: Malloc hall config data failed", __func__);
return HDF_FAILURE;
}
HDF_LOGI("%s: Init hall driver success", __func__);
return HDF_SUCCESS;
}
void HallReleaseDriver(struct HdfDeviceObject *device)
{
struct HallDrvData *drvData = NULL;
CHECK_NULL_PTR_RETURN(device);
drvData = (struct HallDrvData *)device->service;
CHECK_NULL_PTR_RETURN(drvData);
if (drvData->detectFlag) {
HallReleaseCfgData(drvData->hallCfg);
}
OsalMemFree(drvData->hallCfg);
drvData->hallCfg = NULL;
HdfWorkDestroy(&drvData->hallWork);
HdfWorkQueueDestroy(&drvData->hallWorkQueue);
OsalMemFree(drvData);
}
struct HdfDriverEntry g_sensorHallDevEntry = {
.moduleVersion = 1,
.moduleName = "HDF_SENSOR_HALL",
.Bind = HallBindDriver,
.Init = HallInitDriver,
.Release = HallReleaseDriver,
};
/*
* 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_hall_driver.h"
#include <securec.h>
#include "gpio_if.h"
#include "hall_ak8789.h"
#include "hdf_base.h"
#include "hdf_device_desc.h"
#include "osal_irq.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_hall_driver_c
#define HDF_HALL_WORK_QUEUE_NAME "hdf_hall_work_queue"
static struct HallDrvData *g_hallDrvData = NULL;
static struct HallDrvData *HallGetDrvData(void)
{
return g_hallDrvData;
}
int32_t HallRegisterChipOps(const struct HallOpsCall *ops)
{
struct HallDrvData *drvData = HallGetDrvData();
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 HallDataWorkEntry(void *arg)
{
struct HallDrvData *drvData = NULL;
drvData = (struct HallDrvData *)arg;
CHECK_NULL_PTR_RETURN(drvData);
if (drvData->ops.ReadData == NULL) {
HDF_LOGI("%s: Hall ReadData function NULL", __func__);
return;
}
if (drvData->ops.ReadData(drvData->hallCfg) != HDF_SUCCESS) {
HDF_LOGE("%s: Hall read data failed", __func__);
}
}
static int32_t HallNorthPolarityIrqFunc(uint16_t gpio, void *data)
{
(void)gpio;
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;
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(struct HallDrvData *drvData)
{
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;
}
drvData->interval = SENSOR_TIMER_MIN_TIME;
drvData->enable = false;
drvData->detectFlag = 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("Gpio set north irq failed: %d", ret);
}
ret = GpioEnableIrq(drvData->GpioIrq[HALL_NORTH_POLARITY_GPIO]);
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,
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 HallBindDriver(struct HdfDeviceObject *device)
{
CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
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 SensorCfgData *config, struct SensorDeviceInfo *deviceInfo)
{
CHECK_NULL_PTR_RETURN_VALUE(config, 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),
&config->sensorInfo, sizeof(config->sensorInfo)) != EOK) {
HDF_LOGE("%s: Copy sensor info failed", __func__);
return HDF_FAILURE;
}
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;
CHECK_NULL_PTR_RETURN_VALUE(node, HDF_ERR_INVALID_PARAM);
CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
if (InitHallOps(drvData->hallCfg, &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;
}
if (ParserHallPinConfigData(node, drvData) != HDF_SUCCESS) {
HDF_LOGE("%s: get hall pin 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 (ret != 0) {
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 (ret != 0) {
HDF_LOGE("%s:%d south south gpio dir failed", __func__, __LINE__);
return HDF_FAILURE;
}
}
return HDF_SUCCESS;
}
struct SensorCfgData *HallCreateCfgData(const struct DeviceResourceNode *node)
{
struct HallDrvData *drvData = HallGetDrvData();
if (drvData == NULL || node == NULL) {
HDF_LOGE("%s: Hall node pointer NULL", __func__);
return NULL;
}
if (drvData->detectFlag) {
HDF_LOGE("%s: Hall sensor have detected", __func__);
return NULL;
}
if (drvData->hallCfg == NULL) {
HDF_LOGE("%s: Hall hallCfg pointer NULL", __func__);
return NULL;
}
if (GetSensorBaseConfigData(node, drvData->hallCfg) != HDF_SUCCESS) {
HDF_LOGE("%s: Get sensor base config failed", __func__);
goto BASE_CONFIG_EXIT;
}
if (SetHallGpioPin(drvData) != HDF_SUCCESS) {
HDF_LOGE("%s: set hall gpio pin failed", __func__);
goto BASE_CONFIG_EXIT;
}
if (DetectSensorDevice(drvData->hallCfg) != HDF_SUCCESS) {
HDF_LOGI("%s: Hall sensor detect device no exist", __func__);
drvData->detectFlag = false;
goto BASE_CONFIG_EXIT;
}
drvData->detectFlag = true;
if (InitHallAfterDetected(node, drvData) != HDF_SUCCESS) {
HDF_LOGE("%s: Hall sensor detect device no exist", __func__);
goto BASE_CONFIG_EXIT;
}
return drvData->hallCfg;
BASE_CONFIG_EXIT:
drvData->hallCfg->root = NULL;
(void)memset_s(&drvData->hallCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo));
(void)memset_s(&drvData->hallCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr));
return NULL;
}
void HallReleaseCfgData(struct SensorCfgData *hallCfg)
{
CHECK_NULL_PTR_RETURN(hallCfg);
(void)DeleteSensorDevice(&hallCfg->sensorInfo);
hallCfg->root = NULL;
(void)memset_s(&hallCfg->sensorInfo, sizeof(struct SensorBasicInfo), 0, sizeof(struct SensorBasicInfo));
(void)memset_s(&hallCfg->sensorAttr, sizeof(struct SensorAttr), 0, sizeof(struct SensorAttr));
}
int32_t HallInitDriver(struct HdfDeviceObject *device)
{
CHECK_NULL_PTR_RETURN_VALUE(device, HDF_ERR_INVALID_PARAM);
struct HallDrvData *drvData = (struct HallDrvData *)device->service;
CHECK_NULL_PTR_RETURN_VALUE(drvData, HDF_ERR_INVALID_PARAM);
if (InitHallData(drvData) != HDF_SUCCESS) {
HDF_LOGE("%s: Init hall config failed", __func__);
return HDF_FAILURE;
}
drvData->hallCfg = (struct SensorCfgData *)OsalMemCalloc(sizeof(*drvData->hallCfg));
if (drvData->hallCfg == NULL) {
HDF_LOGE("%s: Malloc hall config data failed", __func__);
return HDF_FAILURE;
}
HDF_LOGI("%s: Init hall driver success", __func__);
return HDF_SUCCESS;
}
void HallReleaseDriver(struct HdfDeviceObject *device)
{
struct HallDrvData *drvData = NULL;
CHECK_NULL_PTR_RETURN(device);
drvData = (struct HallDrvData *)device->service;
CHECK_NULL_PTR_RETURN(drvData);
if (drvData->detectFlag) {
HallReleaseCfgData(drvData->hallCfg);
}
OsalMemFree(drvData->hallCfg);
drvData->hallCfg = NULL;
HdfWorkDestroy(&drvData->hallWork);
HdfWorkQueueDestroy(&drvData->hallWorkQueue);
OsalMemFree(drvData);
}
struct HdfDriverEntry g_sensorHallDevEntry = {
.moduleVersion = 1,
.moduleName = "HDF_SENSOR_HALL",
.Bind = HallBindDriver,
.Init = HallInitDriver,
.Release = HallReleaseDriver,
};
HDF_INIT(g_sensorHallDevEntry);
model/sensor/driver/hall/sensor_hall_driver.h
+46 -46
View File
@@ -1,46 +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_HALL_DRIVER_H
#define SENSOR_HALL_DRIVER_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);
};
struct HallDrvData {
struct IDeviceIoService ioService;
struct HdfDeviceObject *device;
HdfWorkQueue hallWorkQueue;
HdfWork hallWork;
bool detectFlag;
bool enable;
int64_t interval;
struct SensorCfgData *hallCfg;
struct HallOpsCall ops;
int32_t GpioIrq[HALL_POLARITY_GPIO_MAX];
};
int32_t HallRegisterChipOps(const struct HallOpsCall *ops);
struct SensorCfgData *HallCreateCfgData(const struct DeviceResourceNode *node);
void HallReleaseCfgData(struct SensorCfgData *sensorCfgData);
#endif /* SENSOR_HALL_DRIVER_H */
/*
* 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 "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);
};
struct HallDrvData {
struct IDeviceIoService ioService;
struct HdfDeviceObject *device;
HdfWorkQueue hallWorkQueue;
HdfWork hallWork;
bool detectFlag;
bool enable;
int64_t interval;
struct SensorCfgData *hallCfg;
struct HallOpsCall ops;
int32_t GpioIrq[HALL_POLARITY_GPIO_MAX];
};
int32_t HallRegisterChipOps(const struct HallOpsCall *ops);
struct SensorCfgData *HallCreateCfgData(const struct DeviceResourceNode *node);
void HallReleaseCfgData(struct SensorCfgData *sensorCfgData);
#endif /* SENSOR_HALL_DRIVER_H */