Re: [U-Boot] [PATCH v2 07/12] dm: regulator: add max77686 regulator driver

Hi Przemyslaw,

On 3 March 2015 at 09:24, Przemyslaw Marczak p.marczak@samsung.com wrote:

This commit adds support to max77686 regulator driver based on a uclass regulator driver-model api, which provides implementation of all uclass regulator api function calls.

New file: drivers/power/regulator/max77686.c New config: CONFIG_DM_REGULATOR_MAX77686

Signed-off-by: Przemyslaw Marczak p.marczak@samsung.com

Changes V2:

• change debug() to error()
• code cleanup
• fix data types
• ldo/buck state implementation
• adjust to new uclass api

---

Makefile | 1 + drivers/power/Makefile | 1 - drivers/power/regulator/Makefile | 8 + drivers/power/regulator/max77686.c | 926 +++++++++++++++++++++++++++++++++++++ include/power/max77686_pmic.h | 24 +- 5 files changed, 956 insertions(+), 4 deletions(-) create mode 100644 drivers/power/regulator/Makefile create mode 100644 drivers/power/regulator/max77686.c

diff --git a/Makefile b/Makefile index 6da4215..fcb37ae 100644 --- a/Makefile +++ b/Makefile @@ -627,6 +627,7 @@ libs-y += drivers/power/ \ drivers/power/fuel_gauge/ \ drivers/power/mfd/ \ drivers/power/pmic/ \

•   drivers/power/regulator/ \
    drivers/power/battery/
  

libs-y += drivers/spi/ libs-$(CONFIG_FMAN_ENET) += drivers/net/fm/ diff --git a/drivers/power/Makefile b/drivers/power/Makefile index 943b38f..7ff1baa 100644 --- a/drivers/power/Makefile +++ b/drivers/power/Makefile @@ -15,7 +15,6 @@ obj-$(CONFIG_TPS6586X_POWER) += tps6586x.o obj-$(CONFIG_TWL4030_POWER) += twl4030.o obj-$(CONFIG_TWL6030_POWER) += twl6030.o obj-$(CONFIG_PALMAS_POWER) += palmas.o

obj-$(CONFIG_POWER) += power_core.o obj-$(CONFIG_DIALOG_POWER) += power_dialog.o obj-$(CONFIG_POWER_FSL) += power_fsl.o diff --git a/drivers/power/regulator/Makefile b/drivers/power/regulator/Makefile new file mode 100644 index 0000000..9d282e3 --- /dev/null +++ b/drivers/power/regulator/Makefile @@ -0,0 +1,8 @@ +# +# Copyright (C) 2014 Samsung Electronics +# Przemyslaw Marczak p.marczak@samsung.com +# +# SPDX-License-Identifier: GPL-2.0+ +#

+obj-$(CONFIG_DM_REGULATOR_MAX77686) += max77686.o diff --git a/drivers/power/regulator/max77686.c b/drivers/power/regulator/max77686.c new file mode 100644 index 0000000..711c19c --- /dev/null +++ b/drivers/power/regulator/max77686.c @@ -0,0 +1,926 @@ +/*

• • Copyright (C) 2012-2015 Samsung Electronics
• • Rajeshwari Shinde rajeshwari.s@samsung.com
• • Przemyslaw Marczak p.marczak@samsung.com
• • SPDX-License-Identifier: GPL-2.0+
• */

+#include <common.h> +#include <fdtdec.h> +#include <i2c.h> +#include <dm.h> +#include <power/pmic.h> +#include <power/regulator.h> +#include <power/max77686_pmic.h> +#include <errno.h> +#include <dm.h>

+DECLARE_GLOBAL_DATA_PTR;

+struct max77686_regulator_info {

•   int ldo_cnt;
  

•   int buck_cnt;
  

•   struct regulator_value_desc ldo_desc[MAX77686_LDO_NUM + 1];
  

Why +1? Then let's use MAX77686_LDO_COUNT for the number of LDOs.

•   struct regulator_value_desc buck_desc[MAX77686_BUCK_NUM + 1];
  

+};

+#define MODE(_mode, _val, _name) { \

•   .mode = _mode, \
  

•   .register_value = _val, \
  

•   .name = _name, \
  

+}

+/* LDO: 1,3,4,5,9,17,18,19,20,21,22,23,24,26,26,27 */ +static struct regulator_mode_desc max77686_ldo_mode_standby1[] = {

•   MODE(OPMODE_OFF, MAX77686_LDO_MODE_OFF, "OFF"),
  

•   MODE(OPMODE_LPM, MAX77686_LDO_MODE_LPM, "LPM"),
  

•   MODE(OPMODE_STANDBY_LPM, MAX77686_LDO_MODE_STANDBY_LPM, "ON/LPM"),
  

•   MODE(OPMODE_ON, MAX77686_LDO_MODE_ON, "ON"),
  

+};

