diff --git a/model/sensor/driver/als/sensor_als_driver.c b/model/sensor/driver/als/sensor_als_driver.c index e2b1c3f958007ecd737addd9b57b7cb96574397c..4459bfa87d5e857baf27d72680cd6b074a4e8534 100755 --- a/model/sensor/driver/als/sensor_als_driver.c +++ b/model/sensor/driver/als/sensor_als_driver.c @@ -27,6 +27,139 @@ static struct AlsDrvData *AlsGetDrvData(void) } 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) +{ + int 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) +{ + int 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) +{ + int 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) +{ + int 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 uint32_t GetExtendedAlsRegGroupNameIndex(const char *name) +{ + uint32_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) { @@ -247,12 +380,22 @@ static int32_t InitAlsAfterDetected(struct SensorCfgData *config) if (ParseSensorRegConfig(config) != HDF_SUCCESS) { HDF_LOGE("%s: Parse sensor register failed", __func__); - (void)DeleteSensorDevice(&config->sensorInfo); - ReleaseSensorAllRegConfig(config); - return HDF_FAILURE; + 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) @@ -309,6 +452,7 @@ void AlsReleaseCfgData(struct SensorCfgData *alsCfg) (void)DeleteSensorDevice(&alsCfg->sensorInfo); ReleaseSensorAllRegConfig(alsCfg); + ReleaseExtendedAlsRegConfig(alsCfg); (void)ReleaseSensorBusHandle(&alsCfg->busCfg); alsCfg->root = NULL; @@ -335,6 +479,7 @@ int32_t AlsInitDriver(struct HdfDeviceObject *device) } drvData->alsCfg->regCfgGroup = &g_regCfgGroup[0]; + drvData->alsCfg->extendedRegCfgGroup = &g_extendAlsRegCfgGroup[0]; return HDF_SUCCESS; } diff --git a/model/sensor/driver/als/sensor_als_driver.h b/model/sensor/driver/als/sensor_als_driver.h index 3ca5d7d37163ca676978c545991184dca8edf9f1..6f02f9f1536814078a2b1ecae2fdf96a40398c87 100755 --- a/model/sensor/driver/als/sensor_als_driver.h +++ b/model/sensor/driver/als/sensor_als_driver.h @@ -17,6 +17,12 @@ #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, @@ -37,6 +43,22 @@ enum AlsLightPart { 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; @@ -65,5 +87,8 @@ struct AlsDrvData { 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/chipset/als/als_bh1745.c b/model/sensor/driver/chipset/als/als_bh1745.c index 2832402e4f8835773ab8192161b717d25007f4f3..12b8967fe3cc58b7ec98b8c5c5fec8f2b0de7fc2 100755 --- a/model/sensor/driver/chipset/als/als_bh1745.c +++ b/model/sensor/driver/chipset/als/als_bh1745.c @@ -14,17 +14,131 @@ #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; } -/* 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 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; + + 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 timeTemp; + uint32_t gainTemp; + uint8_t timeRegValue; + uint8_t gainRegvalue; + uint32_t index = 1; + uint32_t luxTemp; + uint8_t timeItemNum; + uint8_t gainItemNum; + struct SensorRegCfgGroupNode *timeGroupNode = NULL; + struct SensorRegCfgGroupNode *gainGroupNode = 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]; + timeGroupNode = CfgData->extendedRegCfgGroup[EXTENDED_ALS_TIME_GROUP]; + timeItemNum = timeGroupNode->itemNum; + gainGroupNode = CfgData->extendedRegCfgGroup[EXTENDED_ALS_GAIN_GROUP]; + gainItemNum = gainGroupNode->itemNum; + + ReadSensorRegCfgArray(&CfgData->busCfg, timeGroupNode, timeIndex, &timeRegValue, sizeof(uint8_t)); + timeRegValue &= timeGroupNode->regCfgItem->mask; + timeTemp = GetTimeByRegValue(timeRegValue, g_timeMap, timeItemNum); + + ReadSensorRegCfgArray(&CfgData->busCfg, gainGroupNode, gainIndex, &gainRegvalue, sizeof(uint8_t)); + gainRegvalue &= gainGroupNode->regCfgItem->mask; + gainTemp = GetGainByRegValue(gainRegvalue, g_gainMap, gainItemNum); + + return (((luxTemp * BH1745_TIME_160MSEC * BH1745_GAIN_16X) / gainTemp) / timeTemp); +} + + static int32_t RawDataConvert(struct SensorCfgData *CfgData, struct AlsReportData *reportData, uint32_t* rgbcData) + { + reportData->als = (uint32_t)CalLux(CfgData, rgbcData); + reportData->als = (reportData->als > 0) ? reportData->als : 0; + DynamicRangCovert(CfgData, rgbcData); + return HDF_SUCCESS; + } static int32_t ReadBh1745RawData(struct SensorCfgData *data, struct AlsData *rawData, int64_t *timestamp) { @@ -73,13 +187,13 @@ static int32_t ReadBh1745RawData(struct SensorCfgData *data, struct AlsData *raw 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 = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[ALS_R_MSB], SENSOR_DATA_WIDTH_8_BIT) | + rawData->red = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[ALS_R_MSB], SENSOR_DATA_WIDTH_8_BIT) | reg[ALS_R_LSB]); - rawData->green = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[ALS_G_MSB], SENSOR_DATA_WIDTH_8_BIT) | + rawData->green = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[ALS_G_MSB], SENSOR_DATA_WIDTH_8_BIT) | reg[ALS_G_LSB]); - rawData->blue = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[ALS_B_MSB], SENSOR_DATA_WIDTH_8_BIT) | + rawData->blue = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[ALS_B_MSB], SENSOR_DATA_WIDTH_8_BIT) | reg[ALS_B_LSB]); - rawData->clear = (int16_t)(SENSOR_DATA_SHIFT_LEFT(reg[ALS_C_MSB], SENSOR_DATA_WIDTH_8_BIT) | + rawData->clear = (uint16_t)(SENSOR_DATA_SHIFT_LEFT(reg[ALS_C_MSB], SENSOR_DATA_WIDTH_8_BIT) | reg[ALS_C_LSB]); return HDF_SUCCESS; @@ -89,8 +203,9 @@ int32_t ReadBh1745Data(struct SensorCfgData *data) { int32_t ret; struct AlsData rawData = { 0, 0, 0, 0 }; - int32_t tmp[ALS_LIGHT_NUM]; + 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); @@ -108,8 +223,9 @@ int32_t ReadBh1745Data(struct SensorCfgData *data) tmp[ALS_B] = rawData.blue; tmp[ALS_C] = rawData.clear; - event.dataLen = sizeof(tmp); - event.data = (uint8_t *)&tmp; + RawDataConvert(data, &reportData, tmp); + 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__); diff --git a/model/sensor/driver/chipset/als/als_bh1745.h b/model/sensor/driver/chipset/als/als_bh1745.h index 41ac6de46ca74b1285e64e1035e6db9bdcaf1722..a6040d4ee44d99de6c78ad664bdbbb05aaac60f4 100755 --- a/model/sensor/driver/chipset/als/als_bh1745.h +++ b/model/sensor/driver/chipset/als/als_bh1745.h @@ -26,6 +26,63 @@ /* 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); diff --git a/model/sensor/driver/common/include/sensor_config_controller.h b/model/sensor/driver/common/include/sensor_config_controller.h index 9c3bc36aefe935a307995b40dba2965b5a361d0a..00f0ff4db61481f8054e1c64440216a1fbac1688 100644 --- a/model/sensor/driver/common/include/sensor_config_controller.h +++ b/model/sensor/driver/common/include/sensor_config_controller.h @@ -39,5 +39,8 @@ struct SensorOpsCall { int32_t SetSensorRegCfgArray(struct SensorBusCfg *busCfg, const struct SensorRegCfgGroupNode *group); 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 cb3af1bfcba3dc409f453a9af26c6e857598cafc..43562189b7072e2b37fe296f55f6b759d3ab0376 100644 --- a/model/sensor/driver/common/include/sensor_config_parser.h +++ b/model/sensor/driver/common/include/sensor_config_parser.h @@ -94,6 +94,7 @@ struct SensorCfgData { struct SensorBasicInfo sensorInfo; struct SensorAttr sensorAttr; struct SensorRegCfgGroupNode **regCfgGroup; + struct SensorRegCfgGroupNode **extendedRegCfgGroup; const struct DeviceResourceNode *root; struct SensorDirection *direction; }; @@ -104,6 +105,8 @@ 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 ParseSensorRegGroup(struct DeviceResourceIface *parser, const struct DeviceResourceNode *regCfgNode, + const char *groupName, struct SensorRegCfgGroupNode **groupNode); int32_t SensorRawDataToRemapData(struct SensorDirection *direction, int32_t *remapData, uint32_t num); void ReleaseSensorDirectionConfig(struct SensorCfgData *config); int32_t ParseSensorDirection(struct SensorCfgData *config); diff --git a/model/sensor/driver/common/src/sensor_config_controller.c b/model/sensor/driver/common/src/sensor_config_controller.c index 24e09ac9273dc7c6e61c77d2c294bc09bb423dd0..4777317674162afe2cc2c4f2db30baf3273f164a 100644 --- a/model/sensor/driver/common/src/sensor_config_controller.c +++ b/model/sensor/driver/common/src/sensor_config_controller.c @@ -285,5 +285,48 @@ int32_t SetSensorRegCfgArrayByBuff(struct SensorBusCfg *busCfg, const struct Sen 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 051aba20df632f53bc05492f18a6a34f225a3872..a5c52e0bdd58e6bf1cd8dd2e72ae6f04c496247f 100644 --- a/model/sensor/driver/common/src/sensor_config_parser.c +++ b/model/sensor/driver/common/src/sensor_config_parser.c @@ -107,7 +107,7 @@ 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;