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

 /*
  * Copyright (c) 2021 Nuvoton Technology Corporation.
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #define DT_DRV_COMPAT nuvoton_npcx_tach

 /**
  * @file
  * @brief Nuvoton NPCX tachometer sensor module driver
  *
  * This file contains a driver for the tachometer sensor module which contains
  * two independent timers (counter 1 and 2). They are used to capture a counter
  * value when the signals via external pins match the condition. The following
  * is block diagram of this module when it set to mode 5.
  *
  *                            |          Capture A
  *                            |              |         +-----------+  TA Pin
  *           +-----------+    |        +-----+-----+   |   _   _   |   |
  * APB_CLK-->| Prescaler |--->|---+--->| Counter 1 |<--| _| |_| |_ |<--+
  *           +-----------+    |   |    +-----------+   +-----------+
  *                            | CLK_SEL                Edge Detection
  *                            |          Capture B
  * LFCLK--------------------->|              |         +-----------+  TB Pin
  *                            |        +-----+-----+   |   _   _   |   |
  *                            |---+--->| Counter 2 |<--| _| |_| |_ |<--+
  *                            |   |    +-----------+   +-----------+
  *                            | CLK_SEL                Edge Detection
  *                            |
  *                            | TACH_CLK
  *                            +----------
  *          (NPCX Tachometer Mode 5, Dual-Independent Input Capture)
  *
  * This mode is used to measure either the frequency of two external clocks
  * (via TA or TB pins) that are slower than TACH_CLK. A transition event (rising
  * or falling edge) received on TAn/TBn pin causes a transfer of timer 1/2
  * contents to Capture register and reload counter. Based on this value, we can
  * compute the current RPM of external signal from encoders.
  */

 #include <errno.h>
 #include <zephyr/device.h>
 #include <zephyr/drivers/clock_control.h>
 #include <zephyr/drivers/pinctrl.h>
 #include <zephyr/drivers/sensor.h>
 #include <zephyr/dt-bindings/sensor/npcx_tach.h>
 #include <soc.h>
 #include <zephyr/logging/log.h>

 LOG_MODULE_REGISTER(tach_npcx, CONFIG_SENSOR_LOG_LEVEL);

 /* Device config */
 struct tach_npcx_config {
 	/* tachometer controller base address */
 	uintptr_t base;
 	/* clock configuration */
 	struct npcx_clk_cfg clk_cfg;
 	/* sampling clock frequency of tachometer */
 	uint32_t sample_clk;
 	/* selected port of tachometer */
 	int port;
 	/* number of pulses (holes) per round of tachometer's input (encoder) */
 	int pulses_per_round;
 	/* pinmux configuration */
 	const struct pinctrl_dev_config *pcfg;
 };

 /* Driver data */
 struct tach_npcx_data {
 	/* Input clock for tachometers */
 	uint32_t input_clk;
 	/* Captured counts of tachometer */
 	uint32_t capture;
 };

 /* Driver convenience defines */
 #define HAL_INSTANCE(dev)                                                                          \
 	((struct tach_reg *)((const struct tach_npcx_config *)(dev)->config)->base)

 /* Maximum count of prescaler */
 #define NPCX_TACHO_PRSC_MAX 0xff
 /* Maximum count of counter */
 #define NPCX_TACHO_CNT_MAX 0xffff
 /* Operation mode used for tachometer */
 #define NPCX_TACH_MDSEL 4
 /* Clock selection for tachometer */
 #define NPCX_CLKSEL_APBCLK 1
 #define NPCX_CLKSEL_LFCLK 4

 /* TACH inline local functions */
 static inline void tach_npcx_start_port_a(const struct device *dev)
 {
 	struct tach_npcx_data *const data = dev->data;
 	struct tach_reg *const inst = HAL_INSTANCE(dev);

 	/* Set the default value of counter and capture register of timer 1. */
 	inst->TCNT1 = NPCX_TACHO_CNT_MAX;
 	inst->TCRA  = NPCX_TACHO_CNT_MAX;

 	/*
 	 * Set the edge detection polarity of port A to falling (high-to-low
 	 * transition) and enable the functionality to capture TCNT1 into TCRA
 	 * and preset TCNT1 when event is triggered.
 	 */
 	inst->TMCTRL |= BIT(NPCX_TMCTRL_TAEN);

 	/* Enable input debounce logic into TA pin. */
 	inst->TCFG |= BIT(NPCX_TCFG_TADBEN);

 	/* Select clock source of timer 1 from no clock and start to count. */
 	SET_FIELD(inst->TCKC, NPCX_TCKC_C1CSEL_FIELD, data->input_clk == LFCLK
 		  ? NPCX_CLKSEL_LFCLK : NPCX_CLKSEL_APBCLK);
 }

 static inline void tach_npcx_start_port_b(const struct device *dev)
 {
 	struct tach_reg *const inst = HAL_INSTANCE(dev);
 	struct tach_npcx_data *const data = dev->data;

 	/* Set the default value of counter and capture register of timer 2. */
 	inst->TCNT2 = NPCX_TACHO_CNT_MAX;
 	inst->TCRB  = NPCX_TACHO_CNT_MAX;

 	/*
 	 * Set the edge detection polarity of port B to falling (high-to-low
 	 * transition) and enable the functionality to capture TCNT2 into TCRB
 	 * and preset TCNT2 when event is triggered.
 	 */
 	inst->TMCTRL |= BIT(NPCX_TMCTRL_TBEN);

 	/* Enable input debounce logic into TB pin. */
 	inst->TCFG |= BIT(NPCX_TCFG_TBDBEN);

 	/* Select clock source of timer 2 from no clock and start to count. */
 	SET_FIELD(inst->TCKC, NPCX_TCKC_C2CSEL_FIELD, data->input_clk == LFCLK
 		  ? NPCX_CLKSEL_LFCLK : NPCX_CLKSEL_APBCLK);
 }

 static inline bool tach_npcx_is_underflow(const struct device *dev)
 {
 	const struct tach_npcx_config *const config = dev->config;
 	struct tach_reg *const inst = HAL_INSTANCE(dev);

 	LOG_DBG("port A is underflow %d, port b is underflow %d",
 		IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TCPND),
 		IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TDPND));

 	/*
 	 * In mode 5, the flag TCPND or TDPND indicates the TCNT1 or TCNT2
 	 * is under underflow situation. (No edges are detected.)
 	 */
 	if (config->port == NPCX_TACH_PORT_A) {
 		return IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TCPND);
 	} else {
 		return IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TDPND);
 	}
 }

 static inline void tach_npcx_clear_underflow_flag(const struct device *dev)
 {
 	const struct tach_npcx_config *const config = dev->config;
 	struct tach_reg *const inst = HAL_INSTANCE(dev);

 	if (config->port == NPCX_TACH_PORT_A) {
 		inst->TECLR = BIT(NPCX_TECLR_TCCLR);
 	} else {
 		inst->TECLR = BIT(NPCX_TECLR_TDCLR);
 	}
 }

 static inline bool tach_npcx_is_captured(const struct device *dev)
 {
 	const struct tach_npcx_config *const config = dev->config;
 	struct tach_reg *const inst = HAL_INSTANCE(dev);

 	LOG_DBG("port A is captured %d, port b is captured %d",
 		IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TAPND),
 		IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TAPND));

 	/*
 	 * In mode 5, the flag TAPND or TBPND indicates a input captured on
 	 * TAn or TBn transition.
 	 */
 	if (config->port == NPCX_TACH_PORT_A) {
 		return IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TAPND);
 	} else {
 		return IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TBPND);
 	}
 }

 static inline void tach_npcx_clear_captured_flag(const struct device *dev)
 {
 	const struct tach_npcx_config *const config = dev->config;
 	struct tach_reg *const inst = HAL_INSTANCE(dev);

 	if (config->port == NPCX_TACH_PORT_A) {
 		inst->TECLR = BIT(NPCX_TECLR_TACLR);
 	} else {
 		inst->TECLR = BIT(NPCX_TECLR_TBCLR);
 	}
 }

 static inline uint16_t tach_npcx_get_captured_count(const struct device *dev)
 {
 	const struct tach_npcx_config *const config = dev->config;
 	struct tach_reg *const inst = HAL_INSTANCE(dev);

 	if (config->port == NPCX_TACH_PORT_A) {
 		return inst->TCRA;
 	} else {
 		return inst->TCRB;
 	}
 }

 /* TACH local functions */
 static int tach_npcx_configure(const struct device *dev)
 {
 	const struct tach_npcx_config *const config = dev->config;
 	struct tach_npcx_data *const data = dev->data;
 	struct tach_reg *const inst = HAL_INSTANCE(dev);

 	/* Set mode 5 to tachometer module */
 	SET_FIELD(inst->TMCTRL, NPCX_TMCTRL_MDSEL_FIELD, NPCX_TACH_MDSEL);

 	/* Configure clock module and its frequency of tachometer */
 	if (config->sample_clk == 0) {
 		return -EINVAL;
 	} else if (data->input_clk == LFCLK) {
 		/* Enable low power mode */
 		inst->TCKC |= BIT(NPCX_TCKC_LOW_PWR);
 		if (config->sample_clk != data->input_clk) {
 			LOG_ERR("%s operate freq is %d not fixed to 32kHz",
 				dev->name, data->input_clk);
 			return -EINVAL;
 		}
 	} else {
 		/* Configure sampling freq by setting prescaler of APB1 */
 		uint16_t prescaler = data->input_clk / config->sample_clk;

 		if (data->input_clk > config->sample_clk) {
 			LOG_ERR("%s operate freq exceeds APB1 clock",
 				dev->name);
 			return -EINVAL;
 		}
 		inst->TPRSC = MIN(NPCX_TACHO_PRSC_MAX, MAX(prescaler, 1));
 	}

 	return 0;
 }

 /* TACH api functions */
 int tach_npcx_sample_fetch(const struct device *dev, enum sensor_channel chan)
 {
 	ARG_UNUSED(chan);
 	struct tach_npcx_data *const data = dev->data;

 	/* Check whether underflow flag of tachometer is occurred */
 	if (tach_npcx_is_underflow(dev)) {
 		/* Clear pending flags */
 		tach_npcx_clear_underflow_flag(dev);

 		LOG_INF("%s is underflow!", dev->name);
 		data->capture = 0;

 		return 0;
 	}

 	/* Check whether capture flag of tachometer is set */
 	if (tach_npcx_is_captured(dev)) {
 		/* Clear pending flags */
 		tach_npcx_clear_captured_flag(dev);
 		/* Save captured count */
 		data->capture = NPCX_TACHO_CNT_MAX -
 					tach_npcx_get_captured_count(dev);
 	}

 	return 0;
 }

 static int tach_npcx_channel_get(const struct device *dev,
 				enum sensor_channel chan,
 				struct sensor_value *val)
 {
 	const struct tach_npcx_config *const config = dev->config;
 	struct tach_npcx_data *const data = dev->data;

 	if (chan != SENSOR_CHAN_RPM) {
 		return -ENOTSUP;
 	}

 	if (data->capture > 0) {
 		/*
 		 * RPM = (f * 60) / (n * TACH)
 		 *   n = Pulses per round
 		 *   f = Tachometer operation frequency (Hz)
 		 *   TACH = Captured counts of tachometer
 		 */
 		val->val1 = (config->sample_clk * 60) /
 			(config->pulses_per_round * data->capture);
 	} else {
 		val->val1 = 0U;
 	}

 	val->val2 = 0U;

 	return 0;
 }


 /* TACH driver registration */
 static int tach_npcx_init(const struct device *dev)
 {
 	const struct tach_npcx_config *const config = dev->config;
 	struct tach_npcx_data *const data = dev->data;
 	const struct device *const clk_dev = DEVICE_DT_GET(NPCX_CLK_CTRL_NODE);
 	int ret;

 	/* Turn on device clock first and get source clock freq. */
 	ret = clock_control_on(clk_dev, (clock_control_subsys_t *)
 							&config->clk_cfg);
 	if (ret < 0) {
 		LOG_ERR("Turn on tachometer clock fail %d", ret);
 		return ret;
 	}

 	ret = clock_control_get_rate(clk_dev, (clock_control_subsys_t *)
 					&config->clk_cfg, &data->input_clk);
 	if (ret < 0) {
 		LOG_ERR("Get tachometer clock rate error %d", ret);
 		return ret;
 	}

 	/* Configure pin-mux for tachometer device */
 	ret = pinctrl_apply_state(config->pcfg, PINCTRL_STATE_DEFAULT);
 	if (ret < 0) {
 		LOG_ERR("Tacho pinctrl setup failed (%d)", ret);
 		return ret;
 	}


 	/* Configure tachometer and its operate freq. */
 	ret = tach_npcx_configure(dev);
 	if (ret < 0) {
 		LOG_ERR("Config tachometer port %d failed", config->port);
 		return ret;
 	}

 	/* Start tachometer sensor */
 	if (config->port == NPCX_TACH_PORT_A) {
 		tach_npcx_start_port_a(dev);
 	} else if (config->port == NPCX_TACH_PORT_B) {
 		tach_npcx_start_port_b(dev);
 	} else {
 		return -EINVAL;
 	}

 	return 0;
 }

 static const struct sensor_driver_api tach_npcx_driver_api = {
 	.sample_fetch = tach_npcx_sample_fetch,
 	.channel_get = tach_npcx_channel_get,
 };

 #define NPCX_TACH_INIT(inst)                                                   \
 	PINCTRL_DT_INST_DEFINE(inst);					       \
 									       \
 	static const struct tach_npcx_config tach_cfg_##inst = {               \
 		.base = DT_INST_REG_ADDR(inst),                                \
 		.clk_cfg = NPCX_DT_CLK_CFG_ITEM(inst),                         \
 		.sample_clk = DT_INST_PROP(inst, sample_clk),                  \
 		.port = DT_INST_PROP(inst, port),                              \
 		.pulses_per_round = DT_INST_PROP(inst, pulses_per_round),      \
 		.pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(inst),                  \
 	};                                                                     \
 									       \
 	static struct tach_npcx_data tach_data_##inst;                         \
 									       \
 	DEVICE_DT_INST_DEFINE(inst,                                            \
 			      tach_npcx_init,                                  \
 			      NULL,                                            \
 			      &tach_data_##inst,                               \
 			      &tach_cfg_##inst,                                \
 			      POST_KERNEL,                                     \
 			      CONFIG_SENSOR_INIT_PRIORITY,                     \
 			      &tach_npcx_driver_api);

 DT_INST_FOREACH_STATUS_OKAY(NPCX_TACH_INIT)
	/*
	* Copyright (c) 2021 Nuvoton Technology Corporation.
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#define DT_DRV_COMPAT nuvoton_npcx_tach

	/**
	* @file
	* @brief Nuvoton NPCX tachometer sensor module driver
	*
	* This file contains a driver for the tachometer sensor module which contains
	* two independent timers (counter 1 and 2). They are used to capture a counter
	* value when the signals via external pins match the condition. The following
	* is block diagram of this module when it set to mode 5.
	*
	* \| Capture A
	* \| \| +-----------+ TA Pin
	* +-----------+ \| +-----+-----+ \| _ _ \| \|
	* APB_CLK-->\| Prescaler \|--->\|---+--->\| Counter 1 \|<--\| _\| \|_\| \|_ \|<--+
	* +-----------+ \| \| +-----------+ +-----------+
	* \| CLK_SEL Edge Detection
	* \| Capture B
	* LFCLK--------------------->\| \| +-----------+ TB Pin
	* \| +-----+-----+ \| _ _ \| \|
	* \|---+--->\| Counter 2 \|<--\| _\| \|_\| \|_ \|<--+
	* \| \| +-----------+ +-----------+
	* \| CLK_SEL Edge Detection
	* \|
	* \| TACH_CLK
	* +----------
	* (NPCX Tachometer Mode 5, Dual-Independent Input Capture)
	*
	* This mode is used to measure either the frequency of two external clocks
	* (via TA or TB pins) that are slower than TACH_CLK. A transition event (rising
	* or falling edge) received on TAn/TBn pin causes a transfer of timer 1/2
	* contents to Capture register and reload counter. Based on this value, we can
	* compute the current RPM of external signal from encoders.
	*/

	#include <errno.h>
	#include <zephyr/device.h>
	#include <zephyr/drivers/clock_control.h>
	#include <zephyr/drivers/pinctrl.h>
	#include <zephyr/drivers/sensor.h>
	#include <zephyr/dt-bindings/sensor/npcx_tach.h>
	#include <soc.h>
	#include <zephyr/logging/log.h>

	LOG_MODULE_REGISTER(tach_npcx, CONFIG_SENSOR_LOG_LEVEL);

	/* Device config */
	struct tach_npcx_config {
	/* tachometer controller base address */
	uintptr_t base;
	/* clock configuration */
	struct npcx_clk_cfg clk_cfg;
	/* sampling clock frequency of tachometer */
	uint32_t sample_clk;
	/* selected port of tachometer */
	int port;
	/* number of pulses (holes) per round of tachometer's input (encoder) */
	int pulses_per_round;
	/* pinmux configuration */
	const struct pinctrl_dev_config *pcfg;
	};

	/* Driver data */
	struct tach_npcx_data {
	/* Input clock for tachometers */
	uint32_t input_clk;
	/* Captured counts of tachometer */
	uint32_t capture;
	};

	/* Driver convenience defines */
	#define HAL_INSTANCE(dev) \
	((struct tach_reg )((const struct tach_npcx_config )(dev)->config)->base)

	/* Maximum count of prescaler */
	#define NPCX_TACHO_PRSC_MAX 0xff
	/* Maximum count of counter */
	#define NPCX_TACHO_CNT_MAX 0xffff
	/* Operation mode used for tachometer */
	#define NPCX_TACH_MDSEL 4
	/* Clock selection for tachometer */
	#define NPCX_CLKSEL_APBCLK 1
	#define NPCX_CLKSEL_LFCLK 4

	/* TACH inline local functions */
	static inline void tach_npcx_start_port_a(const struct device *dev)
	{
	struct tach_npcx_data *const data = dev->data;
	struct tach_reg *const inst = HAL_INSTANCE(dev);

	/* Set the default value of counter and capture register of timer 1. */
	inst->TCNT1 = NPCX_TACHO_CNT_MAX;
	inst->TCRA = NPCX_TACHO_CNT_MAX;

	/*
	* Set the edge detection polarity of port A to falling (high-to-low
	* transition) and enable the functionality to capture TCNT1 into TCRA
	* and preset TCNT1 when event is triggered.
	*/
	inst->TMCTRL \|= BIT(NPCX_TMCTRL_TAEN);

	/* Enable input debounce logic into TA pin. */
	inst->TCFG \|= BIT(NPCX_TCFG_TADBEN);

	/* Select clock source of timer 1 from no clock and start to count. */
	SET_FIELD(inst->TCKC, NPCX_TCKC_C1CSEL_FIELD, data->input_clk == LFCLK
	? NPCX_CLKSEL_LFCLK : NPCX_CLKSEL_APBCLK);
	}

	static inline void tach_npcx_start_port_b(const struct device *dev)
	{
	struct tach_reg *const inst = HAL_INSTANCE(dev);
	struct tach_npcx_data *const data = dev->data;

	/* Set the default value of counter and capture register of timer 2. */
	inst->TCNT2 = NPCX_TACHO_CNT_MAX;
	inst->TCRB = NPCX_TACHO_CNT_MAX;

	/*
	* Set the edge detection polarity of port B to falling (high-to-low
	* transition) and enable the functionality to capture TCNT2 into TCRB
	* and preset TCNT2 when event is triggered.
	*/
	inst->TMCTRL \|= BIT(NPCX_TMCTRL_TBEN);

	/* Enable input debounce logic into TB pin. */
	inst->TCFG \|= BIT(NPCX_TCFG_TBDBEN);

	/* Select clock source of timer 2 from no clock and start to count. */
	SET_FIELD(inst->TCKC, NPCX_TCKC_C2CSEL_FIELD, data->input_clk == LFCLK
	? NPCX_CLKSEL_LFCLK : NPCX_CLKSEL_APBCLK);
	}

	static inline bool tach_npcx_is_underflow(const struct device *dev)
	{
	const struct tach_npcx_config *const config = dev->config;
	struct tach_reg *const inst = HAL_INSTANCE(dev);

	LOG_DBG("port A is underflow %d, port b is underflow %d",
	IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TCPND),
	IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TDPND));

	/*
	* In mode 5, the flag TCPND or TDPND indicates the TCNT1 or TCNT2
	* is under underflow situation. (No edges are detected.)
	*/
	if (config->port == NPCX_TACH_PORT_A) {
	return IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TCPND);
	} else {
	return IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TDPND);
	}
	}

	static inline void tach_npcx_clear_underflow_flag(const struct device *dev)
	{
	const struct tach_npcx_config *const config = dev->config;
	struct tach_reg *const inst = HAL_INSTANCE(dev);

	if (config->port == NPCX_TACH_PORT_A) {
	inst->TECLR = BIT(NPCX_TECLR_TCCLR);
	} else {
	inst->TECLR = BIT(NPCX_TECLR_TDCLR);
	}
	}

	static inline bool tach_npcx_is_captured(const struct device *dev)
	{
	const struct tach_npcx_config *const config = dev->config;
	struct tach_reg *const inst = HAL_INSTANCE(dev);

	LOG_DBG("port A is captured %d, port b is captured %d",
	IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TAPND),
	IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TAPND));

	/*
	* In mode 5, the flag TAPND or TBPND indicates a input captured on
	* TAn or TBn transition.
	*/
	if (config->port == NPCX_TACH_PORT_A) {
	return IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TAPND);
	} else {
	return IS_BIT_SET(inst->TECTRL, NPCX_TECTRL_TBPND);
	}
	}

	static inline void tach_npcx_clear_captured_flag(const struct device *dev)
	{
	const struct tach_npcx_config *const config = dev->config;
	struct tach_reg *const inst = HAL_INSTANCE(dev);

	if (config->port == NPCX_TACH_PORT_A) {
	inst->TECLR = BIT(NPCX_TECLR_TACLR);
	} else {
	inst->TECLR = BIT(NPCX_TECLR_TBCLR);
	}
	}

	static inline uint16_t tach_npcx_get_captured_count(const struct device *dev)
	{
	const struct tach_npcx_config *const config = dev->config;
	struct tach_reg *const inst = HAL_INSTANCE(dev);

	if (config->port == NPCX_TACH_PORT_A) {
	return inst->TCRA;
	} else {
	return inst->TCRB;
	}
	}

	/* TACH local functions */
	static int tach_npcx_configure(const struct device *dev)
	{
	const struct tach_npcx_config *const config = dev->config;
	struct tach_npcx_data *const data = dev->data;
	struct tach_reg *const inst = HAL_INSTANCE(dev);

	/* Set mode 5 to tachometer module */
	SET_FIELD(inst->TMCTRL, NPCX_TMCTRL_MDSEL_FIELD, NPCX_TACH_MDSEL);

	/* Configure clock module and its frequency of tachometer */
	if (config->sample_clk == 0) {
	return -EINVAL;
	} else if (data->input_clk == LFCLK) {
	/* Enable low power mode */
	inst->TCKC \|= BIT(NPCX_TCKC_LOW_PWR);
	if (config->sample_clk != data->input_clk) {
	LOG_ERR("%s operate freq is %d not fixed to 32kHz",
	dev->name, data->input_clk);
	return -EINVAL;
	}
	} else {
	/* Configure sampling freq by setting prescaler of APB1 */
	uint16_t prescaler = data->input_clk / config->sample_clk;

	if (data->input_clk > config->sample_clk) {
	LOG_ERR("%s operate freq exceeds APB1 clock",
	dev->name);
	return -EINVAL;
	}
	inst->TPRSC = MIN(NPCX_TACHO_PRSC_MAX, MAX(prescaler, 1));
	}

	return 0;
	}

	/* TACH api functions */
	int tach_npcx_sample_fetch(const struct device *dev, enum sensor_channel chan)
	{
	ARG_UNUSED(chan);
	struct tach_npcx_data *const data = dev->data;

	/* Check whether underflow flag of tachometer is occurred */
	if (tach_npcx_is_underflow(dev)) {
	/* Clear pending flags */
	tach_npcx_clear_underflow_flag(dev);

	LOG_INF("%s is underflow!", dev->name);
	data->capture = 0;

	return 0;
	}

	/* Check whether capture flag of tachometer is set */
	if (tach_npcx_is_captured(dev)) {
	/* Clear pending flags */
	tach_npcx_clear_captured_flag(dev);
	/* Save captured count */
	data->capture = NPCX_TACHO_CNT_MAX -
	tach_npcx_get_captured_count(dev);
	}

	return 0;
	}

	static int tach_npcx_channel_get(const struct device *dev,
	enum sensor_channel chan,
	struct sensor_value *val)
	{
	const struct tach_npcx_config *const config = dev->config;
	struct tach_npcx_data *const data = dev->data;

	if (chan != SENSOR_CHAN_RPM) {
	return -ENOTSUP;
	}

	if (data->capture > 0) {
	/*
	* RPM = (f * 60) / (n * TACH)
	* n = Pulses per round
	* f = Tachometer operation frequency (Hz)
	* TACH = Captured counts of tachometer
	*/
	val->val1 = (config->sample_clk * 60) /
	(config->pulses_per_round * data->capture);
	} else {
	val->val1 = 0U;
	}

	val->val2 = 0U;

	return 0;
	}


	/* TACH driver registration */
	static int tach_npcx_init(const struct device *dev)
	{
	const struct tach_npcx_config *const config = dev->config;
	struct tach_npcx_data *const data = dev->data;
	const struct device *const clk_dev = DEVICE_DT_GET(NPCX_CLK_CTRL_NODE);
	int ret;

	/* Turn on device clock first and get source clock freq. */
	ret = clock_control_on(clk_dev, (clock_control_subsys_t *)
	&config->clk_cfg);
	if (ret < 0) {
	LOG_ERR("Turn on tachometer clock fail %d", ret);
	return ret;
	}

	ret = clock_control_get_rate(clk_dev, (clock_control_subsys_t *)
	&config->clk_cfg, &data->input_clk);
	if (ret < 0) {
	LOG_ERR("Get tachometer clock rate error %d", ret);
	return ret;
	}

	/* Configure pin-mux for tachometer device */
	ret = pinctrl_apply_state(config->pcfg, PINCTRL_STATE_DEFAULT);
	if (ret < 0) {
	LOG_ERR("Tacho pinctrl setup failed (%d)", ret);
	return ret;
	}


	/* Configure tachometer and its operate freq. */
	ret = tach_npcx_configure(dev);
	if (ret < 0) {
	LOG_ERR("Config tachometer port %d failed", config->port);
	return ret;
	}

	/* Start tachometer sensor */
	if (config->port == NPCX_TACH_PORT_A) {
	tach_npcx_start_port_a(dev);
	} else if (config->port == NPCX_TACH_PORT_B) {
	tach_npcx_start_port_b(dev);
	} else {
	return -EINVAL;
	}

	return 0;
	}

	static const struct sensor_driver_api tach_npcx_driver_api = {
	.sample_fetch = tach_npcx_sample_fetch,
	.channel_get = tach_npcx_channel_get,
	};

	#define NPCX_TACH_INIT(inst) \
	PINCTRL_DT_INST_DEFINE(inst); \
	\
	static const struct tach_npcx_config tach_cfg_##inst = { \
	.base = DT_INST_REG_ADDR(inst), \
	.clk_cfg = NPCX_DT_CLK_CFG_ITEM(inst), \
	.sample_clk = DT_INST_PROP(inst, sample_clk), \
	.port = DT_INST_PROP(inst, port), \
	.pulses_per_round = DT_INST_PROP(inst, pulses_per_round), \
	.pcfg = PINCTRL_DT_INST_DEV_CONFIG_GET(inst), \
	}; \
	\
	static struct tach_npcx_data tach_data_##inst; \
	\
	DEVICE_DT_INST_DEFINE(inst, \
	tach_npcx_init, \
	NULL, \
	&tach_data_##inst, \
	&tach_cfg_##inst, \
	POST_KERNEL, \
	CONFIG_SENSOR_INIT_PRIORITY, \
	&tach_npcx_driver_api);

	DT_INST_FOREACH_STATUS_OKAY(NPCX_TACH_INIT)