+/* LDO: 2,6,7,8,10,11,12,14,15,16 */ +static struct regulator_mode_desc max77686_ldo_mode_standby2[] = {

•   MODE(OPMODE_OFF, MAX77686_LDO_MODE_OFF, "OFF"),
  

•   MODE(OPMODE_STANDBY, MAX77686_LDO_MODE_STANDBY, "ON/OFF"),
  

•   MODE(OPMODE_STANDBY_LPM, MAX77686_LDO_MODE_STANDBY_LPM, "ON/LPM"),
  

•   MODE(OPMODE_ON, MAX77686_LDO_MODE_ON, "ON"),
  

+};

+/* Buck: 1 */ +static struct regulator_mode_desc max77686_buck_mode_standby[] = {

•   MODE(OPMODE_OFF, MAX77686_BUCK_MODE_OFF, "OFF"),
  

•   MODE(OPMODE_STANDBY, MAX77686_BUCK_MODE_STANDBY, "ON/OFF"),
  

•   MODE(OPMODE_ON, MAX77686_BUCK_MODE_ON, "ON"),
  

+};

+/* Buck: 2,3,4 */ +static struct regulator_mode_desc max77686_buck_mode_lpm[] = {

•   MODE(OPMODE_OFF, MAX77686_BUCK_MODE_OFF, "OFF"),
  

•   MODE(OPMODE_STANDBY, MAX77686_BUCK_MODE_STANDBY, "ON/OFF"),
  

•   MODE(OPMODE_LPM, MAX77686_BUCK_MODE_LPM, "LPM"),
  

•   MODE(OPMODE_ON, MAX77686_BUCK_MODE_ON, "ON"),
  

+};

+/* Buck: 5,6,7,8,9 */ +static struct regulator_mode_desc max77686_buck_mode_onoff[] = {

•   MODE(OPMODE_OFF, MAX77686_BUCK_MODE_OFF, "OFF"),
  

•   MODE(OPMODE_ON, MAX77686_BUCK_MODE_ON, "ON"),
  

+};

+static const char max77686_buck_addr[] = {

•   0xff, 0x10, 0x12, 0x1c, 0x26, 0x30, 0x32, 0x34, 0x36, 0x38
  

+};

+static int max77686_buck_volt2hex(int buck, int uV) +{

•   unsigned int hex = 0;
  

•   unsigned int hex_max = 0;
  

•   switch (buck) {
  

•   case 2:
  

•   case 3:
  

•   case 4:
  

•           /* hex = (uV - 600000) / 12500; */
  

•           hex = (uV - MAX77686_BUCK_UV_LMIN) / MAX77686_BUCK_UV_LSTEP;
  

•           hex_max = MAX77686_BUCK234_VOLT_MAX_HEX;
  

•           /**
  

•            * This uses voltage scaller - temporary not implemented
  

•            * so return just 0
  

•            */
  

•           return 0;
  

•   default:
  

•           /* hex = (uV - 750000) / 50000; */
  

•           hex = (uV - MAX77686_BUCK_UV_HMIN) / MAX77686_BUCK_UV_HSTEP;
  

•           hex_max = MAX77686_BUCK_VOLT_MAX_HEX;
  

•           break;
  

•   }
  

•   if (hex >= 0 && hex <= hex_max)
  

•           return hex;
  

•   error("Value: %d uV is wrong for BUCK%d", uV, buck);
  

•   return -EINVAL;
  

+}

+static int max77686_buck_hex2volt(int buck, int hex) +{

•   unsigned uV = 0;
  

•   unsigned int hex_max = 0;
  

•   if (hex < 0)
  

•           goto bad_hex;
  

•   switch (buck) {
  

•   case 2:
  

•   case 3:
  

•   case 4:
  

•           hex_max = MAX77686_BUCK234_VOLT_MAX_HEX;
  

•           if (hex > hex_max)
  

•                   goto bad_hex;
  

•           /* uV = hex * 12500 + 600000; */
  

•           uV = hex * MAX77686_BUCK_UV_LSTEP + MAX77686_BUCK_UV_LMIN;
  

•           break;
  

•   default:
  

•           hex_max = MAX77686_BUCK_VOLT_MAX_HEX;
  

•           if (hex > hex_max)
  

•                   goto bad_hex;
  

•           /* uV = hex * 50000 + 750000; */
  

•           uV = hex * MAX77686_BUCK_UV_HSTEP + MAX77686_BUCK_UV_HMIN;
  

•           break;
  

•   }
  

•   return uV;
  

+bad_hex:

•   error("Value: %#x is wrong for BUCK%d", hex, buck);
  

•   return -EINVAL;
  

+}

