drivers/gpio/gpio_fxl6408.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2021 Abel Sensors
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #include <zephyr/drivers/gpio.h>
 #include <zephyr/drivers/i2c.h>
 #include "gpio_utils.h"
 #include <zephyr/logging/log.h>

 LOG_MODULE_REGISTER(fxl6408, CONFIG_FXL6408_LOG_LEVEL);
 #define DT_DRV_COMPAT             fcs_fxl6408

 /* Register definitions */
 #define REG_DEVICE_ID_CTRL        0x01
 #define REG_DIRECTION             0x03
 #define REG_OUTPUT                0x05
 #define REG_OUTPUT_HIGH_Z         0x07
 #define REG_INPUT_DEFAULT_STATE   0x09
 #define REG_PUD_EN                0x0B
 #define REG_PUD_SEL               0x0D
 #define REG_INPUT_VALUE           0x0F
 #define REG_INT_MASK              0x11
 #define REG_INT_STATUS            0x13

 #define SUPPORTED_FLAGS (GPIO_INPUT | GPIO_OUTPUT | GPIO_OUTPUT_INIT_LOW |\
 			GPIO_OUTPUT_INIT_HIGH | GPIO_PULL_DOWN | GPIO_PULL_UP |\
 			GPIO_ACTIVE_HIGH | GPIO_ACTIVE_LOW)

 /** Configuration data*/
 struct gpio_fxl6408_config {
 	/* gpio_driver_config needs to be first */
 	struct gpio_driver_config common;

 	/** Master I2C device */
 	const struct device *i2c_master;

 	/** The slave address of the chip */
 	uint16_t i2c_slave_addr;
 };

 /** Runtime driver data */
 struct gpio_fxl6408_drv_data {
 	/* gpio_driver_data needs to be first */
 	struct gpio_driver_data common;

 	struct {
 		uint8_t input;
 		uint8_t output;
 		uint8_t dir;
 		uint8_t high_z;
 		uint8_t pud_en;
 		uint8_t pud_sel;
 	} reg_cache;

 	struct k_sem lock;
 };

 /**
  * @brief Read the port of certain register function.
  *
  * @param dev Device struct of the FXL6408.
  * @param reg Register to read.
  * @param cache Pointer to the cache to be updated after successful read.
  *
  * @return 0 if successful, failed otherwise.
  */
 static int read_port_regs(const struct device *dev, uint8_t reg, uint8_t *cache)
 {
 	const struct gpio_fxl6408_config *const config = dev->config;
 	const struct device *i2c_master = config->i2c_master;
 	uint16_t i2c_addr = config->i2c_slave_addr;
 	uint8_t port_data;
 	int ret;

 	ret = i2c_reg_read_byte(i2c_master, i2c_addr, reg, &port_data);
 	if (ret != 0) {
 		LOG_ERR("Error reading register 0x%X (%d)", reg, ret);
 		return ret;
 	}
 	*cache = port_data;
 	LOG_DBG("Read: REG[0x%X] = 0x%X", reg, *cache);

 	return ret;
 }

 /**
  *  @brief Write to the port registers of certain register function.
  *
  * @param dev Device struct of the FXL6408.
  * @param reg Register to write into. Possible values:  REG_DEVICE_ID_CTRL,
  * REG_OUTPUT, REG_DIRECTION, REG_PUD_SEL, REG_PUD_EN, REG_OUTPUT_HIGH_Z and
  * REG_INPUT_DEFAULT.
  * @param cache Pointer to the cache to be updated after successful write.
  * @param value New value to set.
  *
  * @return 0 if successful, failed otherwise.
  */
 static int write_port_regs(const struct device *dev, uint8_t reg,
 			   uint8_t *cache, uint8_t value)
 {
 	const struct gpio_fxl6408_config *const config = dev->config;
 	const struct device *i2c_master = config->i2c_master;
 	int ret = 0;

 	if (*cache != value) {
 		ret = i2c_reg_write_byte(i2c_master, config->i2c_slave_addr,
 			reg, value);
 		if (ret != 0) {
 			LOG_ERR("error writing to register 0x%X (%d)",
 				reg, ret);
 			return ret;
 		}
 		*cache = value;
 		LOG_DBG("Write: REG[0x%X] = 0x%X", reg, *cache);
 	}

 	return ret;
 }

 static inline int update_input_regs(const struct device *dev, uint8_t *buf)
 {
 	struct gpio_fxl6408_drv_data *const drv_data =
 		(struct gpio_fxl6408_drv_data *const)dev->data;
 	int ret = read_port_regs(dev, REG_INPUT_VALUE,
 				 &drv_data->reg_cache.input);
 	*buf = drv_data->reg_cache.input;

 	return ret;
 }

 static inline int update_output_regs(const struct device *dev, uint8_t value)
 {
 	struct gpio_fxl6408_drv_data *const drv_data =
 		(struct gpio_fxl6408_drv_data *const)dev->data;

 	return write_port_regs(dev, REG_OUTPUT,
 			&drv_data->reg_cache.output, value);
 }

 static inline int update_high_z_regs(const struct device *dev, uint8_t value)
 {
 	struct gpio_fxl6408_drv_data *const drv_data =
 		(struct gpio_fxl6408_drv_data *const)dev->data;

 	return write_port_regs(dev, REG_OUTPUT_HIGH_Z,
 			&drv_data->reg_cache.high_z, value);
 }

 static inline int update_direction_regs(const struct device *dev, uint8_t value)
 {
 	struct gpio_fxl6408_drv_data *const drv_data =
 		(struct gpio_fxl6408_drv_data *const)dev->data;

 	return write_port_regs(dev, REG_DIRECTION,
 			&drv_data->reg_cache.dir, value);
 }

 static inline int update_pul_sel_regs(const struct device *dev, uint8_t value)
 {
 	struct gpio_fxl6408_drv_data *const drv_data =
 		(struct gpio_fxl6408_drv_data *const)dev->data;

 	return write_port_regs(dev, REG_PUD_SEL,
 			&drv_data->reg_cache.pud_sel, value);
 }

 static inline int update_pul_en_regs(const struct device *dev, uint8_t value)
 {
 	struct gpio_fxl6408_drv_data *const drv_data =
 		(struct gpio_fxl6408_drv_data *const)dev->data;

 	return write_port_regs(dev, REG_PUD_EN,
 			&drv_data->reg_cache.pud_en, value);
 }

 static int setup_pin_dir(const struct device *dev, uint32_t pin, int flags)
 {
 	struct gpio_fxl6408_drv_data *const drv_data =
 		(struct gpio_fxl6408_drv_data *const)dev->data;
 	uint8_t reg_dir = drv_data->reg_cache.dir;
 	uint8_t reg_out = drv_data->reg_cache.output;
 	uint8_t reg_high_z = drv_data->reg_cache.high_z;
 	int ret;

 	if (((flags & GPIO_INPUT) != 0) && ((flags & GPIO_OUTPUT) != 0)) {
 		return -ENOTSUP;
 	}

 	/* Update the driver data to the actual situation of the FXL6408 */
 	if (flags & GPIO_OUTPUT) {
 		if ((flags & GPIO_OUTPUT_INIT_HIGH)) {
 			reg_out |= BIT(pin);
 		} else if ((flags & GPIO_OUTPUT_INIT_LOW)) {
 			reg_out &= ~BIT(pin);
 		}
 		reg_dir |= BIT(pin);
 		reg_high_z &= ~BIT(pin);
 	} else if (flags & GPIO_INPUT) {
 		reg_dir &= ~BIT(pin);
 		reg_high_z &= ~BIT(pin);
 	} else {
 		reg_high_z |= BIT(pin);
 		reg_dir |= BIT(pin);
 	}

 	ret = update_output_regs(dev, reg_out);
 	if (ret != 0) {
 		return ret;
 	}

 	ret = update_high_z_regs(dev, reg_high_z);
 	if (ret != 0) {
 		return ret;
 	}

 	ret = update_direction_regs(dev, reg_dir);
 	return ret;
 }

 /**
  * @brief Setup the pin pull up/pull down status
  *
  * @param dev Device struct of the FXL6408
  * @param pin The pin number
  * @param flags Flags of pin or port
  *
  * @return 0 if successful, failed otherwise
  */
 static int setup_pin_pullupdown(const struct device *dev, uint32_t pin,
 				int flags)
 {
 	struct gpio_fxl6408_drv_data *const drv_data =
 		(struct gpio_fxl6408_drv_data *const)dev->data;
 	uint8_t reg_pud;
 	int ret;

 	/* If disabling pull up/down, there is no need to set the selection
 	 * register. Just go straight to disabling.
 	 */
 	if ((flags & (GPIO_PULL_UP | GPIO_PULL_DOWN)) != 0U) {
 		/* Setup pin pull up or pull down */
 		reg_pud = drv_data->reg_cache.pud_sel;

 		/* Pull down == 0, pull up == 1 */
 		WRITE_BIT(reg_pud, pin, (flags & GPIO_PULL_UP) != 0U);

 		ret = update_pul_sel_regs(dev, reg_pud);
 		if (ret != 0) {
 			return ret;
 		}
 	}

 	/* Enable/disable pull up/down */
 	reg_pud = drv_data->reg_cache.pud_en;

 	WRITE_BIT(reg_pud, pin,
 		  (flags & (GPIO_PULL_UP | GPIO_PULL_DOWN)) != 0U);

 	ret = update_pul_en_regs(dev, reg_pud);
 	return ret;
 }

 static int gpio_fxl6408_pin_config(const struct device *dev, gpio_pin_t pin,
 				   gpio_flags_t flags)
 {
 	struct gpio_fxl6408_drv_data *const drv_data =
 		(struct gpio_fxl6408_drv_data *const)dev->data;
 	int ret;

 	/* Check if supported flag is set */
 	if ((flags & ~SUPPORTED_FLAGS) != 0) {
 		return -ENOTSUP;
 	}

 	/* Can't do I2C bus operations from an ISR */
 	if (k_is_in_isr()) {
 		return -EWOULDBLOCK;
 	}
 	k_sem_take(&drv_data->lock, K_FOREVER);

 	ret = setup_pin_dir(dev, pin, flags);
 	if (ret != 0) {
 		LOG_ERR("error setting pin direction (%d)", ret);
 		goto done;
 	}

 	ret = setup_pin_pullupdown(dev, pin, flags);
 	if (ret) {
 		LOG_ERR("error setting pin pull up/down (%d)", ret);
 		goto done;
 	}

 done:
 	k_sem_give(&drv_data->lock);
 	return ret;
 }

 static int gpio_fxl6408_port_get_raw(const struct device *dev, uint32_t *value)
 {
 	struct gpio_fxl6408_drv_data *const drv_data =
 		(struct gpio_fxl6408_drv_data *const)dev->data;
 	uint8_t buf = 0;
 	int ret = 0;

 	/* Can't do I2C bus operations from an ISR */
 	if (k_is_in_isr()) {
 		return -EWOULDBLOCK;
 	}

 	k_sem_take(&drv_data->lock, K_FOREVER);

 	ret = update_input_regs(dev, &buf);
 	if (ret != 0) {
 		goto done;
 	}
 	*value = buf;

 done:
 	k_sem_give(&drv_data->lock);
 	return ret;
 }

 static int gpio_fxl6408_port_set_masked_raw(const struct device *dev,
 						uint32_t mask, uint32_t value)
 {
 	struct gpio_fxl6408_drv_data *const drv_data =
 		(struct gpio_fxl6408_drv_data *const)dev->data;
 	uint8_t reg_out;
 	int ret;

 	/* Can't do I2C bus operations from an ISR */
 	if (k_is_in_isr()) {
 		return -EWOULDBLOCK;
 	}

 	k_sem_take(&drv_data->lock, K_FOREVER);

 	reg_out = drv_data->reg_cache.output;
 	reg_out = (reg_out & ~mask) | (mask & value);

 	ret = update_output_regs(dev, reg_out);

 	k_sem_give(&drv_data->lock);

 	return ret;
 }

 static int gpio_fxl6408_port_set_bits_raw(const struct device *dev,
 					  uint32_t mask)
 {
 	return gpio_fxl6408_port_set_masked_raw(dev, mask, mask);
 }

 static int gpio_fxl6408_port_clear_bits_raw(const struct device *dev,
 						uint32_t mask)
 {
 	return gpio_fxl6408_port_set_masked_raw(dev, mask, 0);
 }

 static int gpio_fxl6408_port_toggle_bits(const struct device *dev,
 					 uint32_t mask)
 {
 	struct gpio_fxl6408_drv_data *const drv_data =
 		(struct gpio_fxl6408_drv_data *const)dev->data;
 	uint8_t reg_out;
 	int ret;

 	/* Can't do I2C bus operations from an ISR */
 	if (k_is_in_isr()) {
 		return -EWOULDBLOCK;
 	}

 	k_sem_take(&drv_data->lock, K_FOREVER);

 	reg_out = drv_data->reg_cache.output;
 	reg_out ^= mask;
 	ret = update_output_regs(dev, reg_out);

 	k_sem_give(&drv_data->lock);

 	return ret;
 }

 static int gpio_fxl6408_pin_interrupt_configure(const struct device *port,
 						gpio_pin_t pin,
 						enum gpio_int_mode mode,
 						enum gpio_int_trig trig)
 {
 	LOG_DBG("Pin interrupts not supported.");
 	return -ENOTSUP;
 }

 int gpio_fxl6408_init(const struct device *dev)
 {
 	struct gpio_fxl6408_drv_data *const drv_data =
 		(struct gpio_fxl6408_drv_data *const)dev->data;
 	const struct gpio_fxl6408_config *const config = dev->config;

 	if (!device_is_ready(config->i2c_master)) {
 		LOG_ERR("%s is not ready", config->i2c_master->name);
 		return -ENODEV;
 	}

 	k_sem_init(&drv_data->lock, 1, 1);

 	return 0;
 }

 static const struct gpio_driver_api gpio_fxl_driver = {
 	.pin_configure = gpio_fxl6408_pin_config,
 	.port_get_raw = gpio_fxl6408_port_get_raw,
 	.port_set_masked_raw = gpio_fxl6408_port_set_masked_raw,
 	.port_set_bits_raw = gpio_fxl6408_port_set_bits_raw,
 	.port_clear_bits_raw = gpio_fxl6408_port_clear_bits_raw,
 	.port_toggle_bits = gpio_fxl6408_port_toggle_bits,
 	.pin_interrupt_configure = gpio_fxl6408_pin_interrupt_configure
 };

 #define GPIO_FXL6408_DEVICE_INSTANCE(inst)                                     \
 	static const struct gpio_fxl6408_config gpio_fxl6408_##inst##_cfg = {  \
 		.common = {                                                    \
 			.port_pin_mask = GPIO_PORT_PIN_MASK_FROM_DT_INST(inst),\
 		},                                                             \
 		.i2c_slave_addr = DT_INST_REG_ADDR(inst),                      \
 		.i2c_master = DEVICE_DT_GET(DT_INST_BUS(inst))                 \
 	};                                                                     \
 \
 	static struct gpio_fxl6408_drv_data gpio_fxl6408_##inst##_drvdata = {  \
 		.reg_cache = {                                                 \
 			.input = 0x0,                                          \
 			.output = 0x00,                                        \
 			.dir = 0x0,                                            \
 			.high_z = 0xFF,                                        \
 			.pud_en = 0xFF,                                        \
 			.pud_sel = 0x0                                         \
 		}                                                              \
 	};                                                                     \
 \
 	DEVICE_DT_INST_DEFINE(inst, gpio_fxl6408_init, NULL,                   \
 		&gpio_fxl6408_##inst##_drvdata,                                \
 		&gpio_fxl6408_##inst##_cfg, POST_KERNEL,                       \
 		CONFIG_GPIO_FXL6408_INIT_PRIORITY,                             \
 		&gpio_fxl_driver);

 DT_INST_FOREACH_STATUS_OKAY(GPIO_FXL6408_DEVICE_INSTANCE)
	/*
	* Copyright (c) 2021 Abel Sensors
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#include <zephyr/drivers/gpio.h>
	#include <zephyr/drivers/i2c.h>
	#include "gpio_utils.h"
	#include <zephyr/logging/log.h>

	LOG_MODULE_REGISTER(fxl6408, CONFIG_FXL6408_LOG_LEVEL);
	#define DT_DRV_COMPAT fcs_fxl6408

	/* Register definitions */
	#define REG_DEVICE_ID_CTRL 0x01
	#define REG_DIRECTION 0x03
	#define REG_OUTPUT 0x05
	#define REG_OUTPUT_HIGH_Z 0x07
	#define REG_INPUT_DEFAULT_STATE 0x09
	#define REG_PUD_EN 0x0B
	#define REG_PUD_SEL 0x0D
	#define REG_INPUT_VALUE 0x0F
	#define REG_INT_MASK 0x11
	#define REG_INT_STATUS 0x13

	#define SUPPORTED_FLAGS (GPIO_INPUT \| GPIO_OUTPUT \| GPIO_OUTPUT_INIT_LOW \|\
	GPIO_OUTPUT_INIT_HIGH \| GPIO_PULL_DOWN \| GPIO_PULL_UP \|\
	GPIO_ACTIVE_HIGH \| GPIO_ACTIVE_LOW)

	/** Configuration data*/
	struct gpio_fxl6408_config {
	/* gpio_driver_config needs to be first */
	struct gpio_driver_config common;

	/** Master I2C device */
	const struct device *i2c_master;

	/** The slave address of the chip */
	uint16_t i2c_slave_addr;
	};

	/** Runtime driver data */
	struct gpio_fxl6408_drv_data {
	/* gpio_driver_data needs to be first */
	struct gpio_driver_data common;

	struct {
	uint8_t input;
	uint8_t output;
	uint8_t dir;
	uint8_t high_z;
	uint8_t pud_en;
	uint8_t pud_sel;
	} reg_cache;

	struct k_sem lock;
	};

	/**
	* @brief Read the port of certain register function.
	*
	* @param dev Device struct of the FXL6408.
	* @param reg Register to read.
	* @param cache Pointer to the cache to be updated after successful read.
	*
	* @return 0 if successful, failed otherwise.
	*/
	static int read_port_regs(const struct device dev, uint8_t reg, uint8_t cache)
	{
	const struct gpio_fxl6408_config *const config = dev->config;
	const struct device *i2c_master = config->i2c_master;
	uint16_t i2c_addr = config->i2c_slave_addr;
	uint8_t port_data;
	int ret;

	ret = i2c_reg_read_byte(i2c_master, i2c_addr, reg, &port_data);
	if (ret != 0) {
	LOG_ERR("Error reading register 0x%X (%d)", reg, ret);
	return ret;
	}
	*cache = port_data;
	LOG_DBG("Read: REG[0x%X] = 0x%X", reg, *cache);

	return ret;
	}

	/**
	* @brief Write to the port registers of certain register function.
	*
	* @param dev Device struct of the FXL6408.
	* @param reg Register to write into. Possible values: REG_DEVICE_ID_CTRL,
	* REG_OUTPUT, REG_DIRECTION, REG_PUD_SEL, REG_PUD_EN, REG_OUTPUT_HIGH_Z and
	* REG_INPUT_DEFAULT.
	* @param cache Pointer to the cache to be updated after successful write.
	* @param value New value to set.
	*
	* @return 0 if successful, failed otherwise.
	*/
	static int write_port_regs(const struct device *dev, uint8_t reg,
	uint8_t *cache, uint8_t value)
	{
	const struct gpio_fxl6408_config *const config = dev->config;
	const struct device *i2c_master = config->i2c_master;
	int ret = 0;

	if (*cache != value) {
	ret = i2c_reg_write_byte(i2c_master, config->i2c_slave_addr,
	reg, value);
	if (ret != 0) {
	LOG_ERR("error writing to register 0x%X (%d)",
	reg, ret);
	return ret;
	}
	*cache = value;
	LOG_DBG("Write: REG[0x%X] = 0x%X", reg, *cache);
	}

	return ret;
	}

	static inline int update_input_regs(const struct device dev, uint8_t buf)
	{
	struct gpio_fxl6408_drv_data *const drv_data =
	(struct gpio_fxl6408_drv_data *const)dev->data;
	int ret = read_port_regs(dev, REG_INPUT_VALUE,
	&drv_data->reg_cache.input);
	*buf = drv_data->reg_cache.input;

	return ret;
	}

	static inline int update_output_regs(const struct device *dev, uint8_t value)
	{
	struct gpio_fxl6408_drv_data *const drv_data =
	(struct gpio_fxl6408_drv_data *const)dev->data;

	return write_port_regs(dev, REG_OUTPUT,
	&drv_data->reg_cache.output, value);
	}

	static inline int update_high_z_regs(const struct device *dev, uint8_t value)
	{
	struct gpio_fxl6408_drv_data *const drv_data =
	(struct gpio_fxl6408_drv_data *const)dev->data;

	return write_port_regs(dev, REG_OUTPUT_HIGH_Z,
	&drv_data->reg_cache.high_z, value);
	}

	static inline int update_direction_regs(const struct device *dev, uint8_t value)
	{
	struct gpio_fxl6408_drv_data *const drv_data =
	(struct gpio_fxl6408_drv_data *const)dev->data;

	return write_port_regs(dev, REG_DIRECTION,
	&drv_data->reg_cache.dir, value);
	}

	static inline int update_pul_sel_regs(const struct device *dev, uint8_t value)
	{
	struct gpio_fxl6408_drv_data *const drv_data =
	(struct gpio_fxl6408_drv_data *const)dev->data;

	return write_port_regs(dev, REG_PUD_SEL,
	&drv_data->reg_cache.pud_sel, value);
	}

	static inline int update_pul_en_regs(const struct device *dev, uint8_t value)
	{
	struct gpio_fxl6408_drv_data *const drv_data =
	(struct gpio_fxl6408_drv_data *const)dev->data;

	return write_port_regs(dev, REG_PUD_EN,
	&drv_data->reg_cache.pud_en, value);
	}

	static int setup_pin_dir(const struct device *dev, uint32_t pin, int flags)
	{
	struct gpio_fxl6408_drv_data *const drv_data =
	(struct gpio_fxl6408_drv_data *const)dev->data;
	uint8_t reg_dir = drv_data->reg_cache.dir;
	uint8_t reg_out = drv_data->reg_cache.output;
	uint8_t reg_high_z = drv_data->reg_cache.high_z;
	int ret;

	if (((flags & GPIO_INPUT) != 0) && ((flags & GPIO_OUTPUT) != 0)) {
	return -ENOTSUP;
	}

	/* Update the driver data to the actual situation of the FXL6408 */
	if (flags & GPIO_OUTPUT) {
	if ((flags & GPIO_OUTPUT_INIT_HIGH)) {
	reg_out \|= BIT(pin);
	} else if ((flags & GPIO_OUTPUT_INIT_LOW)) {
	reg_out &= ~BIT(pin);
	}
	reg_dir \|= BIT(pin);
	reg_high_z &= ~BIT(pin);
	} else if (flags & GPIO_INPUT) {
	reg_dir &= ~BIT(pin);
	reg_high_z &= ~BIT(pin);
	} else {
	reg_high_z \|= BIT(pin);
	reg_dir \|= BIT(pin);
	}

	ret = update_output_regs(dev, reg_out);
	if (ret != 0) {
	return ret;
	}

	ret = update_high_z_regs(dev, reg_high_z);
	if (ret != 0) {
	return ret;
	}

	ret = update_direction_regs(dev, reg_dir);
	return ret;
	}

	/**
	* @brief Setup the pin pull up/pull down status
	*
	* @param dev Device struct of the FXL6408
	* @param pin The pin number
	* @param flags Flags of pin or port
	*
	* @return 0 if successful, failed otherwise
	*/
	static int setup_pin_pullupdown(const struct device *dev, uint32_t pin,
	int flags)
	{
	struct gpio_fxl6408_drv_data *const drv_data =
	(struct gpio_fxl6408_drv_data *const)dev->data;
	uint8_t reg_pud;
	int ret;

	/* If disabling pull up/down, there is no need to set the selection
	* register. Just go straight to disabling.
	*/
	if ((flags & (GPIO_PULL_UP \| GPIO_PULL_DOWN)) != 0U) {
	/* Setup pin pull up or pull down */
	reg_pud = drv_data->reg_cache.pud_sel;

	/* Pull down == 0, pull up == 1 */
	WRITE_BIT(reg_pud, pin, (flags & GPIO_PULL_UP) != 0U);

	ret = update_pul_sel_regs(dev, reg_pud);
	if (ret != 0) {
	return ret;
	}
	}

	/* Enable/disable pull up/down */
	reg_pud = drv_data->reg_cache.pud_en;

	WRITE_BIT(reg_pud, pin,
	(flags & (GPIO_PULL_UP \| GPIO_PULL_DOWN)) != 0U);

	ret = update_pul_en_regs(dev, reg_pud);
	return ret;
	}

	static int gpio_fxl6408_pin_config(const struct device *dev, gpio_pin_t pin,
	gpio_flags_t flags)
	{
	struct gpio_fxl6408_drv_data *const drv_data =
	(struct gpio_fxl6408_drv_data *const)dev->data;
	int ret;

	/* Check if supported flag is set */
	if ((flags & ~SUPPORTED_FLAGS) != 0) {
	return -ENOTSUP;
	}

	/* Can't do I2C bus operations from an ISR */
	if (k_is_in_isr()) {
	return -EWOULDBLOCK;
	}
	k_sem_take(&drv_data->lock, K_FOREVER);

	ret = setup_pin_dir(dev, pin, flags);
	if (ret != 0) {
	LOG_ERR("error setting pin direction (%d)", ret);
	goto done;
	}

	ret = setup_pin_pullupdown(dev, pin, flags);
	if (ret) {
	LOG_ERR("error setting pin pull up/down (%d)", ret);
	goto done;
	}

	done:
	k_sem_give(&drv_data->lock);
	return ret;
	}

	static int gpio_fxl6408_port_get_raw(const struct device dev, uint32_t value)
	{
	struct gpio_fxl6408_drv_data *const drv_data =
	(struct gpio_fxl6408_drv_data *const)dev->data;
	uint8_t buf = 0;
	int ret = 0;

	/* Can't do I2C bus operations from an ISR */
	if (k_is_in_isr()) {
	return -EWOULDBLOCK;
	}

	k_sem_take(&drv_data->lock, K_FOREVER);

	ret = update_input_regs(dev, &buf);
	if (ret != 0) {
	goto done;
	}
	*value = buf;

	done:
	k_sem_give(&drv_data->lock);
	return ret;
	}

	static int gpio_fxl6408_port_set_masked_raw(const struct device *dev,
	uint32_t mask, uint32_t value)
	{
	struct gpio_fxl6408_drv_data *const drv_data =
	(struct gpio_fxl6408_drv_data *const)dev->data;
	uint8_t reg_out;
	int ret;

	/* Can't do I2C bus operations from an ISR */
	if (k_is_in_isr()) {
	return -EWOULDBLOCK;
	}

	k_sem_take(&drv_data->lock, K_FOREVER);

	reg_out = drv_data->reg_cache.output;
	reg_out = (reg_out & ~mask) \| (mask & value);

	ret = update_output_regs(dev, reg_out);

	k_sem_give(&drv_data->lock);

	return ret;
	}

	static int gpio_fxl6408_port_set_bits_raw(const struct device *dev,
	uint32_t mask)
	{
	return gpio_fxl6408_port_set_masked_raw(dev, mask, mask);
	}

	static int gpio_fxl6408_port_clear_bits_raw(const struct device *dev,
	uint32_t mask)
	{
	return gpio_fxl6408_port_set_masked_raw(dev, mask, 0);
	}

	static int gpio_fxl6408_port_toggle_bits(const struct device *dev,
	uint32_t mask)
	{
	struct gpio_fxl6408_drv_data *const drv_data =
	(struct gpio_fxl6408_drv_data *const)dev->data;
	uint8_t reg_out;
	int ret;

	/* Can't do I2C bus operations from an ISR */
	if (k_is_in_isr()) {
	return -EWOULDBLOCK;
	}

	k_sem_take(&drv_data->lock, K_FOREVER);

	reg_out = drv_data->reg_cache.output;
	reg_out ^= mask;
	ret = update_output_regs(dev, reg_out);

	k_sem_give(&drv_data->lock);

	return ret;
	}

	static int gpio_fxl6408_pin_interrupt_configure(const struct device *port,
	gpio_pin_t pin,
	enum gpio_int_mode mode,
	enum gpio_int_trig trig)
	{
	LOG_DBG("Pin interrupts not supported.");
	return -ENOTSUP;
	}

	int gpio_fxl6408_init(const struct device *dev)
	{
	struct gpio_fxl6408_drv_data *const drv_data =
	(struct gpio_fxl6408_drv_data *const)dev->data;
	const struct gpio_fxl6408_config *const config = dev->config;

	if (!device_is_ready(config->i2c_master)) {
	LOG_ERR("%s is not ready", config->i2c_master->name);
	return -ENODEV;
	}

	k_sem_init(&drv_data->lock, 1, 1);

	return 0;
	}

	static const struct gpio_driver_api gpio_fxl_driver = {
	.pin_configure = gpio_fxl6408_pin_config,
	.port_get_raw = gpio_fxl6408_port_get_raw,
	.port_set_masked_raw = gpio_fxl6408_port_set_masked_raw,
	.port_set_bits_raw = gpio_fxl6408_port_set_bits_raw,
	.port_clear_bits_raw = gpio_fxl6408_port_clear_bits_raw,
	.port_toggle_bits = gpio_fxl6408_port_toggle_bits,
	.pin_interrupt_configure = gpio_fxl6408_pin_interrupt_configure
	};

	#define GPIO_FXL6408_DEVICE_INSTANCE(inst) \
	static const struct gpio_fxl6408_config gpio_fxl6408_##inst##_cfg = { \
	.common = { \
	.port_pin_mask = GPIO_PORT_PIN_MASK_FROM_DT_INST(inst),\
	}, \
	.i2c_slave_addr = DT_INST_REG_ADDR(inst), \
	.i2c_master = DEVICE_DT_GET(DT_INST_BUS(inst)) \
	}; \
	\
	static struct gpio_fxl6408_drv_data gpio_fxl6408_##inst##_drvdata = { \
	.reg_cache = { \
	.input = 0x0, \
	.output = 0x00, \
	.dir = 0x0, \
	.high_z = 0xFF, \
	.pud_en = 0xFF, \
	.pud_sel = 0x0 \
	} \
	}; \
	\
	DEVICE_DT_INST_DEFINE(inst, gpio_fxl6408_init, NULL, \
	&gpio_fxl6408_##inst##_drvdata, \
	&gpio_fxl6408_##inst##_cfg, POST_KERNEL, \
	CONFIG_GPIO_FXL6408_INIT_PRIORITY, \
	&gpio_fxl_driver);

	DT_INST_FOREACH_STATUS_OKAY(GPIO_FXL6408_DEVICE_INSTANCE)