drivers/sensor/wsen_hids/wsen_hids.c

/*
 * Copyright (c) 2022 Würth Elektronik eiSos GmbH & Co. KG
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#define DT_DRV_COMPAT we_wsen_hids

#include <string.h>

#include <zephyr/sys/__assert.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/logging/log.h>

#include "wsen_hids.h"

LOG_MODULE_REGISTER(WSEN_HIDS, CONFIG_SENSOR_LOG_LEVEL);

/*
 * List of supported output data rates (sensor_value struct, input to
 * sensor_attr_set()). Index into this list is used as argument for
 * HIDS_setOutputDataRate().
 */
static const struct sensor_value hids_odr_list[] = {
	{.val1 = 0, .val2 = 0},
	{.val1 = 1, .val2 = 0},
	{.val1 = 7, .val2 = 0},
	{.val1 = 12, .val2 = 5 * 100000},
};

static int hids_sample_fetch(const struct device *dev, enum sensor_channel channel)
{
	struct hids_data *data = dev->data;
	int16_t raw_humidity;
	int16_t raw_temp;

	__ASSERT_NO_MSG(channel == SENSOR_CHAN_ALL);

	if (HIDS_getRawValues(&data->sensor_interface, &raw_humidity, &raw_temp) != WE_SUCCESS) {
		LOG_ERR("Failed to %s sample.", "fetch data");
		return -EIO;
	}

	if (HIDS_convertHumidity_uint16(&data->sensor_interface, raw_humidity, &data->humidity) !=
	    WE_SUCCESS) {
		LOG_ERR("Failed to %s sample.", "convert humidity");
		return -EIO;
	}

	if (HIDS_convertTemperature_int16(&data->sensor_interface, raw_temp, &data->temperature) !=
	    WE_SUCCESS) {
		LOG_ERR("Failed to %s sample.", "convert temperature");
		return -EIO;
	}

	return 0;
}

static int hids_channel_get(const struct device *dev, enum sensor_channel channel,
			    struct sensor_value *value)
{
	struct hids_data *data = dev->data;
	int32_t value_converted;

	if (channel == SENSOR_CHAN_AMBIENT_TEMP) {
		value_converted = (int32_t)data->temperature;

		/* Convert temperature from 0.01 degrees Celsius to degrees Celsius */
		value->val1 = value_converted / 100;
		value->val2 = (value_converted % 100) * (1000000 / 100);
	} else if (channel == SENSOR_CHAN_HUMIDITY) {
		value_converted = (int32_t)data->humidity;

		/* Convert humidity from 0.01 percent to percent */
		value->val1 = value_converted / 100;
		value->val2 = (value_converted % 100) * (1000000 / 100);
	} else {
		return -ENOTSUP;
	}

	return 0;
}

/* Set output data rate. See hids_odr_list for allowed values. */
static int hids_odr_set(const struct device *dev, const struct sensor_value *odr)
{
	struct hids_data *data = dev->data;
	int odr_index;

	for (odr_index = 0; odr_index < ARRAY_SIZE(hids_odr_list); odr_index++) {
		if (odr->val1 == hids_odr_list[odr_index].val1 &&
		    odr->val2 == hids_odr_list[odr_index].val2) {
			break;
		}
	}

	if (odr_index == ARRAY_SIZE(hids_odr_list)) {
		/* ODR not allowed (was not found in hids_odr_list) */
		LOG_ERR("Bad sampling frequency %d.%d", odr->val1, odr->val2);
		return -EINVAL;
	}

	if (HIDS_setOutputDataRate(&data->sensor_interface, (HIDS_outputDataRate_t)odr_index) !=
	    WE_SUCCESS) {
		LOG_ERR("Failed to set output data rate");
		return -EIO;
	}

	return 0;
}

static int hids_attr_set(const struct device *dev, enum sensor_channel chan,
			 enum sensor_attribute attr, const struct sensor_value *val)
{
	if (chan != SENSOR_CHAN_ALL) {
		LOG_WRN("attr_set() is not supported on channel %d.", chan);
		return -ENOTSUP;
	}

	if (attr == SENSOR_ATTR_SAMPLING_FREQUENCY) {
		return hids_odr_set(dev, val);
	} else {
		return -ENOTSUP;
	}
}

static const struct sensor_driver_api hids_driver_api = {
	.attr_set = hids_attr_set,
#if CONFIG_WSEN_HIDS_TRIGGER
	.trigger_set = hids_trigger_set,
#endif
	.sample_fetch = hids_sample_fetch,
	.channel_get = hids_channel_get,
};

