/* lsm6ds0.c - Driver for LSM6DS0 accelerometer, gyroscope and
 * temperature sensor
 */

/*
 * Copyright (c) 2016 Intel Corporation
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#define DT_DRV_COMPAT st_lsm6ds0

#include <zephyr/drivers/sensor.h>
#include <zephyr/kernel.h>
#include <zephyr/device.h>
#include <zephyr/init.h>
#include <zephyr/sys/byteorder.h>
#include <zephyr/sys/__assert.h>
#include <zephyr/logging/log.h>

#include "lsm6ds0.h"

LOG_MODULE_REGISTER(LSM6DS0, CONFIG_SENSOR_LOG_LEVEL);

static inline int lsm6ds0_reboot(const struct device *dev)
{
	const struct lsm6ds0_config *config = dev->config;

	if (i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG8,
				   LSM6DS0_MASK_CTRL_REG8_BOOT,
				   1 << LSM6DS0_SHIFT_CTRL_REG8_BOOT) < 0) {
		return -EIO;
	}

	k_busy_wait(USEC_PER_MSEC * 50U);

	return 0;
}

static inline int lsm6ds0_accel_axis_ctrl(const struct device *dev, int x_en,
					  int y_en, int z_en)
{
	const struct lsm6ds0_config *config = dev->config;
	uint8_t state = (x_en << LSM6DS0_SHIFT_CTRL_REG5_XL_XEN_XL) |
			(y_en << LSM6DS0_SHIFT_CTRL_REG5_XL_YEN_XL) |
			(z_en << LSM6DS0_SHIFT_CTRL_REG5_XL_ZEN_XL);

	return i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG5_XL,
				      LSM6DS0_MASK_CTRL_REG5_XL_XEN_XL |
				      LSM6DS0_MASK_CTRL_REG5_XL_YEN_XL |
				      LSM6DS0_MASK_CTRL_REG5_XL_ZEN_XL,
				      state);
}

static int lsm6ds0_accel_set_fs_raw(const struct device *dev, uint8_t fs)
{
	const struct lsm6ds0_config *config = dev->config;

	if (i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG6_XL,
				   LSM6DS0_MASK_CTRL_REG6_XL_FS_XL,
				   fs << LSM6DS0_SHIFT_CTRL_REG6_XL_FS_XL) < 0) {
		return -EIO;
	}

	return 0;
}

static int lsm6ds0_accel_set_odr_raw(const struct device *dev, uint8_t odr)
{
	const struct lsm6ds0_config *config = dev->config;

	if (i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG6_XL,
				   LSM6DS0_MASK_CTRL_REG6_XL_ODR_XL,
				   odr << LSM6DS0_SHIFT_CTRL_REG6_XL_ODR_XL) < 0) {
		return -EIO;
	}

	return 0;
}

static inline int lsm6ds0_gyro_axis_ctrl(const struct device *dev, int x_en,
					 int y_en,
					 int z_en)
{
	const struct lsm6ds0_config *config = dev->config;
	uint8_t state = (x_en << LSM6DS0_SHIFT_CTRL_REG4_XEN_G) |
			(y_en << LSM6DS0_SHIFT_CTRL_REG4_YEN_G) |
			(z_en << LSM6DS0_SHIFT_CTRL_REG4_ZEN_G);

	return i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG4,
				      LSM6DS0_MASK_CTRL_REG4_XEN_G |
				      LSM6DS0_MASK_CTRL_REG4_YEN_G |
				      LSM6DS0_MASK_CTRL_REG4_ZEN_G,
				      state);
}

static int lsm6ds0_gyro_set_fs_raw(const struct device *dev, uint8_t fs)
{
	const struct lsm6ds0_config *config = dev->config;

	if (i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG1_G,
				   LSM6DS0_MASK_CTRL_REG1_G_FS_G,
				   fs << LSM6DS0_SHIFT_CTRL_REG1_G_FS_G) < 0) {
		return -EIO;
	}

	return 0;
}

static int lsm6ds0_gyro_set_odr_raw(const struct device *dev, uint8_t odr)
{
	const struct lsm6ds0_config *config = dev->config;

	if (i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG1_G,
				   LSM6DS0_MASK_CTRL_REG1_G_ODR_G,
				   odr << LSM6DS0_SHIFT_CTRL_REG1_G_ODR_G) < 0) {
		return -EIO;
	}

	return 0;
}

static int lsm6ds0_sample_fetch_accel(const struct device *dev)
{
	struct lsm6ds0_data *data = dev->data;
	const struct lsm6ds0_config *config = dev->config;
	uint8_t buf[6];

	if (i2c_burst_read_dt(&config->i2c, LSM6DS0_REG_OUT_X_L_XL, buf, sizeof(buf)) < 0) {
		LOG_DBG("failed to read sample");
		return -EIO;
	}

#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_X_AXIS)
	data->accel_sample_x = (int16_t)((uint16_t)(buf[0]) |
				((uint16_t)(buf[1]) << 8));
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Y_AXIS)
	data->accel_sample_y = (int16_t)((uint16_t)(buf[2]) |
				((uint16_t)(buf[3]) << 8));
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Z_AXIS)
	data->accel_sample_z = (int16_t)((uint16_t)(buf[4]) |
				((uint16_t)(buf[5]) << 8));
#endif

	return 0;
}

static int lsm6ds0_sample_fetch_gyro(const struct device *dev)
{
	struct lsm6ds0_data *data = dev->data;
	const struct lsm6ds0_config *config = dev->config;
	uint8_t buf[6];

	if (i2c_burst_read_dt(&config->i2c, LSM6DS0_REG_OUT_X_L_G, buf, sizeof(buf)) < 0) {
		LOG_DBG("failed to read sample");
		return -EIO;
	}

#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_X_AXIS)
	data->gyro_sample_x = (int16_t)((uint16_t)(buf[0]) |
				((uint16_t)(buf[1]) << 8));
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Y_AXIS)
	data->gyro_sample_y = (int16_t)((uint16_t)(buf[2]) |
				((uint16_t)(buf[3]) << 8));
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Z_AXIS)
	data->gyro_sample_z = (int16_t)((uint16_t)(buf[4]) |
				((uint16_t)(buf[5]) << 8));
#endif

	return 0;
}

#if defined(CONFIG_LSM6DS0_ENABLE_TEMP)
static int lsm6ds0_sample_fetch_temp(const struct device *dev)
{
	struct lsm6ds0_data *data = dev->data;
	const struct lsm6ds0_config *config = dev->config;
	uint8_t buf[2];

	if (i2c_burst_read_dt(&config->i2c, LSM6DS0_REG_OUT_TEMP_L, buf, sizeof(buf)) < 0) {
		LOG_DBG("failed to read sample");
		return -EIO;
	}

	data->temp_sample = (int16_t)((uint16_t)(buf[0]) |
				((uint16_t)(buf[1]) << 8));

	return 0;
}
#endif

static int lsm6ds0_sample_fetch(const struct device *dev,
				enum sensor_channel chan)
{
	__ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL ||
			chan == SENSOR_CHAN_ACCEL_XYZ ||
#if defined(CONFIG_LSM6DS0_ENABLE_TEMP)
			chan == SENSOR_CHAN_DIE_TEMP ||
#endif
			chan == SENSOR_CHAN_GYRO_XYZ);

	switch (chan) {
	case SENSOR_CHAN_ACCEL_XYZ:
		lsm6ds0_sample_fetch_accel(dev);
		break;
	case SENSOR_CHAN_GYRO_XYZ:
		lsm6ds0_sample_fetch_gyro(dev);
		break;
#if defined(CONFIG_LSM6DS0_ENABLE_TEMP)
	case SENSOR_CHAN_DIE_TEMP:
		lsm6ds0_sample_fetch_temp(dev);
		break;
#endif
	case SENSOR_CHAN_ALL:
		lsm6ds0_sample_fetch_accel(dev);
		lsm6ds0_sample_fetch_gyro(dev);
#if defined(CONFIG_LSM6DS0_ENABLE_TEMP)
		lsm6ds0_sample_fetch_temp(dev);
#endif
		break;
	default:
		return -ENOTSUP;
	}

	return 0;
}

static inline void lsm6ds0_accel_convert(struct sensor_value *val, int raw_val,
					 float scale)
{
	double dval;

	dval = (double)(raw_val) * (double)scale / 32767.0;
	val->val1 = (int32_t)dval;
	val->val2 = ((int32_t)(dval * 1000000)) % 1000000;
}

static inline int lsm6ds0_accel_get_channel(enum sensor_channel chan,
					    struct sensor_value *val,
					    struct lsm6ds0_data *data,
					    float scale)
{
	switch (chan) {
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_X_AXIS)
	case SENSOR_CHAN_ACCEL_X:
		lsm6ds0_accel_convert(val, data->accel_sample_x, scale);
		break;
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Y_AXIS)
	case SENSOR_CHAN_ACCEL_Y:
		lsm6ds0_accel_convert(val, data->accel_sample_y, scale);
		break;
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Z_AXIS)
	case SENSOR_CHAN_ACCEL_Z:
		lsm6ds0_accel_convert(val, data->accel_sample_z, scale);
		break;
#endif
	case SENSOR_CHAN_ACCEL_XYZ:
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_X_AXIS)
		lsm6ds0_accel_convert(val, data->accel_sample_x, scale);
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Y_AXIS)
		lsm6ds0_accel_convert(val + 1, data->accel_sample_y, scale);
#endif
#if defined(CONFIG_LSM6DS0_ACCEL_ENABLE_Z_AXIS)
		lsm6ds0_accel_convert(val + 2, data->accel_sample_z, scale);
#endif
		break;
	default:
		return -ENOTSUP;
	}

	return 0;
}

static int lsm6ds0_accel_channel_get(enum sensor_channel chan,
				     struct sensor_value *val,
				     struct lsm6ds0_data *data)
{
	return lsm6ds0_accel_get_channel(chan, val, data,
					LSM6DS0_DEFAULT_ACCEL_FULLSCALE_FACTOR);
}

static inline void lsm6ds0_gyro_convert(struct sensor_value *val, int raw_val,
					float numerator)
{
	double dval;

	dval = (double)(raw_val) * (double)numerator / 1000.0 * SENSOR_DEG2RAD_DOUBLE;
	val->val1 = (int32_t)dval;
	val->val2 = ((int32_t)(dval * 1000000)) % 1000000;
}

static inline int lsm6ds0_gyro_get_channel(enum sensor_channel chan,
					   struct sensor_value *val,
					   struct lsm6ds0_data *data,
					   float numerator)
{
	switch (chan) {
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_X_AXIS)
	case SENSOR_CHAN_GYRO_X:
		lsm6ds0_gyro_convert(val, data->gyro_sample_x, numerator);
		break;
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Y_AXIS)
	case SENSOR_CHAN_GYRO_Y:
		lsm6ds0_gyro_convert(val, data->gyro_sample_y, numerator);
		break;
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Z_AXIS)
	case SENSOR_CHAN_GYRO_Z:
		lsm6ds0_gyro_convert(val, data->gyro_sample_z, numerator);
		break;
#endif
	case SENSOR_CHAN_GYRO_XYZ:
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_X_AXIS)
		lsm6ds0_gyro_convert(val, data->gyro_sample_x, numerator);
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Y_AXIS)
		lsm6ds0_gyro_convert(val + 1, data->gyro_sample_y, numerator);
#endif
#if defined(CONFIG_LSM6DS0_GYRO_ENABLE_Z_AXIS)
		lsm6ds0_gyro_convert(val + 2, data->gyro_sample_z, numerator);
#endif
		break;
	default:
		return -ENOTSUP;
	}

	return 0;
}

static int lsm6ds0_gyro_channel_get(enum sensor_channel chan,
				    struct sensor_value *val,
				    struct lsm6ds0_data *data)
{
	return lsm6ds0_gyro_get_channel(chan, val, data,
					LSM6DS0_DEFAULT_GYRO_FULLSCALE_FACTOR);
}

#if defined(CONFIG_LSM6DS0_ENABLE_TEMP)
static void lsm6ds0_gyro_channel_get_temp(struct sensor_value *val,
					  struct lsm6ds0_data *data)
{
	/* val = temp_sample / 16 + 25 */
	val->val1 = data->temp_sample / 16 + 25;
	val->val2 = (data->temp_sample % 16) * (1000000 / 16);
}
#endif