+static int max77686_ldo_volt2hex(int ldo, int uV) +{

•   unsigned int hex = 0;
  

•   switch (ldo) {
  

•   case 1:
  

•   case 2:
  

•   case 6:
  

•   case 7:
  

•   case 8:
  

•   case 15:
  

•           hex = (uV - MAX77686_LDO_UV_MIN) / MAX77686_LDO_UV_LSTEP;
  

•           /* hex = (uV - 800000) / 25000; */
  

•           break;
  

•   default:
  

•           hex = (uV - MAX77686_LDO_UV_MIN) / MAX77686_LDO_UV_HSTEP;
  

•           /* hex = (uV - 800000) / 50000; */
  

•   }
  

•   if (hex >= 0 && hex <= MAX77686_LDO_VOLT_MAX_HEX)
  

•           return hex;
  

•   error("Value: %d uV is wrong for LDO%d", uV, ldo);
  

•   return -EINVAL;
  

+}

+static int max77686_ldo_hex2volt(int ldo, int hex) +{

•   unsigned int uV = 0;
  

•   if (hex > MAX77686_LDO_VOLT_MAX_HEX)
  

•           goto bad_hex;
  

•   switch (ldo) {
  

•   case 1:
  

•   case 2:
  

•   case 6:
  

•   case 7:
  

•   case 8:
  

•   case 15:
  

•           /* uV = hex * 25000 + 800000; */
  

•           uV = hex * MAX77686_LDO_UV_LSTEP + MAX77686_LDO_UV_MIN;
  

•           break;
  

•   default:
  

•           /* uV = hex * 50000 + 800000; */
  

•           uV = hex * MAX77686_LDO_UV_HSTEP + MAX77686_LDO_UV_MIN;
  

•   }
  

•   return uV;
  

+bad_hex:

•   error("Value: %#x is wrong for ldo%d", hex, ldo);
  

•   return -EINVAL;
  

+}

+static int max77686_ldo_hex2mode(int ldo, int hex) +{

•   if (hex > MAX77686_LDO_MODE_MASK)
  

•           return -EINVAL;
  

•   switch (hex) {
  

•   case MAX77686_LDO_MODE_OFF:
  

•           return OPMODE_OFF;
  

•   case MAX77686_LDO_MODE_LPM: /* == MAX77686_LDO_MODE_STANDBY: */
  

•           /* The same mode values but different meaning for each ldo */
  

•           switch (ldo) {
  

•           case 2:
  

•           case 6:
  

•           case 7:
  

•           case 8:
  

•           case 10:
  

•           case 11:
  

•           case 12:
  

•           case 14:
  

•           case 15:
  

•           case 16:
  

•                   return OPMODE_STANDBY;
  

•           default:
  

•                   return OPMODE_LPM;
  

•           }
  

•   case MAX77686_LDO_MODE_STANDBY_LPM:
  

•           return OPMODE_STANDBY_LPM;
  

•   case MAX77686_LDO_MODE_ON:
  

•           return OPMODE_ON;
  

•   default:
  

•           return -EINVAL;
  

•   }
  

+}

+static int max77686_buck_hex2mode(int buck, int hex) +{

•   if (hex > MAX77686_BUCK_MODE_MASK)
  

•           return -EINVAL;
  

•   switch (hex) {
  

•   case MAX77686_BUCK_MODE_OFF:
  

•           return OPMODE_OFF;
  

•   case MAX77686_BUCK_MODE_ON:
  

•           return OPMODE_ON;
  

•   case MAX77686_BUCK_MODE_STANDBY:
  

•           switch (buck) {
  

•           case 1:
  

•           case 2:
  

•           case 3:
  

•           case 4:
  

•                   return OPMODE_STANDBY;
  

•           default:
  

•                   return -EINVAL;
  

•           }
  

•   case MAX77686_BUCK_MODE_LPM:
  

•           switch (buck) {
  

•           case 2:
  

•           case 3:
  

•           case 4:
  

•                   return OPMODE_LPM;
  

•           default:
  

•                   return -EINVAL;
  

•           }
  

•   default:
  

•           return -EINVAL;
  

•   }
  

+}

+static int max77686_get_value_desc(struct udevice *dev, int type, int d_num,

•                              struct regulator_value_desc **desc)
  

+{

•   struct max77686_regulator_info *dev_info;
  

Can we just pass struct max77686_regulator_info into this function avoid all this checking? Similar elsewhere it applied.

•   if (!dev)
  

•           return -ENODEV;
  

•   if (!dev->priv)
  

•           return -ENXIO;
  

•   dev_info = dev->priv;
  

•   switch (type) {
  

•   case REGULATOR_TYPE_LDO:
  

•           if (d_num < 1 || d_num > 26)
  

•                   return -EINVAL;
  

•           *desc = &dev_info->ldo_desc[d_num];
  

•           return 0;
  

•   case REGULATOR_TYPE_BUCK:
  

•           if (d_num < 1 || d_num > 9)
  

•                   return -EINVAL;
  

•           *desc = &dev_info->buck_desc[d_num];
  

•           return 0;
  

•   default:
  

•           return -EPERM;
  

•   }
  

+}

+static int max77686_get_mode_desc_array(struct udevice *dev, int type,

•                                   int d_num, int *d_mode_cnt,
  

•                                   struct regulator_mode_desc **desc)
  