static int hids_init(const struct device *dev)
{
	const struct hids_config *config = dev->config;
	struct hids_data *data = dev->data;
	uint8_t device_id;

	/* Initialize WE sensor interface */
	WE_sensorInterfaceType_t interface_type = data->sensor_interface.interfaceType;

	HIDS_getDefaultInterface(&data->sensor_interface);
	data->sensor_interface.interfaceType = interface_type;

	switch (data->sensor_interface.interfaceType) {
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
	case WE_i2c:
		data->sensor_interface.handle = (void *)&config->bus_cfg.i2c;
		break;
#endif
#if DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
	case WE_spi:
		data->sensor_interface.handle = (void *)&config->bus_cfg.spi;
		break;
#endif
	default:
		LOG_ERR("Invalid interface type");
		return -EINVAL;
	}

	/* First communication test - check device ID */
	if (HIDS_getDeviceID(&data->sensor_interface, &device_id) != WE_SUCCESS) {
		LOG_ERR("Failed to read device ID.");
		return -EIO;
	}

	if (device_id != HIDS_DEVICE_ID_VALUE) {
		LOG_ERR("Invalid device ID 0x%x.", device_id);
		return -EINVAL;
	}

	if (HIDS_setOutputDataRate(&data->sensor_interface, config->odr) != WE_SUCCESS) {
		LOG_ERR("Failed to set output data rate.");
		return -EIO;
	}

	if (HIDS_enableBlockDataUpdate(&data->sensor_interface, HIDS_enable) != WE_SUCCESS) {
		LOG_ERR("Failed to enable block data update.");
		return -EIO;
	}

	if (HIDS_setPowerMode(&data->sensor_interface, HIDS_activeMode) != WE_SUCCESS) {
		LOG_ERR("Failed to set power mode.");
		return -EIO;
	}

	if (HIDS_readCalibrationData(&data->sensor_interface) != WE_SUCCESS) {
		LOG_ERR("Failed to read calibration data.");
		return -EIO;
	}

#if CONFIG_WSEN_HIDS_TRIGGER
	int status = hids_init_interrupt(dev);

	if (status < 0) {
		LOG_ERR("Failed to initialize data-ready interrupt.");
		return status;
	}
#endif

	return 0;
}

#if DT_NUM_INST_STATUS_OKAY(DT_DRV_COMPAT) == 0
#warning "HIDS driver enabled without any devices"
#endif

/*
 * Device creation macros
 */

#define HIDS_DEVICE_INIT(inst)                                                         \
	SENSOR_DEVICE_DT_INST_DEFINE(inst,                                             \
			      hids_init,                                               \
			      NULL,                                                    \
			      &hids_data_##inst,                                       \
			      &hids_config_##inst,                                     \
			      POST_KERNEL,                                             \
			      CONFIG_SENSOR_INIT_PRIORITY,                             \
			      &hids_driver_api);

#ifdef CONFIG_WSEN_HIDS_TRIGGER
#define HIDS_CFG_IRQ(inst) .gpio_drdy = GPIO_DT_SPEC_INST_GET(inst, drdy_gpios)
#else
#define HIDS_CFG_IRQ(inst)
#endif /* CONFIG_WSEN_HIDS_TRIGGER */

#define HIDS_CONFIG_COMMON(inst)                                                       \
	.odr = (HIDS_outputDataRate_t)(DT_INST_ENUM_IDX(inst, odr) + 1),               \
	COND_CODE_1(DT_INST_NODE_HAS_PROP(inst, drdy_gpios),                           \
			(HIDS_CFG_IRQ(inst)), ())

/*
 * Instantiation macros used when device is on SPI bus.
 */

#define HIDS_SPI_OPERATION (SPI_WORD_SET(8) | SPI_OP_MODE_MASTER | SPI_MODE_CPOL | SPI_MODE_CPHA)

#define HIDS_CONFIG_SPI(inst)                                                          \
	{                                                                              \
		.bus_cfg = {                                                           \
			.spi = SPI_DT_SPEC_INST_GET(inst,                              \
							HIDS_SPI_OPERATION,            \
							0),                            \
		},                                                                     \
		HIDS_CONFIG_COMMON(inst)                                               \
	}

/*
 * Instantiation macros used when device is on I2C bus.
 */

#define HIDS_CONFIG_I2C(inst)                                                          \
	{                                                                              \
		.bus_cfg = {                                                           \
			.i2c = I2C_DT_SPEC_INST_GET(inst),                             \
		},                                                                     \
		HIDS_CONFIG_COMMON(inst)                                               \
	}

/*
 * Main instantiation macro. Use of COND_CODE_1() selects the right
 * bus-specific macro at preprocessor time.
 */
#define HIDS_DEFINE(inst)                                                              \
	static struct hids_data hids_data_##inst =                                     \
		COND_CODE_1(DT_INST_ON_BUS(inst, i2c),                                 \
			    ({ .sensor_interface = { .interfaceType = WE_i2c } }), ()) \
		COND_CODE_1(DT_INST_ON_BUS(inst, spi),                                 \
			    ({ .sensor_interface = { .interfaceType = WE_spi } }), ());\
	static const struct hids_config hids_config_##inst =                           \
		COND_CODE_1(DT_INST_ON_BUS(inst, i2c), (HIDS_CONFIG_I2C(inst)), ())      \
		COND_CODE_1(DT_INST_ON_BUS(inst, spi), (HIDS_CONFIG_SPI(inst)), ());     \
	HIDS_DEVICE_INIT(inst)

DT_INST_FOREACH_STATUS_OKAY(HIDS_DEFINE)