static int lsm6ds0_channel_get(const struct device *dev,
			       enum sensor_channel chan,
			       struct sensor_value *val)
{
	struct lsm6ds0_data *data = dev->data;

	switch (chan) {
	case SENSOR_CHAN_ACCEL_X:
	case SENSOR_CHAN_ACCEL_Y:
	case SENSOR_CHAN_ACCEL_Z:
	case SENSOR_CHAN_ACCEL_XYZ:
		lsm6ds0_accel_channel_get(chan, val, data);
		break;
	case SENSOR_CHAN_GYRO_X:
	case SENSOR_CHAN_GYRO_Y:
	case SENSOR_CHAN_GYRO_Z:
	case SENSOR_CHAN_GYRO_XYZ:
		lsm6ds0_gyro_channel_get(chan, val, data);
		break;
#if defined(CONFIG_LSM6DS0_ENABLE_TEMP)
	case SENSOR_CHAN_DIE_TEMP:
		lsm6ds0_gyro_channel_get_temp(val, data);
		break;
#endif
	default:
		return -ENOTSUP;
	}

	return 0;
}

static DEVICE_API(sensor, lsm6ds0_api_funcs) = {
	.sample_fetch = lsm6ds0_sample_fetch,
	.channel_get = lsm6ds0_channel_get,
};