+{

•   struct max77686_regulator_info *dev_info;
  

•   if (!dev)
  

•           return -ENODEV;
  

•   if (!dev->priv)
  

•           return -ENXIO;
  

•   dev_info = dev->priv;
  

•   *d_mode_cnt = 0;
  

•   if (type == REGULATOR_TYPE_LDO) {
  

•           if (d_num < 1 || d_num > dev_info->ldo_cnt)
  

•                   return -EINVAL;
  

•           switch (d_num) {
  

•           case 2:
  

•           case 6:
  

•           case 7:
  

•           case 8:
  

•           case 10:
  

•           case 11:
  

•           case 12:
  

•           case 14:
  

•           case 15:
  

•           case 16:
  

•                   *d_mode_cnt = ARRAY_SIZE(max77686_ldo_mode_standby2);
  

•                   *desc = max77686_ldo_mode_standby2;
  

•                   return 0;
  

•           default:
  

•                   *d_mode_cnt = ARRAY_SIZE(max77686_ldo_mode_standby1);
  

•                   *desc = max77686_ldo_mode_standby1;
  

•                   return 0;
  

•           }
  

•   } else if (type == REGULATOR_TYPE_BUCK) {
  

•           if (d_num < 1 || d_num > dev_info->buck_cnt)
  

•                   return -EINVAL;
  

•           switch (d_num) {
  

•           case 1:
  

•                   *d_mode_cnt = ARRAY_SIZE(max77686_buck_mode_standby);
  

•                   *desc = max77686_buck_mode_standby;
  

•                   return 0;
  

•           case 2:
  

•           case 3:
  

•           case 4:
  

•                   *d_mode_cnt = ARRAY_SIZE(max77686_buck_mode_lpm);
  

•                   *desc = max77686_buck_mode_lpm;
  

•                   return 0;
  

•           default:
  

•                   *d_mode_cnt = ARRAY_SIZE(max77686_buck_mode_onoff);
  

•                   *desc = max77686_buck_mode_onoff;
  

•                   return 0;
  

•           }
  

•   }
  

•   return -EINVAL;
  

+}

+static int max77686_ldo_val(struct udevice *dev, int op,

•                           int ldo, int *uV)
  

+{

•   unsigned int ret, hex, adr;
  

•   unsigned char val;
  

•   if (op == PMIC_OP_GET)
  

•           *uV = 0;
  

•   if (ldo < 1 || ldo > 26) {
  

•           error("Wrong ldo number: %d", ldo);
  

•           return -EINVAL;
  

•   }
  

•   adr = MAX77686_REG_PMIC_LDO1CTRL1 + ldo - 1;
  

•   ret = pmic_read(dev->parent, adr, &val);
  

•   if (ret)
  

•           return ret;
  

•   if (op == PMIC_OP_GET) {
  

•           val &= MAX77686_LDO_VOLT_MASK;
  

•           ret = max77686_ldo_hex2volt(ldo, val);
  

•           if (ret < 0)
  

•                   return ret;
  

•           *uV = ret;
  

•           return 0;
  

•   }
  

•   hex = max77686_ldo_volt2hex(ldo, *uV);
  

•   if (hex < 0)
  

•           return -EINVAL;
  

•   val &= ~MAX77686_LDO_VOLT_MASK;
  

•   val |= hex;
  

•   ret |= pmic_write(dev->parent, adr, val);
  

You should not | error values together as you will get nonsense. Try:

ret = pmic_write() if (ret) return ret

or

if (ret) goto err:

/* more code *.

err: return ret;

•   return ret;
  

+}

+static int max77686_buck_val(struct udevice *dev, int op,

•                           int buck, int *uV)
  

+{

•   unsigned int hex, ret, mask, adr;
  

•   unsigned char val;
  

•   if (buck < 1 || buck > 9) {
  

•           error("Wrong buck number: %d", buck);
  

•           return -EINVAL;
  

•   }
  

•   if (op == PMIC_OP_GET)
  

•           *uV = 0;
  

•   /* &buck_out = ctrl + 1 */
  

•   adr = max77686_buck_addr[buck] + 1;
  

•   /* mask */
  

•   switch (buck) {
  

•   case 2:
  

•   case 3:
  

•   case 4:
  

•           /* Those uses voltage scallers - will support in the future */
  

•           mask = MAX77686_BUCK234_VOLT_MASK;
  

•           return -EPERM;
  

•   default:
  

•           mask = MAX77686_BUCK_VOLT_MASK;
  

•   }
  

•   ret = pmic_read(dev->parent, adr, &val);
  

•   if (ret)
  

•           return ret;
  

•   if (op == PMIC_OP_GET) {
  

•           val &= mask;
  

•           ret = max77686_buck_hex2volt(buck, val);
  

•           if (ret < 0)
  

•                   return ret;
  

•           *uV = ret;
  

•           return 0;
  

•   }
  

•   hex = max77686_buck_volt2hex(buck, *uV);
  

•   if (hex < 0)
  

•           return -EINVAL;
  

•   val &= ~mask;
  

•   val |= hex;
  

•   ret = pmic_write(dev->parent, adr, val);
  

•   return ret;
  

+}

