drivers/sensor/tmag5170/tmag5170.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2023 Michal Morsisko
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #define DT_DRV_COMPAT ti_tmag5170

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

 #if defined(CONFIG_TMAG5170_CRC)
 #include <zephyr/sys/crc.h>
 #endif

 #include "tmag5170.h"

 #define TMAG5170_REG_DEVICE_CONFIG	0x0U
 #define TMAG5170_REG_SENSOR_CONFIG	0x1U
 #define TMAG5170_REG_SYSTEM_CONFIG	0x2U
 #define TMAG5170_REG_ALERT_CONFIG	0x3U
 #define TMAG5170_REG_X_THRX_CONFIG	0x4U
 #define TMAG5170_REG_Y_THRX_CONFIG	0x5U
 #define TMAG5170_REG_Z_THRX_CONFIG	0x6U
 #define TMAG5170_REG_T_THRX_CONFIG	0x7U
 #define TMAG5170_REG_CONV_STATUS	0x8U
 #define TMAG5170_REG_X_CH_RESULT	0x9U
 #define TMAG5170_REG_Y_CH_RESULT	0xAU
 #define TMAG5170_REG_Z_CH_RESULT	0xBU
 #define TMAG5170_REG_TEMP_RESULT	0xCU
 #define TMAG5170_REG_AFE_STATUS		0xDU
 #define TMAG5170_REG_SYS_STATUS		0xEU
 #define TMAG5170_REG_TEST_CONFIG	0xFU
 #define TMAG5170_REG_OSC_MONITOR	0x10U
 #define TMAG5170_REG_MAG_GAIN_CONFIG	0x11U
 #define TMAG5170_REG_MAG_OFFSET_CONFIG	0x12U
 #define TMAG5170_REG_ANGLE_RESULT	0x13U
 #define TMAG5170_REG_MAGNITUDE_RESULT	0x14U

 #define TMAG5170_CONV_AVG_POS		12U
 #define TMAG5170_CONV_AVG_MASK		(BIT_MASK(3U) << TMAG5170_CONV_AVG_POS)
 #define TMAG5170_CONV_AVG_SET(value)	(((value) << TMAG5170_CONV_AVG_POS) &\
 					TMAG5170_CONV_AVG_MASK)

 #define TMAG5170_MAG_TEMPCO_POS		8U
 #define TMAG5170_MAG_TEMPCO_MASK	(BIT_MASK(2U) << TMAG5170_MAG_TEMPCO_POS)
 #define TMAG5170_MAG_TEMPCO_SET(value)	(((value) << TMAG5170_MAG_TEMPCO_POS) &\
 					TMAG5170_MAG_TEMPCO_MASK)

 #define TMAG5170_OPERATING_MODE_POS		4U
 #define TMAG5170_OPERATING_MODE_MASK		(BIT_MASK(3U) << TMAG5170_OPERATING_MODE_POS)
 #define TMAG5170_OPERATING_MODE_SET(value)	(((value) << TMAG5170_OPERATING_MODE_POS) &\
 						TMAG5170_OPERATING_MODE_MASK)

 #define TMAG5170_T_CH_EN_POS		3U
 #define TMAG5170_T_CH_EN_MASK		(BIT_MASK(1U) << TMAG5170_T_CH_EN_POS)
 #define TMAG5170_T_CH_EN_SET(value)	(((value) << TMAG5170_T_CH_EN_POS) &\
 					TMAG5170_T_CH_EN_MASK)

 #define TMAG5170_T_RATE_POS		2U
 #define TMAG5170_T_RATE_MASK		(BIT_MASK(1U) << TMAG5170_T_RATE_POS)
 #define TMAG5170_T_RATE_SET(value)	(((value) << TMAG5170_T_RATE_POS) &\
 					TMAG5170_T_RATE_MASK)

 #define TMAG5170_ANGLE_EN_POS		14U
 #define TMAG5170_ANGLE_EN_MASK		(BIT_MASK(2U) << TMAG5170_ANGLE_EN_POS)
 #define TMAG5170_ANGLE_EN_SET(value)	(((value) << TMAG5170_ANGLE_EN_POS) &\
 					TMAG5170_ANGLE_EN_MASK)

 #define TMAG5170_SLEEPTIME_POS	10U
 #define TMAG5170_SLEEPTIME_MASK		(BIT_MASK(4U) << TMAG5170_SLEEPTIME_POS)
 #define TMAG5170_SLEEPTIME_SET(value)	(((value) << TMAG5170_SLEEPTIME_POS) &\
 					TMAG5170_SLEEPTIME_MASK)

 #define TMAG5170_MAG_CH_EN_POS	6U
 #define TMAG5170_MAG_CH_EN_MASK		(BIT_MASK(4U) << TMAG5170_MAG_CH_EN_POS)
 #define TMAG5170_MAG_CH_EN_SET(value)	(((value) << TMAG5170_MAG_CH_EN_POS) &\
 					TMAG5170_MAG_CH_EN_MASK)

 #define TMAG5170_Z_RANGE_POS		4U
 #define TMAG5170_Z_RANGE_MASK		(BIT_MASK(2U) << TMAG5170_Z_RANGE_POS)
 #define TMAG5170_Z_RANGE_SET(value)	(((value) << TMAG5170_Z_RANGE_POS) &\
 					TMAG5170_Z_RANGE_MASK)

 #define TMAG5170_Y_RANGE_POS		2U
 #define TMAG5170_Y_RANGE_MASK		(BIT_MASK(2U) << TMAG5170_Y_RANGE_POS)
 #define TMAG5170_Y_RANGE_SET(value)	(((value) << TMAG5170_Y_RANGE_POS) &\
 					TMAG5170_Y_RANGE_MASK)

 #define TMAG5170_X_RANGE_POS		0U
 #define TMAG5170_X_RANGE_MASK		(BIT_MASK(2U) << TMAG5170_X_RANGE_POS)
 #define TMAG5170_X_RANGE_SET(value)	(((value) << TMAG5170_X_RANGE_POS) &\
 					TMAG5170_X_RANGE_MASK)

 #define TMAG5170_RSLT_ALRT_POS		8U
 #define TMAG5170_RSLT_ALRT_MASK		(BIT_MASK(1U) << TMAG5170_RSLT_ALRT_POS)
 #define TMAG5170_RSLT_ALRT_SET(value)	(((value) << TMAG5170_RSLT_ALRT_POS) &\
 					TMAG5170_RSLT_ALRT_MASK)

 #define TMAG5170_VER_POS	4U
 #define TMAG5170_VER_MASK	(BIT_MASK(2U) << TMAG5170_VER_POS)
 #define TMAG5170_VER_GET(value)	(((value) & TMAG5170_VER_MASK) >> TMAG5170_VER_POS)

 #define TMAG5170_A1_REV				0x0U
 #define TMAG5170_A2_REV				0x1U

 #define TMAG5170_MAX_RANGE_50MT_IDX		0x0U
 #define TMAG5170_MAX_RANGE_25MT_IDX		0x1U
 #define TMAG5170_MAX_RANGE_100MT_IDX		0x2U
 #define TMAG5170_MAX_RANGE_EXTEND_FACTOR	0x3U

 #define TMAG5170_CONFIGURATION_MODE		0x0U
 #define TMAG5170_STAND_BY_MODE			0x1U
 #define TMAG5170_ACTIVE_TRIGGER_MODE		0x3U
 #define TMAG5170_SLEEP_MODE			0x5U
 #define TMAG5170_DEEP_SLEEP_MODE		0x6U

 #define TMAG5170_MT_TO_GAUSS_RATIO		10U
 #define TMAG5170_T_SENS_T0			25U
 #define TMAG5170_T_ADC_T0			17522U
 #define TMAG5170_T_ADC_RES			60U

 #define TMAG5170_CMD_TRIGGER_CONVERSION		BIT(0U)

 #define TMAG5170_CRC_SEED			0xFU
 #define TMAG5170_CRC_POLY			0x3U
 #define TMAG5170_SPI_BUFFER_LEN			4U
 #define TMAG5170_SET_CRC(buf, crc)		((uint8_t *)(buf))[3] |= (crc & 0x0F)
 #define TMAG5170_ZERO_CRC(buf)			((uint8_t *)(buf))[3] &= 0xF0
 #define TMAG5170_GET_CRC(buf)			((uint8_t *)(buf))[3] & 0x0F

 LOG_MODULE_REGISTER(TMAG5170, CONFIG_SENSOR_LOG_LEVEL);

 static int tmag5170_transmit_raw(const struct tmag5170_dev_config *config,
 				 uint8_t *buffer_tx,
 				 uint8_t *buffer_rx)
 {
 	const struct spi_buf tx_buf = {
 		.buf = buffer_tx,
 		.len = TMAG5170_SPI_BUFFER_LEN,
 	};

 	const struct spi_buf_set tx = {
 		.buffers = &tx_buf,
 		.count = 1
 	};

 	const struct spi_buf rx_buf = {
 		.buf = buffer_rx,
 		.len = TMAG5170_SPI_BUFFER_LEN,
 	};

 	const struct spi_buf_set rx = {
 		.buffers = &rx_buf,
 		.count = 1
 	};

 	int ret = spi_transceive_dt(&config->bus, &tx, &rx);

 	return ret;
 }

 static int tmag5170_transmit(const struct device *dev, uint8_t *buffer_tx, uint8_t *buffer_rx)
 {
 #if defined(CONFIG_TMAG5170_CRC)
 	TMAG5170_ZERO_CRC(buffer_tx);
 	uint8_t crc = crc4_ti(TMAG5170_CRC_SEED, buffer_tx, TMAG5170_SPI_BUFFER_LEN);

 	TMAG5170_SET_CRC(buffer_tx, crc);
 #endif
 	int ret = tmag5170_transmit_raw(dev->config, buffer_tx, buffer_rx);
 #if defined(CONFIG_TMAG5170_CRC)
 	if (buffer_rx != NULL && ret == 0) {
 		uint8_t read_crc = TMAG5170_GET_CRC(buffer_rx);

 		TMAG5170_ZERO_CRC(buffer_rx);
 		crc = crc4_ti(TMAG5170_CRC_SEED, buffer_rx, TMAG5170_SPI_BUFFER_LEN);
 		if (read_crc != crc) {
 			return -EIO;
 		}
 	}
 #endif

 	return ret;
 }

 static int tmag5170_write_register(const struct device *dev, uint32_t reg, uint16_t data)
 {
 	uint8_t buffer_tx[4] = { reg, (data >> 8) & 0xFF, data & 0xFF, 0x00U };

 	return tmag5170_transmit(dev, buffer_tx, NULL);
 }

 static int tmag5170_read_register(const struct device *dev,
 				  uint32_t reg,
 				  uint16_t *output,
 				  uint8_t cmd)
 {
 	uint8_t buffer_tx[4] = { BIT(7) | reg, 0x00U, 0x00U, (cmd & BIT_MASK(4U)) << 4U };
 	uint8_t buffer_rx[4] = { 0x00U };

 	int ret = tmag5170_transmit(dev, buffer_tx, buffer_rx);

 	*output = (buffer_rx[1] << 8) | buffer_rx[2];

 	return ret;
 }

 static int tmag5170_convert_magn_reading_to_gauss(struct sensor_value *output,
 						  uint16_t chan_reading,
 						  uint8_t chan_range,
 						  uint8_t chip_revision)
 {
 	uint16_t max_range_mt = 0U;

 	if (chan_range == TMAG5170_MAX_RANGE_50MT_IDX) {
 		max_range_mt = 50U;
 	} else if (chan_range == TMAG5170_MAX_RANGE_25MT_IDX) {
 		max_range_mt = 25U;
 	} else if (chan_range == TMAG5170_MAX_RANGE_100MT_IDX) {
 		max_range_mt = 100U;
 	} else {
 		return -ENOTSUP;
 	}

 	if (chip_revision == TMAG5170_A2_REV) {
 		max_range_mt *= TMAG5170_MAX_RANGE_EXTEND_FACTOR;
 	}

 	max_range_mt *= 2U;

 	/* The sensor returns data in mT, we need to convert it to Gauss */
 	uint32_t max_range_gauss = max_range_mt * TMAG5170_MT_TO_GAUSS_RATIO;

 	/* Convert from 2's complementary system */
 	int64_t result = chan_reading - ((chan_reading & 0x8000) << 1);

 	result *= max_range_gauss;

 	/* Scale to increase accuracy */
 	result *= 100000;

 	/* Divide as it is shown in datasheet */
 	result /= 65536;

 	/* Remove scale from the final result */
 	output->val1 = result / 100000;
 	output->val2 = result % 100000;

 	return 0;
 }

 static void tmag5170_convert_temp_reading_to_celsius(struct sensor_value *output,
 						     uint16_t chan_reading)
 {
 	int32_t result = chan_reading - TMAG5170_T_ADC_T0;

 	result = (TMAG5170_T_SENS_T0 * 100000) + (100000 * result / (int32_t)TMAG5170_T_ADC_RES);

 	output->val1 = result / 100000;
 	output->val2 = (result % 100000) * 10;
 }

 static void tmag5170_covert_angle_reading_to_degrees(struct sensor_value *output,
 						     uint16_t chan_reading)
 {
 	/* 12 MSBs store the integer part of the result,
 	 * 4 LSBs store the fractional part of the result
 	 */
 	output->val1 = chan_reading >> 4;
 	output->val2 = ((chan_reading & 0xF) * 1000000) / 16;
 }

 static int tmag5170_sample_fetch(const struct device *dev,
 				 enum sensor_channel chan)
 {
 	const struct tmag5170_dev_config *cfg = dev->config;
 	struct tmag5170_data *drv_data = dev->data;
 	int ret = 0;

 	if (cfg->operating_mode == TMAG5170_STAND_BY_MODE ||
 	    cfg->operating_mode == TMAG5170_ACTIVE_TRIGGER_MODE) {
 		uint16_t read_status;

 		tmag5170_read_register(dev,
 				       TMAG5170_REG_SYS_STATUS,
 				       &read_status,
 				       TMAG5170_CMD_TRIGGER_CONVERSION);

 		/* Wait for the measurement to be ready.
 		 * The waiting time will vary depending on the configuration
 		 */
 		k_sleep(K_MSEC(5U));
 	}

 	switch (chan) {
 	case SENSOR_CHAN_MAGN_X:
 		ret = tmag5170_read_register(dev, TMAG5170_REG_X_CH_RESULT, &drv_data->x, 0U);
 		break;
 	case SENSOR_CHAN_MAGN_Y:
 		ret = tmag5170_read_register(dev, TMAG5170_REG_Y_CH_RESULT, &drv_data->y, 0U);
 		break;
 	case SENSOR_CHAN_MAGN_Z:
 		ret = tmag5170_read_register(dev, TMAG5170_REG_Z_CH_RESULT, &drv_data->z, 0U);
 		break;
 	case SENSOR_CHAN_MAGN_XYZ:
 		ret = tmag5170_read_register(dev, TMAG5170_REG_X_CH_RESULT, &drv_data->x, 0U);

 		if (ret == 0) {
 			ret = tmag5170_read_register(dev,
 						     TMAG5170_REG_Y_CH_RESULT,
 						     &drv_data->y,
 						     0U);
 		}
 		if (ret == 0) {
 			ret = tmag5170_read_register(dev,
 						     TMAG5170_REG_Z_CH_RESULT,
 						     &drv_data->z,
 						     0U);
 		}
 		break;
 	case SENSOR_CHAN_ROTATION:
 		ret = tmag5170_read_register(dev,
 					     TMAG5170_REG_ANGLE_RESULT,
 					     &drv_data->angle,
 					     0U);
 		break;
 	case SENSOR_CHAN_AMBIENT_TEMP:
 		ret = tmag5170_read_register(dev,
 					TMAG5170_REG_TEMP_RESULT,
 					&drv_data->temperature,
 					0U);
 		break;
 	case SENSOR_CHAN_ALL:
 		ret = tmag5170_read_register(dev,
 					     TMAG5170_REG_TEMP_RESULT,
 					     &drv_data->temperature,
 					     0U);

 		if (ret == 0) {
 			ret = tmag5170_read_register(dev,
 						     TMAG5170_REG_ANGLE_RESULT,
 						     &drv_data->angle,
 						     0U);
 		}

 		if (ret == 0) {
 			ret = tmag5170_read_register(dev,
 						     TMAG5170_REG_X_CH_RESULT,
 						     &drv_data->x,
 						     0U);
 		}

 		if (ret == 0) {
 			ret = tmag5170_read_register(dev,
 						     TMAG5170_REG_Y_CH_RESULT,
 						     &drv_data->y,
 						     0U);
 		}

 		if (ret == 0) {
 			ret = tmag5170_read_register(dev,
 						     TMAG5170_REG_Z_CH_RESULT,
 						     &drv_data->z,
 						     0U);
 		}

 		break;
 	default:
 		ret = -ENOTSUP;
 		break;
 	}

 	return ret;
 }

 static int tmag5170_channel_get(const struct device *dev,
 				enum sensor_channel chan,
 				struct sensor_value *val)
 {
 	const struct tmag5170_dev_config *cfg = dev->config;
 	struct tmag5170_data *drv_data = dev->data;
 	int ret = 0;

 	switch (chan) {
 	case SENSOR_CHAN_MAGN_XYZ:
 		ret = tmag5170_convert_magn_reading_to_gauss(val,
 							     drv_data->x,
 							     cfg->x_range,
 							     drv_data->chip_revision);

 		if (ret == 0) {
 			ret = tmag5170_convert_magn_reading_to_gauss(val + 1,
 								     drv_data->y,
 								     cfg->y_range,
 								     drv_data->chip_revision);
 		}

 		if (ret == 0) {
 			ret = tmag5170_convert_magn_reading_to_gauss(val + 2,
 								     drv_data->z,
 								     cfg->z_range,
 								     drv_data->chip_revision);
 		}
 		break;
 	case SENSOR_CHAN_MAGN_X:
 		ret = tmag5170_convert_magn_reading_to_gauss(val,
 							     drv_data->x,
 							     cfg->x_range,
 							     drv_data->chip_revision);
 		break;
 	case SENSOR_CHAN_MAGN_Y:
 		ret = tmag5170_convert_magn_reading_to_gauss(val,
 							     drv_data->y,
 							     cfg->y_range,
 							     drv_data->chip_revision);
 		break;
 	case SENSOR_CHAN_MAGN_Z:
 		ret = tmag5170_convert_magn_reading_to_gauss(val,
 							     drv_data->z,
 							     cfg->z_range,
 							     drv_data->chip_revision);
 		break;
 	case SENSOR_CHAN_ROTATION:
 		tmag5170_covert_angle_reading_to_degrees(val, drv_data->angle);
 		break;
 	case SENSOR_CHAN_AMBIENT_TEMP:
 		tmag5170_convert_temp_reading_to_celsius(val, drv_data->temperature);
 		break;
 	default:
 		ret = -ENOTSUP;
 		break;
 	}

 	return ret;
 }

 static int tmag5170_init_registers(const struct device *dev)
 {
 	const struct tmag5170_dev_config *cfg = dev->config;
 	struct tmag5170_data *drv_data = dev->data;
 	uint16_t test_cfg_reg = 0U;
 	int ret = 0;

 #if !defined(CONFIG_TMAG5170_CRC)
 	const uint8_t disable_crc_packet[4] = { 0x0FU, 0x0U, 0x04U, 0x07U };

 	ret = tmag5170_transmit_raw(cfg, disable_crc_packet, NULL);
 #endif
 	if (ret == 0) {
 		ret = tmag5170_read_register(dev, TMAG5170_REG_TEST_CONFIG, &test_cfg_reg, 0U);
 	}

 	if (ret == 0) {
 		drv_data->chip_revision = TMAG5170_VER_GET(test_cfg_reg);

 		ret = tmag5170_write_register(dev,
 				TMAG5170_REG_SENSOR_CONFIG,
 				TMAG5170_ANGLE_EN_SET(cfg->angle_measurement) |
 				TMAG5170_SLEEPTIME_SET(cfg->sleep_time) |
 				TMAG5170_MAG_CH_EN_SET(cfg->magnetic_channels) |
 				TMAG5170_Z_RANGE_SET(cfg->z_range) |
 				TMAG5170_Y_RANGE_SET(cfg->y_range) |
 				TMAG5170_X_RANGE_SET(cfg->x_range));
 	}

 #if defined(CONFIG_TMAG5170_TRIGGER)
 	if (ret == 0) {
 		ret = tmag5170_write_register(dev,
 				TMAG5170_REG_ALERT_CONFIG,
 				TMAG5170_RSLT_ALRT_SET(1U));
 	}
 #endif
 	if (ret == 0) {
 		ret = tmag5170_write_register(dev,
 				TMAG5170_REG_DEVICE_CONFIG,
 				TMAG5170_OPERATING_MODE_SET(cfg->operating_mode) |
 				TMAG5170_CONV_AVG_SET(cfg->oversampling) |
 				TMAG5170_MAG_TEMPCO_SET(cfg->magnet_type) |
 				TMAG5170_T_CH_EN_SET(cfg->tempeature_measurement) |
 				TMAG5170_T_RATE_SET(cfg->disable_temperature_oversampling));
 	}

 	return ret;
 }

 #ifdef CONFIG_PM_DEVICE
 static int tmag5170_pm_action(const struct device *dev,
 			      enum pm_device_action action)
 {
 	int ret_val = 0;

 	switch (action) {
 	case PM_DEVICE_ACTION_RESUME:
 		tmag5170_write_register(dev,
 					TMAG5170_REG_DEVICE_CONFIG,
 					TMAG5170_OPERATING_MODE_SET(TMAG5170_CONFIGURATION_MODE));
 		/* As per datasheet, waking up from deep-sleep can take up to 500us */
 		k_sleep(K_USEC(500));
 		ret_val = tmag5170_init_registers(dev);
 		break;
 	case PM_DEVICE_ACTION_SUSPEND:
 		ret_val = tmag5170_write_register(dev,
 					TMAG5170_REG_DEVICE_CONFIG,
 					TMAG5170_OPERATING_MODE_SET(TMAG5170_DEEP_SLEEP_MODE));
 		break;
 	default:
 		ret_val = -ENOTSUP;
 	}

 	return ret_val;
 }
 #endif /* CONFIG_PM_DEVICE */

 static const struct sensor_driver_api tmag5170_driver_api = {
 	.sample_fetch = tmag5170_sample_fetch,
 	.channel_get = tmag5170_channel_get,
 #if defined(CONFIG_TMAG5170_TRIGGER)
 	.trigger_set = tmag5170_trigger_set
 #endif
 };

 static int tmag5170_init(const struct device *dev)
 {
 	const struct tmag5170_dev_config *cfg = dev->config;
 	int ret = 0;

 	if (!spi_is_ready_dt(&cfg->bus)) {
 		LOG_ERR("SPI dev %s not ready", cfg->bus.bus->name);
 		return -ENODEV;
 	}

 	ret = tmag5170_init_registers(dev);
 	if (ret != 0) {
 		return ret;
 	}

 #if defined(CONFIG_TMAG5170_TRIGGER)
 	if (cfg->int_gpio.port) {
 		ret = tmag5170_trigger_init(dev);
 	}
 #endif

 	return ret;
 }

 #define DEFINE_TMAG5170(_num)								   \
 	static struct tmag5170_data tmag5170_data_##_num;				   \
 	static const struct tmag5170_dev_config tmag5170_config_##_num = {		   \
 		.bus = SPI_DT_SPEC_INST_GET(_num,					   \
 					   SPI_OP_MODE_MASTER |				   \
 					   SPI_TRANSFER_MSB |				   \
 					   SPI_WORD_SET(32),				   \
 					   0),						   \
 		.magnetic_channels = DT_INST_ENUM_IDX(_num, magnetic_channels),		   \
 		.x_range = DT_INST_ENUM_IDX(_num, x_range),				   \
 		.y_range = DT_INST_ENUM_IDX(_num, y_range),				   \
 		.z_range = DT_INST_ENUM_IDX(_num, z_range),				   \
 		.operating_mode = DT_INST_PROP(_num, operating_mode),			   \
 		.oversampling = DT_INST_ENUM_IDX(_num, oversampling),			   \
 		.tempeature_measurement = DT_INST_PROP(_num, enable_temperature_channel),  \
 		.magnet_type = DT_INST_ENUM_IDX(_num, magnet_type),			   \
 		.angle_measurement = DT_INST_ENUM_IDX(_num, angle_measurement),		   \
 		.disable_temperature_oversampling = DT_INST_PROP(_num,			   \
 							disable_temperature_oversampling), \
 		.sleep_time = DT_INST_ENUM_IDX(_num, sleep_time),			   \
 		IF_ENABLED(CONFIG_TMAG5170_TRIGGER,					   \
 			(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(_num, int_gpios, { 0 }),))   \
 	};										   \
 	PM_DEVICE_DT_INST_DEFINE(_num, tmag5170_pm_action);				   \
 											   \
 	SENSOR_DEVICE_DT_INST_DEFINE(_num,						   \
 				tmag5170_init,						   \
 				PM_DEVICE_DT_INST_GET(_num),				   \
 				&tmag5170_data_##_num,					   \
 				&tmag5170_config_##_num,				   \
 				POST_KERNEL,						   \
 				CONFIG_SENSOR_INIT_PRIORITY,				   \
 				&tmag5170_driver_api);

 DT_INST_FOREACH_STATUS_OKAY(DEFINE_TMAG5170)
	/*
	* Copyright (c) 2023 Michal Morsisko
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#define DT_DRV_COMPAT ti_tmag5170

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

	#if defined(CONFIG_TMAG5170_CRC)
	#include <zephyr/sys/crc.h>
	#endif

	#include "tmag5170.h"

	#define TMAG5170_REG_DEVICE_CONFIG 0x0U
	#define TMAG5170_REG_SENSOR_CONFIG 0x1U
	#define TMAG5170_REG_SYSTEM_CONFIG 0x2U
	#define TMAG5170_REG_ALERT_CONFIG 0x3U
	#define TMAG5170_REG_X_THRX_CONFIG 0x4U
	#define TMAG5170_REG_Y_THRX_CONFIG 0x5U
	#define TMAG5170_REG_Z_THRX_CONFIG 0x6U
	#define TMAG5170_REG_T_THRX_CONFIG 0x7U
	#define TMAG5170_REG_CONV_STATUS 0x8U
	#define TMAG5170_REG_X_CH_RESULT 0x9U
	#define TMAG5170_REG_Y_CH_RESULT 0xAU
	#define TMAG5170_REG_Z_CH_RESULT 0xBU
	#define TMAG5170_REG_TEMP_RESULT 0xCU
	#define TMAG5170_REG_AFE_STATUS 0xDU
	#define TMAG5170_REG_SYS_STATUS 0xEU
	#define TMAG5170_REG_TEST_CONFIG 0xFU
	#define TMAG5170_REG_OSC_MONITOR 0x10U
	#define TMAG5170_REG_MAG_GAIN_CONFIG 0x11U
	#define TMAG5170_REG_MAG_OFFSET_CONFIG 0x12U
	#define TMAG5170_REG_ANGLE_RESULT 0x13U
	#define TMAG5170_REG_MAGNITUDE_RESULT 0x14U

	#define TMAG5170_CONV_AVG_POS 12U
	#define TMAG5170_CONV_AVG_MASK (BIT_MASK(3U) << TMAG5170_CONV_AVG_POS)
	#define TMAG5170_CONV_AVG_SET(value) (((value) << TMAG5170_CONV_AVG_POS) &\
	TMAG5170_CONV_AVG_MASK)

	#define TMAG5170_MAG_TEMPCO_POS 8U
	#define TMAG5170_MAG_TEMPCO_MASK (BIT_MASK(2U) << TMAG5170_MAG_TEMPCO_POS)
	#define TMAG5170_MAG_TEMPCO_SET(value) (((value) << TMAG5170_MAG_TEMPCO_POS) &\
	TMAG5170_MAG_TEMPCO_MASK)

	#define TMAG5170_OPERATING_MODE_POS 4U
	#define TMAG5170_OPERATING_MODE_MASK (BIT_MASK(3U) << TMAG5170_OPERATING_MODE_POS)
	#define TMAG5170_OPERATING_MODE_SET(value) (((value) << TMAG5170_OPERATING_MODE_POS) &\
	TMAG5170_OPERATING_MODE_MASK)

	#define TMAG5170_T_CH_EN_POS 3U
	#define TMAG5170_T_CH_EN_MASK (BIT_MASK(1U) << TMAG5170_T_CH_EN_POS)
	#define TMAG5170_T_CH_EN_SET(value) (((value) << TMAG5170_T_CH_EN_POS) &\
	TMAG5170_T_CH_EN_MASK)

	#define TMAG5170_T_RATE_POS 2U
	#define TMAG5170_T_RATE_MASK (BIT_MASK(1U) << TMAG5170_T_RATE_POS)
	#define TMAG5170_T_RATE_SET(value) (((value) << TMAG5170_T_RATE_POS) &\
	TMAG5170_T_RATE_MASK)

	#define TMAG5170_ANGLE_EN_POS 14U
	#define TMAG5170_ANGLE_EN_MASK (BIT_MASK(2U) << TMAG5170_ANGLE_EN_POS)
	#define TMAG5170_ANGLE_EN_SET(value) (((value) << TMAG5170_ANGLE_EN_POS) &\
	TMAG5170_ANGLE_EN_MASK)

	#define TMAG5170_SLEEPTIME_POS 10U
	#define TMAG5170_SLEEPTIME_MASK (BIT_MASK(4U) << TMAG5170_SLEEPTIME_POS)
	#define TMAG5170_SLEEPTIME_SET(value) (((value) << TMAG5170_SLEEPTIME_POS) &\
	TMAG5170_SLEEPTIME_MASK)

	#define TMAG5170_MAG_CH_EN_POS 6U
	#define TMAG5170_MAG_CH_EN_MASK (BIT_MASK(4U) << TMAG5170_MAG_CH_EN_POS)
	#define TMAG5170_MAG_CH_EN_SET(value) (((value) << TMAG5170_MAG_CH_EN_POS) &\
	TMAG5170_MAG_CH_EN_MASK)

	#define TMAG5170_Z_RANGE_POS 4U
	#define TMAG5170_Z_RANGE_MASK (BIT_MASK(2U) << TMAG5170_Z_RANGE_POS)
	#define TMAG5170_Z_RANGE_SET(value) (((value) << TMAG5170_Z_RANGE_POS) &\
	TMAG5170_Z_RANGE_MASK)

	#define TMAG5170_Y_RANGE_POS 2U
	#define TMAG5170_Y_RANGE_MASK (BIT_MASK(2U) << TMAG5170_Y_RANGE_POS)
	#define TMAG5170_Y_RANGE_SET(value) (((value) << TMAG5170_Y_RANGE_POS) &\
	TMAG5170_Y_RANGE_MASK)

	#define TMAG5170_X_RANGE_POS 0U
	#define TMAG5170_X_RANGE_MASK (BIT_MASK(2U) << TMAG5170_X_RANGE_POS)
	#define TMAG5170_X_RANGE_SET(value) (((value) << TMAG5170_X_RANGE_POS) &\
	TMAG5170_X_RANGE_MASK)

	#define TMAG5170_RSLT_ALRT_POS 8U
	#define TMAG5170_RSLT_ALRT_MASK (BIT_MASK(1U) << TMAG5170_RSLT_ALRT_POS)
	#define TMAG5170_RSLT_ALRT_SET(value) (((value) << TMAG5170_RSLT_ALRT_POS) &\
	TMAG5170_RSLT_ALRT_MASK)

	#define TMAG5170_VER_POS 4U
	#define TMAG5170_VER_MASK (BIT_MASK(2U) << TMAG5170_VER_POS)
	#define TMAG5170_VER_GET(value) (((value) & TMAG5170_VER_MASK) >> TMAG5170_VER_POS)

	#define TMAG5170_A1_REV 0x0U
	#define TMAG5170_A2_REV 0x1U

	#define TMAG5170_MAX_RANGE_50MT_IDX 0x0U
	#define TMAG5170_MAX_RANGE_25MT_IDX 0x1U
	#define TMAG5170_MAX_RANGE_100MT_IDX 0x2U
	#define TMAG5170_MAX_RANGE_EXTEND_FACTOR 0x3U

	#define TMAG5170_CONFIGURATION_MODE 0x0U
	#define TMAG5170_STAND_BY_MODE 0x1U
	#define TMAG5170_ACTIVE_TRIGGER_MODE 0x3U
	#define TMAG5170_SLEEP_MODE 0x5U
	#define TMAG5170_DEEP_SLEEP_MODE 0x6U

	#define TMAG5170_MT_TO_GAUSS_RATIO 10U
	#define TMAG5170_T_SENS_T0 25U
	#define TMAG5170_T_ADC_T0 17522U
	#define TMAG5170_T_ADC_RES 60U

	#define TMAG5170_CMD_TRIGGER_CONVERSION BIT(0U)

	#define TMAG5170_CRC_SEED 0xFU
	#define TMAG5170_CRC_POLY 0x3U
	#define TMAG5170_SPI_BUFFER_LEN 4U
	#define TMAG5170_SET_CRC(buf, crc) ((uint8_t *)(buf))[3] \|= (crc & 0x0F)
	#define TMAG5170_ZERO_CRC(buf) ((uint8_t *)(buf))[3] &= 0xF0
	#define TMAG5170_GET_CRC(buf) ((uint8_t *)(buf))[3] & 0x0F

	LOG_MODULE_REGISTER(TMAG5170, CONFIG_SENSOR_LOG_LEVEL);

	static int tmag5170_transmit_raw(const struct tmag5170_dev_config *config,
	uint8_t *buffer_tx,
	uint8_t *buffer_rx)
	{
	const struct spi_buf tx_buf = {
	.buf = buffer_tx,
	.len = TMAG5170_SPI_BUFFER_LEN,
	};

	const struct spi_buf_set tx = {
	.buffers = &tx_buf,
	.count = 1
	};

	const struct spi_buf rx_buf = {
	.buf = buffer_rx,
	.len = TMAG5170_SPI_BUFFER_LEN,
	};

	const struct spi_buf_set rx = {
	.buffers = &rx_buf,
	.count = 1
	};

	int ret = spi_transceive_dt(&config->bus, &tx, &rx);

	return ret;
	}

	static int tmag5170_transmit(const struct device dev, uint8_t buffer_tx, uint8_t *buffer_rx)
	{
	#if defined(CONFIG_TMAG5170_CRC)
	TMAG5170_ZERO_CRC(buffer_tx);
	uint8_t crc = crc4_ti(TMAG5170_CRC_SEED, buffer_tx, TMAG5170_SPI_BUFFER_LEN);

	TMAG5170_SET_CRC(buffer_tx, crc);
	#endif
	int ret = tmag5170_transmit_raw(dev->config, buffer_tx, buffer_rx);
	#if defined(CONFIG_TMAG5170_CRC)
	if (buffer_rx != NULL && ret == 0) {
	uint8_t read_crc = TMAG5170_GET_CRC(buffer_rx);

	TMAG5170_ZERO_CRC(buffer_rx);
	crc = crc4_ti(TMAG5170_CRC_SEED, buffer_rx, TMAG5170_SPI_BUFFER_LEN);
	if (read_crc != crc) {
	return -EIO;
	}
	}
	#endif

	return ret;
	}

	static int tmag5170_write_register(const struct device *dev, uint32_t reg, uint16_t data)
	{
	uint8_t buffer_tx[4] = { reg, (data >> 8) & 0xFF, data & 0xFF, 0x00U };

	return tmag5170_transmit(dev, buffer_tx, NULL);
	}

	static int tmag5170_read_register(const struct device *dev,
	uint32_t reg,
	uint16_t *output,
	uint8_t cmd)
	{
	uint8_t buffer_tx[4] = { BIT(7) \| reg, 0x00U, 0x00U, (cmd & BIT_MASK(4U)) << 4U };
	uint8_t buffer_rx[4] = { 0x00U };

	int ret = tmag5170_transmit(dev, buffer_tx, buffer_rx);

	*output = (buffer_rx[1] << 8) \| buffer_rx[2];

	return ret;
	}

	static int tmag5170_convert_magn_reading_to_gauss(struct sensor_value *output,
	uint16_t chan_reading,
	uint8_t chan_range,
	uint8_t chip_revision)
	{
	uint16_t max_range_mt = 0U;

	if (chan_range == TMAG5170_MAX_RANGE_50MT_IDX) {
	max_range_mt = 50U;
	} else if (chan_range == TMAG5170_MAX_RANGE_25MT_IDX) {
	max_range_mt = 25U;
	} else if (chan_range == TMAG5170_MAX_RANGE_100MT_IDX) {
	max_range_mt = 100U;
	} else {
	return -ENOTSUP;
	}

	if (chip_revision == TMAG5170_A2_REV) {
	max_range_mt *= TMAG5170_MAX_RANGE_EXTEND_FACTOR;
	}

	max_range_mt *= 2U;

	/* The sensor returns data in mT, we need to convert it to Gauss */
	uint32_t max_range_gauss = max_range_mt * TMAG5170_MT_TO_GAUSS_RATIO;

	/* Convert from 2's complementary system */
	int64_t result = chan_reading - ((chan_reading & 0x8000) << 1);

	result *= max_range_gauss;

	/* Scale to increase accuracy */
	result *= 100000;

	/* Divide as it is shown in datasheet */
	result /= 65536;

	/* Remove scale from the final result */
	output->val1 = result / 100000;
	output->val2 = result % 100000;

	return 0;
	}

	static void tmag5170_convert_temp_reading_to_celsius(struct sensor_value *output,
	uint16_t chan_reading)
	{
	int32_t result = chan_reading - TMAG5170_T_ADC_T0;

	result = (TMAG5170_T_SENS_T0 * 100000) + (100000 * result / (int32_t)TMAG5170_T_ADC_RES);

	output->val1 = result / 100000;
	output->val2 = (result % 100000) * 10;
	}

	static void tmag5170_covert_angle_reading_to_degrees(struct sensor_value *output,
	uint16_t chan_reading)
	{
	/* 12 MSBs store the integer part of the result,
	* 4 LSBs store the fractional part of the result
	*/
	output->val1 = chan_reading >> 4;
	output->val2 = ((chan_reading & 0xF) * 1000000) / 16;
	}

	static int tmag5170_sample_fetch(const struct device *dev,
	enum sensor_channel chan)
	{
	const struct tmag5170_dev_config *cfg = dev->config;
	struct tmag5170_data *drv_data = dev->data;
	int ret = 0;

	if (cfg->operating_mode == TMAG5170_STAND_BY_MODE \|\|
	cfg->operating_mode == TMAG5170_ACTIVE_TRIGGER_MODE) {
	uint16_t read_status;

	tmag5170_read_register(dev,
	TMAG5170_REG_SYS_STATUS,
	&read_status,
	TMAG5170_CMD_TRIGGER_CONVERSION);

	/* Wait for the measurement to be ready.
	* The waiting time will vary depending on the configuration
	*/
	k_sleep(K_MSEC(5U));
	}

	switch (chan) {
	case SENSOR_CHAN_MAGN_X:
	ret = tmag5170_read_register(dev, TMAG5170_REG_X_CH_RESULT, &drv_data->x, 0U);
	break;
	case SENSOR_CHAN_MAGN_Y:
	ret = tmag5170_read_register(dev, TMAG5170_REG_Y_CH_RESULT, &drv_data->y, 0U);
	break;
	case SENSOR_CHAN_MAGN_Z:
	ret = tmag5170_read_register(dev, TMAG5170_REG_Z_CH_RESULT, &drv_data->z, 0U);
	break;
	case SENSOR_CHAN_MAGN_XYZ:
	ret = tmag5170_read_register(dev, TMAG5170_REG_X_CH_RESULT, &drv_data->x, 0U);

	if (ret == 0) {
	ret = tmag5170_read_register(dev,
	TMAG5170_REG_Y_CH_RESULT,
	&drv_data->y,
	0U);
	}
	if (ret == 0) {
	ret = tmag5170_read_register(dev,
	TMAG5170_REG_Z_CH_RESULT,
	&drv_data->z,
	0U);
	}
	break;
	case SENSOR_CHAN_ROTATION:
	ret = tmag5170_read_register(dev,
	TMAG5170_REG_ANGLE_RESULT,
	&drv_data->angle,
	0U);
	break;
	case SENSOR_CHAN_AMBIENT_TEMP:
	ret = tmag5170_read_register(dev,
	TMAG5170_REG_TEMP_RESULT,
	&drv_data->temperature,
	0U);
	break;
	case SENSOR_CHAN_ALL:
	ret = tmag5170_read_register(dev,
	TMAG5170_REG_TEMP_RESULT,
	&drv_data->temperature,
	0U);

	if (ret == 0) {
	ret = tmag5170_read_register(dev,
	TMAG5170_REG_ANGLE_RESULT,
	&drv_data->angle,
	0U);
	}

	if (ret == 0) {
	ret = tmag5170_read_register(dev,
	TMAG5170_REG_X_CH_RESULT,
	&drv_data->x,
	0U);
	}

	if (ret == 0) {
	ret = tmag5170_read_register(dev,
	TMAG5170_REG_Y_CH_RESULT,
	&drv_data->y,
	0U);
	}

	if (ret == 0) {
	ret = tmag5170_read_register(dev,
	TMAG5170_REG_Z_CH_RESULT,
	&drv_data->z,
	0U);
	}

	break;
	default:
	ret = -ENOTSUP;
	break;
	}

	return ret;
	}

	static int tmag5170_channel_get(const struct device *dev,
	enum sensor_channel chan,
	struct sensor_value *val)
	{
	const struct tmag5170_dev_config *cfg = dev->config;
	struct tmag5170_data *drv_data = dev->data;
	int ret = 0;

	switch (chan) {
	case SENSOR_CHAN_MAGN_XYZ:
	ret = tmag5170_convert_magn_reading_to_gauss(val,
	drv_data->x,
	cfg->x_range,
	drv_data->chip_revision);

	if (ret == 0) {
	ret = tmag5170_convert_magn_reading_to_gauss(val + 1,
	drv_data->y,
	cfg->y_range,
	drv_data->chip_revision);
	}

	if (ret == 0) {
	ret = tmag5170_convert_magn_reading_to_gauss(val + 2,
	drv_data->z,
	cfg->z_range,
	drv_data->chip_revision);
	}
	break;
	case SENSOR_CHAN_MAGN_X:
	ret = tmag5170_convert_magn_reading_to_gauss(val,
	drv_data->x,
	cfg->x_range,
	drv_data->chip_revision);
	break;
	case SENSOR_CHAN_MAGN_Y:
	ret = tmag5170_convert_magn_reading_to_gauss(val,
	drv_data->y,
	cfg->y_range,
	drv_data->chip_revision);
	break;
	case SENSOR_CHAN_MAGN_Z:
	ret = tmag5170_convert_magn_reading_to_gauss(val,
	drv_data->z,
	cfg->z_range,
	drv_data->chip_revision);
	break;
	case SENSOR_CHAN_ROTATION:
	tmag5170_covert_angle_reading_to_degrees(val, drv_data->angle);
	break;
	case SENSOR_CHAN_AMBIENT_TEMP:
	tmag5170_convert_temp_reading_to_celsius(val, drv_data->temperature);
	break;
	default:
	ret = -ENOTSUP;
	break;
	}

	return ret;
	}

	static int tmag5170_init_registers(const struct device *dev)
	{
	const struct tmag5170_dev_config *cfg = dev->config;
	struct tmag5170_data *drv_data = dev->data;
	uint16_t test_cfg_reg = 0U;
	int ret = 0;

	#if !defined(CONFIG_TMAG5170_CRC)
	const uint8_t disable_crc_packet[4] = { 0x0FU, 0x0U, 0x04U, 0x07U };

	ret = tmag5170_transmit_raw(cfg, disable_crc_packet, NULL);
	#endif
	if (ret == 0) {
	ret = tmag5170_read_register(dev, TMAG5170_REG_TEST_CONFIG, &test_cfg_reg, 0U);
	}

	if (ret == 0) {
	drv_data->chip_revision = TMAG5170_VER_GET(test_cfg_reg);

	ret = tmag5170_write_register(dev,
	TMAG5170_REG_SENSOR_CONFIG,
	TMAG5170_ANGLE_EN_SET(cfg->angle_measurement) \|
	TMAG5170_SLEEPTIME_SET(cfg->sleep_time) \|
	TMAG5170_MAG_CH_EN_SET(cfg->magnetic_channels) \|
	TMAG5170_Z_RANGE_SET(cfg->z_range) \|
	TMAG5170_Y_RANGE_SET(cfg->y_range) \|
	TMAG5170_X_RANGE_SET(cfg->x_range));
	}

	#if defined(CONFIG_TMAG5170_TRIGGER)
	if (ret == 0) {
	ret = tmag5170_write_register(dev,
	TMAG5170_REG_ALERT_CONFIG,
	TMAG5170_RSLT_ALRT_SET(1U));
	}
	#endif
	if (ret == 0) {
	ret = tmag5170_write_register(dev,
	TMAG5170_REG_DEVICE_CONFIG,
	TMAG5170_OPERATING_MODE_SET(cfg->operating_mode) \|
	TMAG5170_CONV_AVG_SET(cfg->oversampling) \|
	TMAG5170_MAG_TEMPCO_SET(cfg->magnet_type) \|
	TMAG5170_T_CH_EN_SET(cfg->tempeature_measurement) \|
	TMAG5170_T_RATE_SET(cfg->disable_temperature_oversampling));
	}

	return ret;
	}

	#ifdef CONFIG_PM_DEVICE
	static int tmag5170_pm_action(const struct device *dev,
	enum pm_device_action action)
	{
	int ret_val = 0;

	switch (action) {
	case PM_DEVICE_ACTION_RESUME:
	tmag5170_write_register(dev,
	TMAG5170_REG_DEVICE_CONFIG,
	TMAG5170_OPERATING_MODE_SET(TMAG5170_CONFIGURATION_MODE));
	/* As per datasheet, waking up from deep-sleep can take up to 500us */
	k_sleep(K_USEC(500));
	ret_val = tmag5170_init_registers(dev);
	break;
	case PM_DEVICE_ACTION_SUSPEND:
	ret_val = tmag5170_write_register(dev,
	TMAG5170_REG_DEVICE_CONFIG,
	TMAG5170_OPERATING_MODE_SET(TMAG5170_DEEP_SLEEP_MODE));
	break;
	default:
	ret_val = -ENOTSUP;
	}

	return ret_val;
	}
	#endif /* CONFIG_PM_DEVICE */

	static const struct sensor_driver_api tmag5170_driver_api = {
	.sample_fetch = tmag5170_sample_fetch,
	.channel_get = tmag5170_channel_get,
	#if defined(CONFIG_TMAG5170_TRIGGER)
	.trigger_set = tmag5170_trigger_set
	#endif
	};

	static int tmag5170_init(const struct device *dev)
	{
	const struct tmag5170_dev_config *cfg = dev->config;
	int ret = 0;

	if (!spi_is_ready_dt(&cfg->bus)) {
	LOG_ERR("SPI dev %s not ready", cfg->bus.bus->name);
	return -ENODEV;
	}

	ret = tmag5170_init_registers(dev);
	if (ret != 0) {
	return ret;
	}

	#if defined(CONFIG_TMAG5170_TRIGGER)
	if (cfg->int_gpio.port) {
	ret = tmag5170_trigger_init(dev);
	}
	#endif

	return ret;
	}

	#define DEFINE_TMAG5170(_num) \
	static struct tmag5170_data tmag5170_data_##_num; \
	static const struct tmag5170_dev_config tmag5170_config_##_num = { \
	.bus = SPI_DT_SPEC_INST_GET(_num, \
	SPI_OP_MODE_MASTER \| \
	SPI_TRANSFER_MSB \| \
	SPI_WORD_SET(32), \
	0), \
	.magnetic_channels = DT_INST_ENUM_IDX(_num, magnetic_channels), \
	.x_range = DT_INST_ENUM_IDX(_num, x_range), \
	.y_range = DT_INST_ENUM_IDX(_num, y_range), \
	.z_range = DT_INST_ENUM_IDX(_num, z_range), \
	.operating_mode = DT_INST_PROP(_num, operating_mode), \
	.oversampling = DT_INST_ENUM_IDX(_num, oversampling), \
	.tempeature_measurement = DT_INST_PROP(_num, enable_temperature_channel), \
	.magnet_type = DT_INST_ENUM_IDX(_num, magnet_type), \
	.angle_measurement = DT_INST_ENUM_IDX(_num, angle_measurement), \
	.disable_temperature_oversampling = DT_INST_PROP(_num, \
	disable_temperature_oversampling), \
	.sleep_time = DT_INST_ENUM_IDX(_num, sleep_time), \
	IF_ENABLED(CONFIG_TMAG5170_TRIGGER, \
	(.int_gpio = GPIO_DT_SPEC_INST_GET_OR(_num, int_gpios, { 0 }),)) \
	}; \
	PM_DEVICE_DT_INST_DEFINE(_num, tmag5170_pm_action); \
	\
	SENSOR_DEVICE_DT_INST_DEFINE(_num, \
	tmag5170_init, \
	PM_DEVICE_DT_INST_GET(_num), \
	&tmag5170_data_##_num, \
	&tmag5170_config_##_num, \
	POST_KERNEL, \
	CONFIG_SENSOR_INIT_PRIORITY, \
	&tmag5170_driver_api);

	DT_INST_FOREACH_STATUS_OKAY(DEFINE_TMAG5170)