static int lsm6ds0_init_chip(const struct device *dev)
{
	const struct lsm6ds0_config *config = dev->config;
	uint8_t chip_id;

	if (lsm6ds0_reboot(dev) < 0) {
		LOG_DBG("failed to reboot device");
		return -EIO;
	}

	if (i2c_reg_read_byte_dt(&config->i2c, LSM6DS0_REG_WHO_AM_I, &chip_id) < 0) {
		LOG_DBG("failed reading chip id");
		return -EIO;
	}
	if (chip_id != LSM6DS0_VAL_WHO_AM_I) {
		LOG_DBG("invalid chip id 0x%x", chip_id);
		return -EIO;
	}
	LOG_DBG("chip id 0x%x", chip_id);

	if (lsm6ds0_accel_axis_ctrl(dev, LSM6DS0_ACCEL_ENABLE_X_AXIS,
				    LSM6DS0_ACCEL_ENABLE_Y_AXIS,
				    LSM6DS0_ACCEL_ENABLE_Z_AXIS) < 0) {
		LOG_DBG("failed to set accelerometer axis");
		return -EIO;
	}

	if (lsm6ds0_accel_set_fs_raw(dev, LSM6DS0_DEFAULT_ACCEL_FULLSCALE)
				     < 0) {
		LOG_DBG("failed to set accelerometer full-scale");
		return -EIO;
	}

	if (lsm6ds0_accel_set_odr_raw(dev, LSM6DS0_DEFAULT_ACCEL_SAMPLING_RATE)
				      < 0) {
		LOG_DBG("failed to set accelerometer sampling rate");
		return -EIO;
	}

	if (lsm6ds0_gyro_axis_ctrl(dev, LSM6DS0_GYRO_ENABLE_X_AXIS,
				   LSM6DS0_GYRO_ENABLE_Y_AXIS,
				   LSM6DS0_GYRO_ENABLE_Z_AXIS) < 0) {
		LOG_DBG("failed to set gyroscope axis");
		return -EIO;
	}

	if (lsm6ds0_gyro_set_fs_raw(dev, LSM6DS0_DEFAULT_GYRO_FULLSCALE)
				    < 0) {
		LOG_DBG("failed to set gyroscope full-scale");
		return -EIO;
	}

	if (lsm6ds0_gyro_set_odr_raw(dev, LSM6DS0_DEFAULT_GYRO_SAMPLING_RATE)
				     < 0) {
		LOG_DBG("failed to set gyroscope sampling rate");
		return -EIO;
	}

	if (i2c_reg_update_byte_dt(&config->i2c, LSM6DS0_REG_CTRL_REG8,
				   LSM6DS0_MASK_CTRL_REG8_BDU |
				   LSM6DS0_MASK_CTRL_REG8_BLE |
				   LSM6DS0_MASK_CTRL_REG8_IF_ADD_INC,
				   (1 << LSM6DS0_SHIFT_CTRL_REG8_BDU) |
				   (0 << LSM6DS0_SHIFT_CTRL_REG8_BLE) |
				   (1 << LSM6DS0_SHIFT_CTRL_REG8_IF_ADD_INC))
				   < 0) {
		LOG_DBG("failed to set BDU, BLE and burst");
		return -EIO;
	}

	return 0;
}

static int lsm6ds0_init(const struct device *dev)
{
	const struct lsm6ds0_config * const config = dev->config;

	if (!device_is_ready(config->i2c.bus)) {
		LOG_ERR("I2C bus device not ready");
		return -ENODEV;
	}

	if (lsm6ds0_init_chip(dev) < 0) {
		LOG_DBG("failed to initialize chip");
		return -EIO;
	}

	return 0;
}

#define LSM6DS0_DEFINE(inst)								\
	static struct lsm6ds0_data lsm6ds0_data_##inst;					\
											\
	static const struct lsm6ds0_config lsm6ds0_config_##inst = {			\
		.i2c = I2C_DT_SPEC_INST_GET(inst),					\
	};										\
											\
	SENSOR_DEVICE_DT_INST_DEFINE(inst, lsm6ds0_init, NULL,				\
			      &lsm6ds0_data_##inst, &lsm6ds0_config_##inst, POST_KERNEL,\
			      CONFIG_SENSOR_INIT_PRIORITY, &lsm6ds0_api_funcs);		\

DT_INST_FOREACH_STATUS_OKAY(LSM6DS0_DEFINE)