+static int max77686_ldo_mode(struct udevice *dev, int op, int ldo, int *opmode) +{

•   unsigned int ret, adr, mode;
  

•   unsigned char val;
  

•   if (op == PMIC_OP_GET)
  

•           *opmode = -EINVAL;
  

•   if (ldo < 1 || ldo > 26) {
  

•           error("Wrong ldo number: %d", ldo);
  

•           return -EINVAL;
  

•   }
  

•   adr = MAX77686_REG_PMIC_LDO1CTRL1 + ldo - 1;
  

•   ret = pmic_read(dev->parent, adr, &val);
  

•   if (ret)
  

•           return ret;
  

•   if (op == PMIC_OP_GET) {
  

•           val &= MAX77686_LDO_MODE_MASK;
  

•           ret = max77686_ldo_hex2mode(ldo, val);
  

•           if (ret < 0)
  

•                   return ret;
  

•           *opmode = ret;
  

•           return 0;
  

•   }
  

•   /* mode */
  

•   switch (*opmode) {
  

•   case OPMODE_OFF:
  

•           mode = MAX77686_LDO_MODE_OFF;
  

•           break;
  

•   case OPMODE_LPM:
  

•           switch (ldo) {
  

•           case 2:
  

•           case 6:
  

•           case 7:
  

•           case 8:
  

•           case 10:
  

•           case 11:
  

•           case 12:
  

•           case 14:
  

•           case 15:
  

•           case 16:
  

•                   return -EINVAL;
  

•           default:
  

•                   mode = MAX77686_LDO_MODE_LPM;
  

•           }
  

•           break;
  

•   case OPMODE_STANDBY:
  

•           switch (ldo) {
  

•           case 2:
  

•           case 6:
  

•           case 7:
  

•           case 8:
  

•           case 10:
  

•           case 11:
  

•           case 12:
  

•           case 14:
  

•           case 15:
  

•           case 16:
  

•                   mode = MAX77686_LDO_MODE_STANDBY;
  

•                   break;
  

•           default:
  

•                   return -EINVAL;
  

•           }
  

•           break;
  

•   case OPMODE_STANDBY_LPM:
  

•           mode = MAX77686_LDO_MODE_STANDBY_LPM;
  

•           break;
  

•   case OPMODE_ON:
  

•           mode = MAX77686_LDO_MODE_ON;
  

•           break;
  

•   default:
  

•           mode = 0xff;
  

•   }
  

•   if (mode == 0xff) {
  

•           error("Wrong mode: %d for ldo%d", *opmode, ldo);
  

•           return -EINVAL;
  

•   }
  

•   val &= ~MAX77686_LDO_MODE_MASK;
  

•   val |= mode;
  

•   ret |= pmic_write(dev->parent, adr, val);
  

•   return ret;
  

+}

+static int max77686_ldo_state(struct udevice *dev, int op, int ldo, int *state) +{

•   int ret, on_off;
  

•   if (op == PMIC_OP_GET) {
  

•           ret = max77686_ldo_mode(dev, op, ldo, &on_off);
  

•           if (ret)
  

•                   return ret;
  

•           switch (on_off) {
  

•           case OPMODE_OFF:
  

•                   *state = 0;
  

•                   break;
  

•           case OPMODE_ON:
  

•                   *state = 1;
  

•                   break;
  

•           default:
  

•                   return -EINVAL;
  

•           }
  

•   } else if (op == PMIC_OP_SET) {
  

•           switch (*state) {
  

•           case 0:
  

•                   on_off = OPMODE_OFF;
  

•                   break;
  

•           case 1:
  

•                   on_off = OPMODE_ON;
  

•                   break;
  

•           default:
  

•                   return -EINVAL;
  

•           }
  

•           ret = max77686_ldo_mode(dev, op, ldo, &on_off);
  

•           if (ret)
  

•                   return ret;
  

•   }
  

•   return 0;
  

+}

+static int max77686_buck_mode(struct udevice *dev, int op, int buck,

•                         int *opmode)
  

