drivers/regulator/regulator_pca9420.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

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

 #define DT_DRV_COMPAT nxp_pca9420

 #include <zephyr/kernel.h>
 #include <zephyr/drivers/regulator.h>
 #include <zephyr/dt-bindings/regulator/pmic_i2c.h>
 #include <zephyr/drivers/i2c.h>
 #include <errno.h>
 #include <zephyr/logging/log.h>

 LOG_MODULE_REGISTER(pca9420, CONFIG_REGULATOR_LOG_LEVEL);

 struct __packed voltage_range {
 	int uV; /* Voltage in uV */
 	int reg_val; /* Register value for voltage */
 };

 struct __packed current_range {
 	int uA; /* Current limit in uA */
 	int reg_val; /* Register value for current limit */
 };

 struct regulator_data {
 	struct onoff_sync_service srv;
 	const struct voltage_range *voltages;
 	const struct current_range *current_levels;
 };

 struct regulator_config {
 	int num_voltages;
 	int num_current_levels;
 	int num_modes;
 	uint8_t vsel_reg;
 	uint8_t vsel_mask;
 	int32_t max_uv;
 	int32_t min_uv;
 	uint8_t enable_reg;
 	uint8_t enable_mask;
 	uint8_t enable_val;
 	bool enable_inverted;
 	bool boot_on;
 	uint8_t ilim_reg;
 	uint8_t ilim_mask;
 	struct i2c_dt_spec i2c;
 	uint16_t initial_mode;
 	uint32_t *voltage_array;
 	uint32_t *current_array;
 	uint16_t *allowed_modes;
 	uint8_t modesel_offset;
 	uint8_t modesel_reg;
 	uint8_t modesel_mask;
 };

 static int regulator_pca9420_is_supported_voltage(const struct device *dev,
 						  int32_t min_uv,
 						  int32_t max_uv);

 /**
  * Reads a register from the PMIC
  * Returns 0 on success, or errno on error
  */
 static int regulator_read_register(const struct device *dev,
 	uint8_t reg, uint8_t *out)
 {
 	const struct regulator_config *conf = dev->config;
 	int ret;

 	ret = i2c_reg_read_byte_dt(&conf->i2c, reg, out);
 	LOG_DBG("READ 0x%x: 0x%x", reg, *out);
 	return ret;
 }

 /**
  * Modifies a register within the PMIC
  * Returns 0 on success, or errno on error
  */
 static int regulator_modify_register(const struct device *dev,
 		uint8_t reg, uint8_t reg_mask, uint8_t reg_val)
 {
 	const struct regulator_config *conf = dev->config;
 	uint8_t reg_current;
 	int rc;

 	rc = regulator_read_register(dev, reg, &reg_current);
 	if (rc) {
 		return rc;
 	}

 	reg_current &= ~reg_mask;
 	reg_current |= (reg_val & reg_mask);
 	LOG_DBG("WRITE 0x%02X to 0x%02X at I2C addr 0x%02X", reg_current,
 		reg, conf->i2c.addr);
 	return i2c_reg_write_byte_dt(&conf->i2c, reg, reg_current);
 }

 /*
  * Internal helper function- gets the voltage from a regulator, with an
  * offset applied to the vsel_reg. Useful to support reading voltages
  * in another target mode
  */
 static int32_t regulator_get_voltage_offset(const struct device *dev,
 					    uint32_t off)
 {
 	const struct regulator_config *config = dev->config;
 	struct regulator_data *data = dev->data;
 	int rc, i = 0;
 	uint8_t raw_reg;

 	rc = regulator_read_register(dev, config->vsel_reg + off, &raw_reg);
 	if (rc) {
 		return rc;
 	}
 	raw_reg &= config->vsel_mask;
 	/* Locate the voltage value in the voltage table */
 	while (i < config->num_voltages &&
 		raw_reg != data->voltages[i].reg_val){
 		i++;
 	}
 	if (i == config->num_voltages) {
 		LOG_WRN("Regulator vsel reg has unknown value");
 		return -EIO;
 	}
 	return data->voltages[i].uV;
 }

 /**
  * Internal helper function- sets the voltage for a regulator, with an
  * offset applied to the vsel_reg. Useful to support setting voltages in
  * another target mode.
  */
 static int regulator_set_voltage_offset(const struct device *dev,
 					int32_t min_uv, int32_t max_uv,
 					uint32_t off)
 {
 	const struct regulator_config *config = dev->config;
 	struct regulator_data *data = dev->data;
 	int i = 0;

 	if (!regulator_pca9420_is_supported_voltage(dev, min_uv, max_uv) ||
 		min_uv > max_uv) {
 		return -EINVAL;
 	}
 	/* Find closest supported voltage */
 	while (i < config->num_voltages && min_uv > data->voltages[i].uV) {
 		i++;
 	}
 	if (data->voltages[i].uV > max_uv) {
 		LOG_DBG("Regulator could not satisfy voltage range, too narrow");
 		return -EINVAL;
 	}
 	if (i == config->num_voltages) {
 		LOG_WRN("Regulator could not locate supported voltage,"
 				"but voltage is in range.");
 		return -EINVAL;
 	}
 	LOG_DBG("Setting regulator %s to %duV", dev->name,
 			data->voltages[i].uV);
 	return regulator_modify_register(dev, config->vsel_reg + off,
 			config->vsel_mask, data->voltages[i].reg_val);
 }


 /**
  * Part of the extended regulator consumer API
  * Returns the number of supported voltages
  */
 static int regulator_pca9420_count_voltages(const struct device *dev)
 {
 	const struct regulator_config *config = dev->config;

 	return config->num_voltages;
 }

 /**
  * Part of the extended regulator consumer API
  * Counts the number of modes supported by a regulator
  */
 static int regulator_pca9420_count_modes(const struct device *dev)
 {
 	const struct regulator_config *config = dev->config;

 	return config->num_modes;
 }

 /**
  * Part of the extended regulator consumer API
  * Returns the supported voltage in uV for a given selector value
  */
 static int32_t regulator_pca9420_list_voltages(const struct device *dev,
 					       unsigned int selector)
 {
 	const struct regulator_config *config = dev->config;
 	struct regulator_data *data = dev->data;

 	if (config->num_voltages <= selector) {
 		return -ENODEV;
 	}
 	return data->voltages[selector].uV;
 }

 /**
  * Part of the extended regulator consumer API
  * Returns true if the regulator supports a voltage in the given range.
  */
 static int regulator_pca9420_is_supported_voltage(const struct device *dev,
 						  int32_t min_uv,
 						  int32_t max_uv)
 {
 	const struct regulator_config *config = dev->config;

 	return !((config->max_uv < min_uv) || (config->min_uv > max_uv));
 }

 /**
  * Part of the extended regulator consumer API
  * Sets the output voltage to the closest supported voltage value
  */
 static int regulator_pca9420_set_voltage(const struct device *dev,
 					 int32_t min_uv, int32_t max_uv)
 {
 	return regulator_set_voltage_offset(dev, min_uv, max_uv, 0);
 }


 /**
  * Part of the extended regulator consumer API
  * Gets the current output voltage in uV
  */
 static int32_t regulator_pca9420_get_voltage(const struct device *dev)
 {
 	return regulator_get_voltage_offset(dev, 0);
 }

 /**
  * Part of the extended regulator consumer API
  * Set the current limit for this device
  */
 static int regulator_pca9420_set_current_limit(const struct device *dev,
 					       int32_t min_ua, int32_t max_ua)
 {
 	const struct regulator_config *config = dev->config;
 	struct regulator_data *data = dev->data;
 	int i = 0;

 	if (config->num_current_levels == 0) {
 		/* Regulator cannot limit current */
 		return -ENOTSUP;
 	}
 	/* Locate the desired current limit */
 	while (i < config->num_current_levels &&
 		min_ua > data->current_levels[i].uA) {
 		i++;
 	}
 	if (i == config->num_current_levels ||
 		data->current_levels[i].uA > max_ua) {
 		return -EINVAL;
 	}
 	/* Set the current limit */
 	return regulator_modify_register(dev, config->ilim_reg,
 		config->ilim_mask, data->current_levels[i].reg_val);
 }

 /**
  * Part of the extended regulator consumer API
  * Gets the set current limit for the regulator
  */
 static int regulator_pca9420_get_current_limit(const struct device *dev)
 {
 	const struct regulator_config *config = dev->config;
 	struct regulator_data *data = dev->data;
 	int rc, i = 0;
 	uint8_t raw_reg;

 	if (config->num_current_levels == 0) {
 		return -ENOTSUP;
 	}
 	rc = regulator_read_register(dev, config->ilim_reg, &raw_reg);
 	if (rc) {
 		return rc;
 	}
 	raw_reg &= config->ilim_mask;
 	while (i < config->num_current_levels &&
 		data->current_levels[i].reg_val != raw_reg) {
 		i++;
 	}
 	if (i == config->num_current_levels) {
 		return -EIO;
 	}
 	return data->current_levels[i].uA;
 }

 /*
  * Part of the extended regulator consumer API.
  * sets the target voltage for a given regulator mode. This mode does
  * not need to be the active mode. This API can be used to configure
  * voltages for a mode, then the regulator can be switched to that mode
  * with the regulator_pca9420_set_mode api
  */
 static int regulator_pca9420_set_mode_voltage(const struct device *dev,
 					      uint32_t mode, int32_t min_uv,
 					      int32_t max_uv)
 {
 	const struct regulator_config *config = dev->config;
 	uint8_t i, sel_off;

 	if (config->num_modes == 0) {
 		return -ENOTSUP;
 	}

 	/* Search for mode ID in allowed modes. */
 	for (i = 0 ; i < config->num_modes; i++) {
 		if (config->allowed_modes[i] == mode) {
 			break;
 		}
 	}
 	if (i == config->num_modes) {
 		/* Mode was not found */
 		return -EINVAL;
 	}
 	sel_off = ((mode & PMIC_MODE_OFFSET_MASK) >> PMIC_MODE_OFFSET_SHIFT);
 	return regulator_set_voltage_offset(dev, min_uv, max_uv, sel_off);
 }

 /*
  * Part of the extended regulator consumer API.
  * Disables the regulator in a given mode. Does not implement the
  * onoff service, as this is incompatible with multiple mode operation
  */
 static int regulator_pca9420_mode_disable(const struct device *dev,
 					  uint32_t mode)
 {
 	const struct regulator_config *config = dev->config;
 	uint8_t i, sel_off, dis_val;

 	if (config->num_modes == 0) {
 		return -ENOTSUP;
 	}

 	/* Search for mode ID in allowed modes. */
 	for (i = 0 ; i < config->num_modes; i++) {
 		if (config->allowed_modes[i] == mode) {
 			break;
 		}
 	}
 	if (i == config->num_modes) {
 		/* Mode was not found */
 		return -EINVAL;
 	}
 	sel_off = ((mode & PMIC_MODE_OFFSET_MASK) >> PMIC_MODE_OFFSET_SHIFT);
 	dis_val = config->enable_inverted ? config->enable_val : 0;
 	return regulator_modify_register(dev, config->enable_reg + sel_off,
 			config->enable_mask, dis_val);
 }

 /*
  * Part of the extended regulator consumer API.
  * Enables the regulator in a given mode. Does not implement the
  * onoff service, as this is incompatible with multiple mode operation
  */
 static int regulator_pca9420_mode_enable(const struct device *dev,
 					 uint32_t mode)
 {
 	const struct regulator_config *config = dev->config;
 	uint8_t i, sel_off, en_val;

 	if (config->num_modes == 0) {
 		return -ENOTSUP;
 	}

 	/* Search for mode ID in allowed modes. */
 	for (i = 0 ; i < config->num_modes; i++) {
 		if (config->allowed_modes[i] == mode) {
 			break;
 		}
 	}
 	if (i == config->num_modes) {
 		/* Mode was not found */
 		return -EINVAL;
 	}
 	sel_off = ((mode & PMIC_MODE_OFFSET_MASK) >> PMIC_MODE_OFFSET_SHIFT);
 	en_val = config->enable_inverted ? 0 : config->enable_val;
 	return regulator_modify_register(dev, config->enable_reg + sel_off,
 			config->enable_mask, en_val);
 }

 /*
  * Part of the extended regulator consumer API.
  * gets the target voltage for a given regulator mode. This mode does
  * not need to be the active mode. This API can be used to read voltages
  * from a regulator mode other than the default.
  */
 static int32_t regulator_pca9420_get_mode_voltage(const struct device *dev,
 						  uint32_t mode)
 {
 	const struct regulator_config *config = dev->config;
 	uint8_t i, sel_off;

 	if (config->num_modes == 0) {
 		return -ENOTSUP;
 	}

 	/* Search for mode ID in allowed modes. */
 	for (i = 0 ; i < config->num_modes; i++) {
 		if (config->allowed_modes[i] == mode) {
 			break;
 		}
 	}
 	if (i == config->num_modes) {
 		/* Mode was not found */
 		return -EINVAL;
 	}
 	sel_off = ((mode & PMIC_MODE_OFFSET_MASK) >> PMIC_MODE_OFFSET_SHIFT);
 	return regulator_get_voltage_offset(dev, sel_off);
 }

 /*
  * Part of the extended regulator consumer API
  * switches the regulator to a given mode. This API will apply a mode for
  * the regulator.
  */
 static int regulator_pca9420_set_mode(const struct device *dev, uint32_t mode)
 {
 	const struct regulator_config *config = dev->config;
 	int rc;
 	uint8_t i, sel_off;

 	if (config->num_modes == 0) {
 		return -ENOTSUP;
 	}

 	/* Search for mode ID in allowed modes. */
 	for (i = 0 ; i < config->num_modes; i++) {
 		if (config->allowed_modes[i] == mode) {
 			break;
 		}
 	}
 	if (i == config->num_modes) {
 		/* Mode was not found */
 		return -EINVAL;
 	}
 	sel_off = ((mode & PMIC_MODE_OFFSET_MASK) >> PMIC_MODE_OFFSET_SHIFT);
 	/* Configure mode */
 	if (mode & PMIC_MODE_FLAG_MODESEL_MULTI_REG) {
 		/* Select mode with offset calculation */
 		rc = regulator_modify_register(dev,
 			config->modesel_reg + sel_off,
 			mode & PMIC_MODE_SELECTOR_MASK, config->modesel_mask);
 	} else {
 		/* Select mode without offset to modesel_reg */
 		rc = regulator_modify_register(dev, config->modesel_reg,
 			mode & PMIC_MODE_SELECTOR_MASK, config->modesel_mask);
 	}
 	return rc;
 }

 static int regulator_pca9420_enable(const struct device *dev,
 				    struct onoff_client *cli)
 {
 	k_spinlock_key_t key;
 	int rc;
 	uint8_t en_val;
 	struct regulator_data *data = dev->data;
 	const struct regulator_config *config = dev->config;

 	LOG_DBG("Enabling regulator");
 	rc = onoff_sync_lock(&data->srv, &key);
 	if (rc) {
 		/* Request has already enabled PMIC */
 		return onoff_sync_finalize(&data->srv, key, cli, rc, true);
 	}
 	en_val = config->enable_inverted ? 0 : config->enable_val;
 	rc = regulator_modify_register(dev, config->enable_reg,
 			config->enable_mask, en_val);
 	if (rc != 0) {
 		return onoff_sync_finalize(&data->srv, key, NULL, rc, false);
 	}
 	return onoff_sync_finalize(&data->srv, key, cli, rc, true);
 }

 static int regulator_pca9420_disable(const struct device *dev)
 {
 	struct regulator_data *data = dev->data;
 	const struct regulator_config *config = dev->config;
 	k_spinlock_key_t key;
 	uint8_t dis_val;
 	int rc;

 	LOG_DBG("Disabling regulator");
 	rc = onoff_sync_lock(&data->srv, &key);
 	if (rc == 0) {
 		rc = -EINVAL;
 		return onoff_sync_finalize(&data->srv, key, NULL, rc, false);
 	} else if (rc == 1) {
 		/* Disable regulator */
 		dis_val = config->enable_inverted ? config->enable_val : 0;
 		rc = regulator_modify_register(dev, config->enable_reg,
 				config->enable_mask, dis_val);
 	}
 	return onoff_sync_finalize(&data->srv, key, NULL, rc, false);
 }

 static int pmic_reg_init(const struct device *dev)
 {
 	const struct regulator_config *config = dev->config;
 	struct regulator_data *data = dev->data;
 	int rc  = 0;

 	/* Cast the voltage array set at compile time to the voltage range
 	 * struct
 	 */
 	data->voltages = (struct voltage_range *)config->voltage_array;
 	/* Do the same cast for current limit ranges */
 	data->current_levels = (struct current_range *)config->current_array;
 	/* Check to verify we have a valid I2C device */
 	if (!device_is_ready(config->i2c.bus)) {
 		return -ENODEV;
 	}
 	if (config->boot_on) {
 		rc = regulator_pca9420_enable(dev, NULL);
 	}
 	if (config->initial_mode) {
 		rc = regulator_pca9420_set_mode(dev, config->initial_mode);
 	}
 	return rc;
 }


 static const struct regulator_driver_api api = {
 	.enable = regulator_pca9420_enable,
 	.disable = regulator_pca9420_disable,
 	.count_voltages = regulator_pca9420_count_voltages,
 	.count_modes = regulator_pca9420_count_modes,
 	.list_voltages = regulator_pca9420_list_voltages,
 	.is_supported_voltage = regulator_pca9420_is_supported_voltage,
 	.set_voltage = regulator_pca9420_set_voltage,
 	.get_voltage = regulator_pca9420_get_voltage,
 	.set_current_limit = regulator_pca9420_set_current_limit,
 	.get_current_limit = regulator_pca9420_get_current_limit,
 	.set_mode = regulator_pca9420_set_mode,
 	.set_mode_voltage = regulator_pca9420_set_mode_voltage,
 	.get_mode_voltage = regulator_pca9420_get_mode_voltage,
 	.mode_disable = regulator_pca9420_mode_disable,
 	.mode_enable = regulator_pca9420_mode_enable,
 };

 /*
  * Each regulator output will be initialized as a separate device struct,
  * and implement the regulator API. Since the DT binding is defined for the
  * entire regulator, this macro will be called for each child node of the
  * regulator device. This allows the regulator to have common DTS properties
  * shared between each regulator output
  */
 #define CONFIGURE_REGULATOR_OUTPUT(node, ord)							\
 	static uint32_t pmic_reg_##ord##_cur_limits[] =						\
 		DT_PROP_OR(node, current_levels, {});						\
 	static uint32_t pmic_reg_##ord##_vol_range[] =						\
 		DT_PROP(node, voltage_range);							\
 	static uint16_t pmic_reg_##ord##_allowed_modes[] =					\
 		DT_PROP_OR(DT_PARENT(node), regulator_allowed_modes, {});			\
 	static struct regulator_data pmic_reg_##ord##_data;					\
 	static struct regulator_config pmic_reg_##ord##_cfg = {					\
 		.vsel_mask = DT_PROP(node, vsel_mask),						\
 		.vsel_reg = DT_PROP(node, vsel_reg),						\
 		.num_voltages = DT_PROP(node, num_voltages),					\
 		.num_current_levels = DT_PROP(node, num_current_levels),			\
 		.enable_reg = DT_PROP(node, enable_reg),					\
 		.enable_mask = DT_PROP(node, enable_mask),					\
 		.enable_val = DT_PROP(node, enable_val),					\
 		.min_uv = DT_PROP(node, min_uv),						\
 		.max_uv = DT_PROP(node, max_uv),						\
 		.ilim_reg = DT_PROP_OR(node, ilim_reg, 0),					\
 		.ilim_mask = DT_PROP_OR(node, ilim_mask, 0),					\
 		.enable_inverted = DT_PROP(node, enable_inverted),				\
 		.boot_on = DT_PROP_OR(node, regulator_boot_on, false),				\
 		.num_modes = ARRAY_SIZE(pmic_reg_##ord##_allowed_modes),			\
 		.initial_mode = DT_PROP_OR(DT_PARENT(node), regulator_initial_mode, 0),		\
 		.i2c = I2C_DT_SPEC_GET(DT_PARENT(node)),					\
 		.voltage_array = pmic_reg_##ord##_vol_range,					\
 		.current_array = pmic_reg_##ord##_cur_limits,					\
 		.allowed_modes = pmic_reg_##ord##_allowed_modes,				\
 		.modesel_offset = DT_PROP_OR(DT_PARENT(node), modesel_offset, 0),		\
 		.modesel_reg = DT_PROP_OR(DT_PARENT(node), modesel_reg, 0),			\
 		.modesel_mask = DT_PROP_OR(DT_PARENT(node), modesel_mask, 0),			\
 	};											\
 	DEVICE_DT_DEFINE(node, pmic_reg_init, NULL,						\
 			      &pmic_reg_##ord##_data,						\
 			      &pmic_reg_##ord##_cfg,						\
 			      POST_KERNEL, CONFIG_REGULATOR_PCA9420_INIT_PRIORITY,		\
 			      &api);								\
 /* Intermediate macros to extract DT node ordinal
  * (used as  a unique token for variable names)
  */
 #define _CONFIGURE_REGULATOR_OUTPUT(node, ord)							\
 	CONFIGURE_REGULATOR_OUTPUT(node, ord)

 #define __CONFIGURE_REGULATOR_OUTPUT(node)							\
 	_CONFIGURE_REGULATOR_OUTPUT(node, DT_DEP_ORD(node))

 #define CONFIGURE_REGULATOR(id)									\
 	DT_INST_FOREACH_CHILD(id, __CONFIGURE_REGULATOR_OUTPUT)

 DT_INST_FOREACH_STATUS_OKAY(CONFIGURE_REGULATOR)
	/*
	* Copyright (c) 2021 NXP
	* SPDX-License-Identifier: Apache-2.0
	*/

	#define DT_DRV_COMPAT nxp_pca9420

	#include <zephyr/kernel.h>
	#include <zephyr/drivers/regulator.h>
	#include <zephyr/dt-bindings/regulator/pmic_i2c.h>
	#include <zephyr/drivers/i2c.h>
	#include <errno.h>
	#include <zephyr/logging/log.h>

	LOG_MODULE_REGISTER(pca9420, CONFIG_REGULATOR_LOG_LEVEL);

	struct __packed voltage_range {
	int uV; /* Voltage in uV */
	int reg_val; /* Register value for voltage */
	};

	struct __packed current_range {
	int uA; /* Current limit in uA */
	int reg_val; /* Register value for current limit */
	};

	struct regulator_data {
	struct onoff_sync_service srv;
	const struct voltage_range *voltages;
	const struct current_range *current_levels;
	};

	struct regulator_config {
	int num_voltages;
	int num_current_levels;
	int num_modes;
	uint8_t vsel_reg;
	uint8_t vsel_mask;
	int32_t max_uv;
	int32_t min_uv;
	uint8_t enable_reg;
	uint8_t enable_mask;
	uint8_t enable_val;
	bool enable_inverted;
	bool boot_on;
	uint8_t ilim_reg;
	uint8_t ilim_mask;
	struct i2c_dt_spec i2c;
	uint16_t initial_mode;
	uint32_t *voltage_array;
	uint32_t *current_array;
	uint16_t *allowed_modes;
	uint8_t modesel_offset;
	uint8_t modesel_reg;
	uint8_t modesel_mask;
	};

	static int regulator_pca9420_is_supported_voltage(const struct device *dev,
	int32_t min_uv,
	int32_t max_uv);

	/**
	* Reads a register from the PMIC
	* Returns 0 on success, or errno on error
	*/
	static int regulator_read_register(const struct device *dev,
	uint8_t reg, uint8_t *out)
	{
	const struct regulator_config *conf = dev->config;
	int ret;

	ret = i2c_reg_read_byte_dt(&conf->i2c, reg, out);
	LOG_DBG("READ 0x%x: 0x%x", reg, *out);
	return ret;
	}

	/**
	* Modifies a register within the PMIC
	* Returns 0 on success, or errno on error
	*/
	static int regulator_modify_register(const struct device *dev,
	uint8_t reg, uint8_t reg_mask, uint8_t reg_val)
	{
	const struct regulator_config *conf = dev->config;
	uint8_t reg_current;
	int rc;

	rc = regulator_read_register(dev, reg, &reg_current);
	if (rc) {
	return rc;
	}

	reg_current &= ~reg_mask;
	reg_current \|= (reg_val & reg_mask);
	LOG_DBG("WRITE 0x%02X to 0x%02X at I2C addr 0x%02X", reg_current,
	reg, conf->i2c.addr);
	return i2c_reg_write_byte_dt(&conf->i2c, reg, reg_current);
	}

	/*
	* Internal helper function- gets the voltage from a regulator, with an
	* offset applied to the vsel_reg. Useful to support reading voltages
	* in another target mode
	*/
	static int32_t regulator_get_voltage_offset(const struct device *dev,
	uint32_t off)
	{
	const struct regulator_config *config = dev->config;
	struct regulator_data *data = dev->data;
	int rc, i = 0;
	uint8_t raw_reg;

	rc = regulator_read_register(dev, config->vsel_reg + off, &raw_reg);
	if (rc) {
	return rc;
	}
	raw_reg &= config->vsel_mask;
	/* Locate the voltage value in the voltage table */
	while (i < config->num_voltages &&
	raw_reg != data->voltages[i].reg_val){
	i++;
	}
	if (i == config->num_voltages) {
	LOG_WRN("Regulator vsel reg has unknown value");
	return -EIO;
	}
	return data->voltages[i].uV;
	}

	/**
	* Internal helper function- sets the voltage for a regulator, with an
	* offset applied to the vsel_reg. Useful to support setting voltages in
	* another target mode.
	*/
	static int regulator_set_voltage_offset(const struct device *dev,
	int32_t min_uv, int32_t max_uv,
	uint32_t off)
	{
	const struct regulator_config *config = dev->config;
	struct regulator_data *data = dev->data;
	int i = 0;

	if (!regulator_pca9420_is_supported_voltage(dev, min_uv, max_uv) \|\|
	min_uv > max_uv) {
	return -EINVAL;
	}
	/* Find closest supported voltage */
	while (i < config->num_voltages && min_uv > data->voltages[i].uV) {
	i++;
	}
	if (data->voltages[i].uV > max_uv) {
	LOG_DBG("Regulator could not satisfy voltage range, too narrow");
	return -EINVAL;
	}
	if (i == config->num_voltages) {
	LOG_WRN("Regulator could not locate supported voltage,"
	"but voltage is in range.");
	return -EINVAL;
	}
	LOG_DBG("Setting regulator %s to %duV", dev->name,
	data->voltages[i].uV);
	return regulator_modify_register(dev, config->vsel_reg + off,
	config->vsel_mask, data->voltages[i].reg_val);
	}


	/**
	* Part of the extended regulator consumer API
	* Returns the number of supported voltages
	*/
	static int regulator_pca9420_count_voltages(const struct device *dev)
	{
	const struct regulator_config *config = dev->config;

	return config->num_voltages;
	}

	/**
	* Part of the extended regulator consumer API
	* Counts the number of modes supported by a regulator
	*/
	static int regulator_pca9420_count_modes(const struct device *dev)
	{
	const struct regulator_config *config = dev->config;

	return config->num_modes;
	}

	/**
	* Part of the extended regulator consumer API
	* Returns the supported voltage in uV for a given selector value
	*/
	static int32_t regulator_pca9420_list_voltages(const struct device *dev,
	unsigned int selector)
	{
	const struct regulator_config *config = dev->config;
	struct regulator_data *data = dev->data;

	if (config->num_voltages <= selector) {
	return -ENODEV;
	}
	return data->voltages[selector].uV;
	}

	/**
	* Part of the extended regulator consumer API
	* Returns true if the regulator supports a voltage in the given range.
	*/
	static int regulator_pca9420_is_supported_voltage(const struct device *dev,
	int32_t min_uv,
	int32_t max_uv)
	{
	const struct regulator_config *config = dev->config;

	return !((config->max_uv < min_uv) \|\| (config->min_uv > max_uv));
	}

	/**
	* Part of the extended regulator consumer API
	* Sets the output voltage to the closest supported voltage value
	*/
	static int regulator_pca9420_set_voltage(const struct device *dev,
	int32_t min_uv, int32_t max_uv)
	{
	return regulator_set_voltage_offset(dev, min_uv, max_uv, 0);
	}


	/**
	* Part of the extended regulator consumer API
	* Gets the current output voltage in uV
	*/
	static int32_t regulator_pca9420_get_voltage(const struct device *dev)
	{
	return regulator_get_voltage_offset(dev, 0);
	}

	/**
	* Part of the extended regulator consumer API
	* Set the current limit for this device
	*/
	static int regulator_pca9420_set_current_limit(const struct device *dev,
	int32_t min_ua, int32_t max_ua)
	{
	const struct regulator_config *config = dev->config;
	struct regulator_data *data = dev->data;
	int i = 0;

	if (config->num_current_levels == 0) {
	/* Regulator cannot limit current */
	return -ENOTSUP;
	}
	/* Locate the desired current limit */
	while (i < config->num_current_levels &&
	min_ua > data->current_levels[i].uA) {
	i++;
	}
	if (i == config->num_current_levels \|\|
	data->current_levels[i].uA > max_ua) {
	return -EINVAL;
	}
	/* Set the current limit */
	return regulator_modify_register(dev, config->ilim_reg,
	config->ilim_mask, data->current_levels[i].reg_val);
	}

	/**
	* Part of the extended regulator consumer API
	* Gets the set current limit for the regulator
	*/
	static int regulator_pca9420_get_current_limit(const struct device *dev)
	{
	const struct regulator_config *config = dev->config;
	struct regulator_data *data = dev->data;
	int rc, i = 0;
	uint8_t raw_reg;

	if (config->num_current_levels == 0) {
	return -ENOTSUP;
	}
	rc = regulator_read_register(dev, config->ilim_reg, &raw_reg);
	if (rc) {
	return rc;
	}
	raw_reg &= config->ilim_mask;
	while (i < config->num_current_levels &&
	data->current_levels[i].reg_val != raw_reg) {
	i++;
	}
	if (i == config->num_current_levels) {
	return -EIO;
	}
	return data->current_levels[i].uA;
	}

	/*
	* Part of the extended regulator consumer API.
	* sets the target voltage for a given regulator mode. This mode does
	* not need to be the active mode. This API can be used to configure
	* voltages for a mode, then the regulator can be switched to that mode
	* with the regulator_pca9420_set_mode api
	*/
	static int regulator_pca9420_set_mode_voltage(const struct device *dev,
	uint32_t mode, int32_t min_uv,
	int32_t max_uv)
	{
	const struct regulator_config *config = dev->config;
	uint8_t i, sel_off;

	if (config->num_modes == 0) {
	return -ENOTSUP;
	}

	/* Search for mode ID in allowed modes. */
	for (i = 0 ; i < config->num_modes; i++) {
	if (config->allowed_modes[i] == mode) {
	break;
	}
	}
	if (i == config->num_modes) {
	/* Mode was not found */
	return -EINVAL;
	}
	sel_off = ((mode & PMIC_MODE_OFFSET_MASK) >> PMIC_MODE_OFFSET_SHIFT);
	return regulator_set_voltage_offset(dev, min_uv, max_uv, sel_off);
	}

	/*
	* Part of the extended regulator consumer API.
	* Disables the regulator in a given mode. Does not implement the
	* onoff service, as this is incompatible with multiple mode operation
	*/
	static int regulator_pca9420_mode_disable(const struct device *dev,
	uint32_t mode)
	{
	const struct regulator_config *config = dev->config;
	uint8_t i, sel_off, dis_val;

	if (config->num_modes == 0) {
	return -ENOTSUP;
	}

	/* Search for mode ID in allowed modes. */
	for (i = 0 ; i < config->num_modes; i++) {
	if (config->allowed_modes[i] == mode) {
	break;
	}
	}
	if (i == config->num_modes) {
	/* Mode was not found */
	return -EINVAL;
	}
	sel_off = ((mode & PMIC_MODE_OFFSET_MASK) >> PMIC_MODE_OFFSET_SHIFT);
	dis_val = config->enable_inverted ? config->enable_val : 0;
	return regulator_modify_register(dev, config->enable_reg + sel_off,
	config->enable_mask, dis_val);
	}

	/*
	* Part of the extended regulator consumer API.
	* Enables the regulator in a given mode. Does not implement the
	* onoff service, as this is incompatible with multiple mode operation
	*/
	static int regulator_pca9420_mode_enable(const struct device *dev,
	uint32_t mode)
	{
	const struct regulator_config *config = dev->config;
	uint8_t i, sel_off, en_val;

	if (config->num_modes == 0) {
	return -ENOTSUP;
	}

	/* Search for mode ID in allowed modes. */
	for (i = 0 ; i < config->num_modes; i++) {
	if (config->allowed_modes[i] == mode) {
	break;
	}
	}
	if (i == config->num_modes) {
	/* Mode was not found */
	return -EINVAL;
	}
	sel_off = ((mode & PMIC_MODE_OFFSET_MASK) >> PMIC_MODE_OFFSET_SHIFT);
	en_val = config->enable_inverted ? 0 : config->enable_val;
	return regulator_modify_register(dev, config->enable_reg + sel_off,
	config->enable_mask, en_val);
	}

	/*
	* Part of the extended regulator consumer API.
	* gets the target voltage for a given regulator mode. This mode does
	* not need to be the active mode. This API can be used to read voltages
	* from a regulator mode other than the default.
	*/
	static int32_t regulator_pca9420_get_mode_voltage(const struct device *dev,
	uint32_t mode)
	{
	const struct regulator_config *config = dev->config;
	uint8_t i, sel_off;

	if (config->num_modes == 0) {
	return -ENOTSUP;
	}

	/* Search for mode ID in allowed modes. */
	for (i = 0 ; i < config->num_modes; i++) {
	if (config->allowed_modes[i] == mode) {
	break;
	}
	}
	if (i == config->num_modes) {
	/* Mode was not found */
	return -EINVAL;
	}
	sel_off = ((mode & PMIC_MODE_OFFSET_MASK) >> PMIC_MODE_OFFSET_SHIFT);
	return regulator_get_voltage_offset(dev, sel_off);
	}

	/*
	* Part of the extended regulator consumer API
	* switches the regulator to a given mode. This API will apply a mode for
	* the regulator.
	*/
	static int regulator_pca9420_set_mode(const struct device *dev, uint32_t mode)
	{
	const struct regulator_config *config = dev->config;
	int rc;
	uint8_t i, sel_off;

	if (config->num_modes == 0) {
	return -ENOTSUP;
	}

	/* Search for mode ID in allowed modes. */
	for (i = 0 ; i < config->num_modes; i++) {
	if (config->allowed_modes[i] == mode) {
	break;
	}
	}
	if (i == config->num_modes) {
	/* Mode was not found */
	return -EINVAL;
	}
	sel_off = ((mode & PMIC_MODE_OFFSET_MASK) >> PMIC_MODE_OFFSET_SHIFT);
	/* Configure mode */
	if (mode & PMIC_MODE_FLAG_MODESEL_MULTI_REG) {
	/* Select mode with offset calculation */
	rc = regulator_modify_register(dev,
	config->modesel_reg + sel_off,
	mode & PMIC_MODE_SELECTOR_MASK, config->modesel_mask);
	} else {
	/* Select mode without offset to modesel_reg */
	rc = regulator_modify_register(dev, config->modesel_reg,
	mode & PMIC_MODE_SELECTOR_MASK, config->modesel_mask);
	}
	return rc;
	}

	static int regulator_pca9420_enable(const struct device *dev,
	struct onoff_client *cli)
	{
	k_spinlock_key_t key;
	int rc;
	uint8_t en_val;
	struct regulator_data *data = dev->data;
	const struct regulator_config *config = dev->config;

	LOG_DBG("Enabling regulator");
	rc = onoff_sync_lock(&data->srv, &key);
	if (rc) {
	/* Request has already enabled PMIC */
	return onoff_sync_finalize(&data->srv, key, cli, rc, true);
	}
	en_val = config->enable_inverted ? 0 : config->enable_val;
	rc = regulator_modify_register(dev, config->enable_reg,
	config->enable_mask, en_val);
	if (rc != 0) {
	return onoff_sync_finalize(&data->srv, key, NULL, rc, false);
	}
	return onoff_sync_finalize(&data->srv, key, cli, rc, true);
	}

	static int regulator_pca9420_disable(const struct device *dev)
	{
	struct regulator_data *data = dev->data;
	const struct regulator_config *config = dev->config;
	k_spinlock_key_t key;
	uint8_t dis_val;
	int rc;

	LOG_DBG("Disabling regulator");
	rc = onoff_sync_lock(&data->srv, &key);
	if (rc == 0) {
	rc = -EINVAL;
	return onoff_sync_finalize(&data->srv, key, NULL, rc, false);
	} else if (rc == 1) {
	/* Disable regulator */
	dis_val = config->enable_inverted ? config->enable_val : 0;
	rc = regulator_modify_register(dev, config->enable_reg,
	config->enable_mask, dis_val);
	}
	return onoff_sync_finalize(&data->srv, key, NULL, rc, false);
	}

	static int pmic_reg_init(const struct device *dev)
	{
	const struct regulator_config *config = dev->config;
	struct regulator_data *data = dev->data;
	int rc = 0;

	/* Cast the voltage array set at compile time to the voltage range
	* struct
	*/
	data->voltages = (struct voltage_range *)config->voltage_array;
	/* Do the same cast for current limit ranges */
	data->current_levels = (struct current_range *)config->current_array;
	/* Check to verify we have a valid I2C device */
	if (!device_is_ready(config->i2c.bus)) {
	return -ENODEV;
	}
	if (config->boot_on) {
	rc = regulator_pca9420_enable(dev, NULL);
	}
	if (config->initial_mode) {
	rc = regulator_pca9420_set_mode(dev, config->initial_mode);
	}
	return rc;
	}


	static const struct regulator_driver_api api = {
	.enable = regulator_pca9420_enable,
	.disable = regulator_pca9420_disable,
	.count_voltages = regulator_pca9420_count_voltages,
	.count_modes = regulator_pca9420_count_modes,
	.list_voltages = regulator_pca9420_list_voltages,
	.is_supported_voltage = regulator_pca9420_is_supported_voltage,
	.set_voltage = regulator_pca9420_set_voltage,
	.get_voltage = regulator_pca9420_get_voltage,
	.set_current_limit = regulator_pca9420_set_current_limit,
	.get_current_limit = regulator_pca9420_get_current_limit,
	.set_mode = regulator_pca9420_set_mode,
	.set_mode_voltage = regulator_pca9420_set_mode_voltage,
	.get_mode_voltage = regulator_pca9420_get_mode_voltage,
	.mode_disable = regulator_pca9420_mode_disable,
	.mode_enable = regulator_pca9420_mode_enable,
	};

	/*
	* Each regulator output will be initialized as a separate device struct,
	* and implement the regulator API. Since the DT binding is defined for the
	* entire regulator, this macro will be called for each child node of the
	* regulator device. This allows the regulator to have common DTS properties
	* shared between each regulator output
	*/
	#define CONFIGURE_REGULATOR_OUTPUT(node, ord) \
	static uint32_t pmic_reg_##ord##_cur_limits[] = \
	DT_PROP_OR(node, current_levels, {}); \
	static uint32_t pmic_reg_##ord##_vol_range[] = \
	DT_PROP(node, voltage_range); \
	static uint16_t pmic_reg_##ord##_allowed_modes[] = \
	DT_PROP_OR(DT_PARENT(node), regulator_allowed_modes, {}); \
	static struct regulator_data pmic_reg_##ord##_data; \
	static struct regulator_config pmic_reg_##ord##_cfg = { \
	.vsel_mask = DT_PROP(node, vsel_mask), \
	.vsel_reg = DT_PROP(node, vsel_reg), \
	.num_voltages = DT_PROP(node, num_voltages), \
	.num_current_levels = DT_PROP(node, num_current_levels), \
	.enable_reg = DT_PROP(node, enable_reg), \
	.enable_mask = DT_PROP(node, enable_mask), \
	.enable_val = DT_PROP(node, enable_val), \
	.min_uv = DT_PROP(node, min_uv), \
	.max_uv = DT_PROP(node, max_uv), \
	.ilim_reg = DT_PROP_OR(node, ilim_reg, 0), \
	.ilim_mask = DT_PROP_OR(node, ilim_mask, 0), \
	.enable_inverted = DT_PROP(node, enable_inverted), \
	.boot_on = DT_PROP_OR(node, regulator_boot_on, false), \
	.num_modes = ARRAY_SIZE(pmic_reg_##ord##_allowed_modes), \
	.initial_mode = DT_PROP_OR(DT_PARENT(node), regulator_initial_mode, 0), \
	.i2c = I2C_DT_SPEC_GET(DT_PARENT(node)), \
	.voltage_array = pmic_reg_##ord##_vol_range, \
	.current_array = pmic_reg_##ord##_cur_limits, \
	.allowed_modes = pmic_reg_##ord##_allowed_modes, \
	.modesel_offset = DT_PROP_OR(DT_PARENT(node), modesel_offset, 0), \
	.modesel_reg = DT_PROP_OR(DT_PARENT(node), modesel_reg, 0), \
	.modesel_mask = DT_PROP_OR(DT_PARENT(node), modesel_mask, 0), \
	}; \
	DEVICE_DT_DEFINE(node, pmic_reg_init, NULL, \
	&pmic_reg_##ord##_data, \
	&pmic_reg_##ord##_cfg, \
	POST_KERNEL, CONFIG_REGULATOR_PCA9420_INIT_PRIORITY, \
	&api); \
	/* Intermediate macros to extract DT node ordinal
	* (used as a unique token for variable names)
	*/
	#define _CONFIGURE_REGULATOR_OUTPUT(node, ord) \
	CONFIGURE_REGULATOR_OUTPUT(node, ord)

	#define __CONFIGURE_REGULATOR_OUTPUT(node) \
	_CONFIGURE_REGULATOR_OUTPUT(node, DT_DEP_ORD(node))

	#define CONFIGURE_REGULATOR(id) \
	DT_INST_FOREACH_CHILD(id, __CONFIGURE_REGULATOR_OUTPUT)

	DT_INST_FOREACH_STATUS_OKAY(CONFIGURE_REGULATOR)