+{

•   unsigned int ret, mask, adr, mode, mode_shift;
  

•   unsigned char val;
  

•   if (buck < 1 || buck > 9) {
  

•           error("Wrong buck number: %d", buck);
  

•           return -EINVAL;
  

•   }
  

•   adr = max77686_buck_addr[buck];
  

•   /* mask */
  

•   switch (buck) {
  

•   case 2:
  

•   case 3:
  

•   case 4:
  

•           mode_shift = MAX77686_BUCK_MODE_SHIFT_2;
  

•           break;
  

•   default:
  

•           mode_shift = MAX77686_BUCK_MODE_SHIFT_1;
  

•   }
  

•   mask = MAX77686_BUCK_MODE_MASK << mode_shift;
  

•   ret = pmic_read(dev->parent, adr, &val);
  

•   if (ret)
  

•           return ret;
  

•   if (op == PMIC_OP_GET) {
  

•           val &= mask;
  

•           val >>= mode_shift;
  

•           ret = max77686_buck_hex2mode(buck, val);
  

•           if (ret < 0)
  

•                   return ret;
  

•           *opmode = ret;
  

•           return 0;
  

•   }
  

•   /* mode */
  

•   switch (*opmode) {
  

•   case OPMODE_OFF:
  

•           mode = MAX77686_BUCK_MODE_OFF;
  

•           break;
  

•   case OPMODE_STANDBY:
  

•           switch (buck) {
  

•           case 1:
  

•           case 2:
  

•           case 3:
  

•           case 4:
  

•                   mode = MAX77686_BUCK_MODE_STANDBY << mode_shift;
  

•                   break;
  

•           default:
  

•                   mode = 0xff;
  

•           }
  

•           break;
  

•   case OPMODE_LPM:
  

•           switch (buck) {
  

•           case 2:
  

•           case 3:
  

•           case 4:
  

•                   mode = MAX77686_BUCK_MODE_LPM << mode_shift;
  

•                   break;
  

•           default:
  

•                   mode = 0xff;
  

•           }
  

•           break;
  

•   case OPMODE_ON:
  

•           mode = MAX77686_BUCK_MODE_ON << mode_shift;
  

•           break;
  

•   default:
  

•           mode = 0xff;
  

•   }
  

•   if (mode == 0xff) {
  

•           error("Wrong mode:%d for buck%d\n", *opmode, buck);
  

•           return -EINVAL;
  

•   }
  

•   val &= ~mask;
  

•   val |= mode;
  

•   ret |= pmic_write(dev->parent, adr, val);
  

•   return ret;
  

+}

+static int max77686_buck_state(struct udevice *dev, int op,

•                          int buck, int *state)
  

+{

•   int ret, on_off;
  

•   if (op == PMIC_OP_GET) {
  

•           ret = max77686_buck_mode(dev, op, buck, &on_off);
  

•           if (ret)
  

•                   return ret;
  

•           switch (on_off) {
  

•           case OPMODE_OFF:
  

•                   *state = 0;
  

•                   break;
  

•           case OPMODE_ON:
  

•                   *state = 1;
  

•                   break;
  

•           default:
  

•                   return -EINVAL;
  

•           }
  

•   } else if (op == PMIC_OP_SET) {
  

•           switch (*state) {
  

•           case 0:
  

•                   on_off = OPMODE_OFF;
  

•                   break;
  

•           case 1:
  

•                   on_off = OPMODE_ON;
  

•                   break;
  

•           default:
  

•                   return -EINVAL;
  

•           }
  

•           ret = max77686_buck_mode(dev, op, buck, &on_off);
  

•           if (ret)
  

•                   return ret;
  

•   }
  

•   return 0;
  

+}

+int fill_reg_desc(int offset, struct regulator_value_desc *desc, int reg_num,

•             int desc_type)
  

+{

•   const void *blob = gd->fdt_blob;
  

•   char *reg_name;
  

•   int reg_min, reg_max, len;
  

•   desc->type = desc_type;
  

•   desc->number = reg_num;
  

•   reg_name = (char *)fdt_getprop(blob, offset, "regulator-name", &len);
  

You can drop the cast.

•   if (reg_name) {
  

•           strncpy(&desc->name[0], reg_name, DESC_NAME_LEN);
  

•           desc->name[DESC_NAME_LEN - 1] = '\0';
  

•   } else {
  

•           sprintf(&desc->name[0], "-");
  

•   }
  

•   reg_min = fdtdec_get_int(blob, offset, "regulator-min-microvolt", -1);
  

•   desc->min_uV = reg_min;
  

•   reg_max = fdtdec_get_int(blob, offset, "regulator-min-microvolt", -1);
  

•   desc->max_uV = reg_max;
  

•   return 0;
  

+}

+static int get_desc_for_compat(int regulators_node, char *compat, int desc_type,

•                          struct regulator_value_desc *desc, int desc_num)
  

+{

•   const void *blob = gd->fdt_blob;
  

•   const char *reg_compat;
  

•   int compat_len = strlen(compat);
  

•   int reg_num;
  

•   int offset;
  

•   int cnt = 0;
  

•   /* First subnode of "voltage_regulators" node */
  

•   offset = fdt_first_subnode(blob, regulators_node);
  

•   while (offset > 0) {
  

•           /* Get regulator properties */
  

•           reg_compat = (char *)fdt_getprop(blob, offset,
  

•                        "regulator-compatible", NULL);
  

•           /* Check compat and compare the number only */
  

•           reg_num = 0;
  

•           if (strstr(reg_compat, compat))
  

•                   reg_num = simple_strtoul(reg_compat + compat_len,
  

•                                            NULL, 0);
  

•           else
  

•                   goto next_offset;
  

•           if (reg_num && reg_num <= desc_num)
  

•                   fill_reg_desc(offset, &desc[reg_num], reg_num,
  

•                                 desc_type);
  

•           cnt++;
  

•           if (cnt == desc_num)
  

•                   return cnt;
  

+next_offset:

•           offset = fdt_next_subnode(blob, offset);
  

•   }
  

•   return cnt;
  

+}

+static int reg_max77686_ofdata_to_platdata(struct udevice *dev) +{

•   struct max77686_regulator_info *dev_info = dev->priv;
  

•   const void *blob = gd->fdt_blob;
  

•   int node = dev->of_offset;
  

•   int offset;
  

•   if (node < 0) {
  

•           error("Device: %s - bad of_offset", dev->name);
  

•           return 0;
  

•   }
  

•   offset = fdt_subnode_offset(blob, node,  "voltage-regulators");
  

•   if (offset < 0) {
  

•           error("Node %s has no 'voltage-regulators' subnode", dev->name);
  

•           return 0;
  

•   }
  

•   dev_info->ldo_cnt = get_desc_for_compat(offset, "LDO", REGULATOR_TYPE_LDO,
  

•                                           dev_info->ldo_desc,
  

•                                           MAX77686_LDO_NUM);
  

•   dev_info->buck_cnt = get_desc_for_compat(offset, "BUCK", REGULATOR_TYPE_BUCK,
  

•                                            dev_info->buck_desc,
  

•                                            MAX77686_BUCK_NUM);
  

Do you think these should be child devices?

•   /* Even if there is no voltage regulators node in dts,
  

Comment style

•    * always return success and allow the driver to bind.
  

•    * Then we can still do read/write pmic registers.
  

•    */
  

•   return 0;
  

+}

+static int max77686_get_cnt(struct udevice *dev, int type, int *cnt) +{

•   switch (type) {
  

•   case REGULATOR_TYPE_LDO:
  

•           *cnt = MAX77686_LDO_NUM;
  

•           break;
  

•   case REGULATOR_TYPE_BUCK:
  

•           *cnt = MAX77686_BUCK_NUM;
  

•           break;
  

•   default:
  

•           *cnt = 0;
  

•           return -EPERM;
  

•   }
  

•   return 0;
  

+}

+static int max77686_get_value(struct udevice *dev, int type, int number,

•                         int *value)
  

+{

•   switch (type) {
  

•   case REGULATOR_TYPE_LDO:
  

•           return max77686_ldo_val(dev, PMIC_OP_GET, number, value);
  

•   case REGULATOR_TYPE_BUCK:
  

•           return max77686_buck_val(dev, PMIC_OP_GET, number, value);
  

•   default:
  

•           return -EPERM;
  

•   }
  

+}

+static int max77686_set_value(struct udevice *dev, int type, int number,

•                         int value)
  

+{

•   switch (type) {
  

•   case REGULATOR_TYPE_LDO:
  

•           return max77686_ldo_val(dev, PMIC_OP_SET, number, &value);
  

•   case REGULATOR_TYPE_BUCK:
  

•           return max77686_buck_val(dev, PMIC_OP_SET, number, &value);
  

•   default:
  

•           return -EPERM;
  

•   }
  

+}

+static int max77686_get_state(struct udevice *dev, int type, int number,

•                         int *state)
  

+{

•   switch (type) {
  

•   case REGULATOR_TYPE_LDO:
  

•           return max77686_ldo_state(dev, PMIC_OP_GET, number, state);
  

•   case REGULATOR_TYPE_BUCK:
  

•           return max77686_buck_state(dev, PMIC_OP_GET, number, state);
  

•   default:
  

•           *state = -1;
  

•           return -EPERM;
  

•   }
  

+}

+static int max77686_set_state(struct udevice *dev, int type, int number,

•                         int state)
  

+{

•   switch (type) {
  

•   case REGULATOR_TYPE_LDO:
  

•           return max77686_ldo_state(dev, PMIC_OP_SET, number, &state);
  

•   case REGULATOR_TYPE_BUCK:
  

•           return max77686_buck_state(dev, PMIC_OP_SET, number, &state);
  

•   default:
  

•           return -EPERM;
  

•   }
  

+}

+static int max77686_get_mode(struct udevice *dev, int type, int number,

•                        int *mode)
  

+{

•   switch (type) {
  

•   case REGULATOR_TYPE_LDO:
  

•           return max77686_ldo_mode(dev, PMIC_OP_GET, number, mode);
  

•   case REGULATOR_TYPE_BUCK:
  

•           return max77686_buck_mode(dev, PMIC_OP_GET, number, mode);
  

•   default:
  

•           return -EPERM;
  

•   }
  

+}

+static int max77686_set_mode(struct udevice *dev, int type, int number,

•                        int mode)
  

+{

•   switch (type) {
  

•   case REGULATOR_TYPE_LDO:
  

•           return max77686_ldo_mode(dev, PMIC_OP_SET, number, &mode);
  

•   case REGULATOR_TYPE_BUCK:
  

•           return max77686_buck_mode(dev, PMIC_OP_SET, number, &mode);
  

•   default:
  

•           return -EPERM;
  

•   }
  

+}

+static const struct dm_regulator_ops reg_max77686_ops = {

•   .get_cnt                = max77686_get_cnt,
  

•   .get_value_desc         = max77686_get_value_desc,
  

•   .get_mode_desc_array    = max77686_get_mode_desc_array,
  

•   .get_value              = max77686_get_value,
  

•   .set_value              = max77686_set_value,
  

•   .get_state              = max77686_get_state,
  

•   .set_state              = max77686_set_state,
  

•   .get_mode               = max77686_get_mode,
  

•   .set_mode               = max77686_set_mode,
  

+};

+U_BOOT_DRIVER(max77686_regulator) = {

•   .name = "max77686 regulator",
  

•   .id = UCLASS_PMIC_REGULATOR,
  

•   .ops = &reg_max77686_ops,
  

•   .ofdata_to_platdata = reg_max77686_ofdata_to_platdata,
  

•   .priv_auto_alloc_size = sizeof(struct max77686_regulator_info),
  

+}; diff --git a/include/power/max77686_pmic.h b/include/power/max77686_pmic.h index fe26d13..81c27d8 100644 --- a/include/power/max77686_pmic.h +++ b/include/power/max77686_pmic.h @@ -126,7 +126,10 @@ enum { };

/* I2C device address for pmic max77686 */ -#define MAX77686_I2C_ADDR (0x12 >> 1) +#define MAX77686_I2C_ADDR (0x12 >> 1) +#define MAX77686_LDO_NUM 26 +#define MAX77686_BUCK_NUM 9 +#define MAX77686_DESC_NUM (MAX77686_LDO_NUM + MAX77686_BUCK_NUM)

enum { REG_DISABLE = 0, @@ -143,23 +146,29 @@ enum {

enum { OPMODE_OFF = 0,

•   OPMODE_STANDBY,
    OPMODE_LPM,
  

•   OPMODE_STANDBY,
  

•   OPMODE_STANDBY_LPM,
    OPMODE_ON,
  

};

+#ifdef CONFIG_POWER int max77686_set_ldo_voltage(struct pmic *p, int ldo, ulong uV); int max77686_set_ldo_mode(struct pmic *p, int ldo, char opmode); int max77686_set_buck_voltage(struct pmic *p, int buck, ulong uV); int max77686_set_buck_mode(struct pmic *p, int buck, char opmode); +#endif

#define MAX77686_LDO_VOLT_MAX_HEX 0x3f #define MAX77686_LDO_VOLT_MASK 0x3f #define MAX77686_LDO_MODE_MASK 0xc0 #define MAX77686_LDO_MODE_OFF (0x00 << 0x06) +#define MAX77686_LDO_MODE_LPM (0x01 << 0x06) #define MAX77686_LDO_MODE_STANDBY (0x01 << 0x06) -#define MAX77686_LDO_MODE_LPM (0x02 << 0x06) +#define MAX77686_LDO_MODE_STANDBY_LPM (0x02 << 0x06) #define MAX77686_LDO_MODE_ON (0x03 << 0x06) +#define MAX77686_BUCK234_VOLT_MAX_HEX 0xff +#define MAX77686_BUCK234_VOLT_MASK 0xff #define MAX77686_BUCK_VOLT_MAX_HEX 0x3f #define MAX77686_BUCK_VOLT_MASK 0x3f #define MAX77686_BUCK_MODE_MASK 0x03 @@ -170,6 +179,15 @@ int max77686_set_buck_mode(struct pmic *p, int buck, char opmode); #define MAX77686_BUCK_MODE_LPM 0x02 #define MAX77686_BUCK_MODE_ON 0x03

+/* For regulator hex<->volt conversion */ +#define MAX77686_LDO_UV_MIN 800000 /* Minimum LDO uV value */ +#define MAX77686_LDO_UV_LSTEP 25000 /* uV lower value step */ +#define MAX77686_LDO_UV_HSTEP 50000 /* uV higher value step */ +#define MAX77686_BUCK_UV_LMIN 600000 /* Lower minimun BUCK value */ +#define MAX77686_BUCK_UV_HMIN 750000 /* Higher minimun BUCK value */ +#define MAX77686_BUCK_UV_LSTEP 12500 /* uV lower value step */ +#define MAX77686_BUCK_UV_HSTEP 50000 /* uV higher value step */

/* Buck1 1 volt value */ #define MAX77686_BUCK1OUT_1V 0x5 /* Buck1 1.05 volt value */ -- 1.9.1

Regards, Simon