// SPDX-License-Identifier: GPL-2.0+ /* * (C) Copyright 2019 * Texas Instruments Incorporated, * * Keerthy */ #include #include #include #include #include #include #include #include /* Single Phase Buck IDs */ #define TPS65941_BUCK_ID_1 1 #define TPS65941_BUCK_ID_2 2 #define TPS65941_BUCK_ID_3 3 #define TPS65941_BUCK_ID_4 4 #define TPS65941_BUCK_ID_5 5 /* Multi Phase Buck IDs */ #define TPS65941_BUCK_ID_12 12 #define TPS65941_BUCK_ID_34 34 #define TPS65941_BUCK_ID_123 123 #define TPS65941_BUCK_ID_1234 1234 /* LDO IDs */ #define TPS65941_LDO_ID_1 1 #define TPS65941_LDO_ID_2 2 #define TPS65941_LDO_ID_3 3 #define TPS65941_LDO_ID_4 4 #define TPS65941_BUCK_CONV_OPS_IDX 0 #define TPS65941_LDO_CONV_OPS_IDX 0 #define TPS65224_LDO_CONV_OPS_IDX 1 #define TPS65224_BUCK_CONV_OPS_IDX 1 struct tps65941_reg_conv_ops { int volt_mask; int (*volt2val)(int idx, int uV); int (*val2volt)(int idx, int volt); int slew_mask; int (*lookup_slew)(int id); }; static const char tps65941_buck_ctrl[TPS65941_BUCK_NUM] = {0x4, 0x6, 0x8, 0xA, 0xC}; static const char tps65941_buck_vout[TPS65941_BUCK_NUM] = {0xE, 0x10, 0x12, 0x14, 0x16}; static const char tps65941_ldo_ctrl[TPS65941_BUCK_NUM] = {0x1D, 0x1E, 0x1F, 0x20}; static const char tps65941_ldo_vout[TPS65941_BUCK_NUM] = {0x23, 0x24, 0x25, 0x26}; static inline int tps65941_get_chip_id(struct udevice *dev) { return dev->parent->driver_data; } static int tps65941_buck_enable(struct udevice *dev, int op, bool *enable) { int ret; unsigned int adr; struct dm_regulator_uclass_plat *uc_pdata; uc_pdata = dev_get_uclass_plat(dev); adr = uc_pdata->ctrl_reg; ret = pmic_reg_read(dev->parent, adr); if (ret < 0) return ret; if (op == PMIC_OP_GET) { ret &= TPS65941_BUCK_MODE_MASK; if (ret) *enable = true; else *enable = false; return 0; } else if (op == PMIC_OP_SET) { if (*enable) ret |= TPS65941_BUCK_MODE_MASK; else ret &= ~TPS65941_BUCK_MODE_MASK; ret = pmic_reg_write(dev->parent, adr, ret); if (ret) return ret; } return 0; } static int tps65941_buck_volt2val(__maybe_unused int idx, int uV) { if (uV > TPS65941_BUCK_VOLT_MAX) return -EINVAL; else if (uV > 1650000) return (uV - 1660000) / 20000 + 0xAB; else if (uV > 1110000) return (uV - 1110000) / 10000 + 0x73; else if (uV > 600000) return (uV - 600000) / 5000 + 0x0F; else if (uV >= 300000) return (uV - 300000) / 20000 + 0x00; else return -EINVAL; } static int tps65941_buck_val2volt(__maybe_unused int idx, int val) { if (val > TPS65941_BUCK_VOLT_MAX_HEX) return -EINVAL; else if (val > 0xAB) return 1660000 + (val - 0xAB) * 20000; else if (val > 0x73) return 1100000 + (val - 0x73) * 10000; else if (val > 0xF) return 600000 + (val - 0xF) * 5000; else if (val >= 0x0) return 300000 + val * 5000; else return -EINVAL; } int tps65941_lookup_slew(int id) { switch (id) { case 0: return 33000; case 1: return 20000; case 2: return 10000; case 3: return 5000; case 4: return 2500; case 5: return 1300; case 6: return 630; case 7: return 310; default: return -1; } } static int tps65224_buck_volt2val(int idx, int uV) { /* This functions maps a value which is in micro Volts to the VSET value. * The mapping is as per the datasheet of TPS65224. */ if (uV > TPS65224_BUCK_VOLT_MAX) return -EINVAL; if (idx > 0) { /* Buck2, Buck3 and Buck4 of TPS65224 has a different schema in * converting b/w micro_volt and VSET hex values * * VSET value starts from 0x00 for 0.5V, and for every increment * in VSET value the output voltage increases by 25mV. This is upto * 1.15V where VSET is 0x1A. * * For 0x1B the output voltage is 1.2V, and for every increment of * VSET the output voltage increases by 50mV upto the max voltage of * 3.3V * * | Voltage Ranges | VSET Ranges | Voltage Step | * +-----------------+--------------+--------------+ * | 0.5V to 1.50V | 0x00 to 0x1A | 25mV | * | 1.2V to 3.3V | 0x1B to 0x45 | 50mV | */ if (uV >= 1200000) return (uV - 1200000) / 50000 + 0x1B; else if (uV >= 500000) return (uV - 500000) / 25000; else return -EINVAL; } /* Buck1 and Buck12(dual phase) has a different mapping b/w output * voltage and VSET value. * * | Voltage Ranges | VSET Ranges | Voltage Step | * +-----------------+--------------+--------------+ * | 0.5V to 0.58V | 0xA to 0xE | 20mV | * | 0.6V to 1.095V | 0xF to 0x72 | 5mV | * | 1.1V to 1.65V | 0x73 to 0xAA | 10mV | * | 1.6V to 3.3V | 0xAB to 0xFD | 20mV | * */ if (uV >= 1660000) return (uV - 1660000) / 20000 + 0xAB; else if (uV >= 1100000) return (uV - 1100000) / 10000 + 0x73; else if (uV >= 600000) return (uV - 600000) / 5000 + 0x0F; else if (uV >= 500000) return (uV - 500000) / 20000 + 0x0A; else return -EINVAL; } static int tps65224_buck_val2volt(int idx, int val) { /* This function does the opposite to the tps65224_buck_volt2val function * described above. * This maps the VSET value to micro volts. Please refer to the ranges * mentioned the comments of tps65224_buck_volt2val. */ if (idx > 0) { if (val > TPS65224_BUCK234_VOLT_MAX_HEX) return -EINVAL; else if (val >= 0x1B) return 1200000 + (val - 0x1B) * 50000; else if (val >= 0x00) return 500000 + (val - 0x00) * 25000; else return -EINVAL; } if (val > TPS65224_BUCK1_VOLT_MAX_HEX) return -EINVAL; else if (val >= 0xAB) return 1660000 + (val - 0xAB) * 20000; else if (val >= 0x73) return 1100000 + (val - 0x73) * 10000; else if (val >= 0xF) return 600000 + (val - 0xF) * 5000; else if (val >= 0xA) return 500000 + (val - 0xA) * 20000; else return -EINVAL; } int tps65224_lookup_slew(int id) { switch (id) { case 0: return 10000; case 1: return 5000; case 2: return 2500; case 3: return 1250; default: return -1; } } static const struct tps65941_reg_conv_ops buck_conv_ops[] = { [TPS65941_BUCK_CONV_OPS_IDX] = { .volt_mask = TPS65941_BUCK_VOLT_MASK, .volt2val = tps65941_buck_volt2val, .val2volt = tps65941_buck_val2volt, .slew_mask = TP65941_BUCK_CONF_SLEW_MASK, .lookup_slew = tps65941_lookup_slew, }, [TPS65224_BUCK_CONV_OPS_IDX] = { .volt_mask = TPS65941_BUCK_VOLT_MASK, .volt2val = tps65224_buck_volt2val, .val2volt = tps65224_buck_val2volt, .slew_mask = TPS65224_BUCK_CONF_SLEW_MASK, .lookup_slew = tps65224_lookup_slew, }, }; static int tps65941_buck_val(struct udevice *dev, int op, int *uV) { unsigned int hex, adr; int ret, delta, uwait, slew, idx; struct dm_regulator_uclass_plat *uc_pdata; const struct tps65941_reg_conv_ops *conv_ops; ulong chip_id; idx = dev->driver_data; chip_id = tps65941_get_chip_id(dev); if (chip_id == TPS65224) { /* idx is the buck id number as per devicetree node which will be same * as the regulator name in the datasheet. * The idx for buck1. buck2, buck3, buck4, buck12 will be 1, 2, 3, 4 * and 12 respectively. * In the driver the numbering is from 0. Hence the -1. */ idx = (idx == TPS65941_BUCK_ID_12) ? 0 : (idx - 1); conv_ops = &buck_conv_ops[TPS65224_BUCK_CONV_OPS_IDX]; } else { conv_ops = &buck_conv_ops[TPS65941_BUCK_CONV_OPS_IDX]; } uc_pdata = dev_get_uclass_plat(dev); if (op == PMIC_OP_GET) *uV = 0; adr = uc_pdata->volt_reg; ret = pmic_reg_read(dev->parent, adr); if (ret < 0) return ret; ret &= conv_ops->volt_mask; ret = conv_ops->val2volt(idx, ret); if (ret < 0) return ret; if (op == PMIC_OP_GET) { *uV = ret; return 0; } /* * Compute the delta voltage, find the slew rate and wait * for the appropriate amount of time after voltage switch */ if (*uV > ret) delta = *uV - ret; else delta = ret - *uV; slew = pmic_reg_read(dev->parent, uc_pdata->ctrl_reg + 1); if (slew < 0) return ret; slew &= conv_ops->slew_mask; slew = conv_ops->lookup_slew(slew); if (slew <= 0) return ret; uwait = delta / slew; hex = conv_ops->volt2val(idx, *uV); if (hex < 0) return hex; ret &= 0x0; ret = hex; ret = pmic_reg_write(dev->parent, adr, ret); udelay(uwait); return ret; } static int tps65941_ldo_enable(struct udevice *dev, int op, bool *enable) { int ret; unsigned int adr; struct dm_regulator_uclass_plat *uc_pdata; uc_pdata = dev_get_uclass_plat(dev); adr = uc_pdata->ctrl_reg; ret = pmic_reg_read(dev->parent, adr); if (ret < 0) return ret; if (op == PMIC_OP_GET) { ret &= TPS65941_LDO_MODE_MASK; if (ret) *enable = true; else *enable = false; return 0; } else if (op == PMIC_OP_SET) { if (*enable) ret |= TPS65941_LDO_MODE_MASK; else ret &= ~TPS65941_LDO_MODE_MASK; ret = pmic_reg_write(dev->parent, adr, ret); if (ret) return ret; } return 0; } static int tps65941_ldo_volt2val(__maybe_unused int idx, int uV) { if (uV > TPS65941_LDO_VOLT_MAX || uV < TPS65941_LDO_VOLT_MIN) return -EINVAL; return ((uV - 600000) / 50000 + 0x4) << TPS65941_LDO_MODE_MASK; } static int tps65941_ldo_val2volt(__maybe_unused int idx, int val) { if (val > TPS65941_LDO_VOLT_MAX_HEX || val < TPS65941_LDO_VOLT_MIN_HEX) return -EINVAL; else if (val >= TPS65941_LDO_VOLT_MIN_HEX) return 600000 + (val - TPS65941_LDO_VOLT_MIN_HEX) * 50000; else return -EINVAL; } static int tps65224_ldo_volt2val(int idx, int uV) { int base = TPS65224_LDO1_VOLT_MIN; int max = TPS65224_LDO1_VOLT_MAX; int offset = TPS65224_LDO1_VOLT_MIN_HEX; int step = TPS65224_LDO_STEP; if (idx > 0) { base = TPS65224_LDO23_VOLT_MIN; max = TPS65224_LDO23_VOLT_MAX; offset = TPS65224_LDO23_VOLT_MIN_HEX; } if (uV > max) return -EINVAL; else if (uV >= base) return (uV - base) / step + offset; else return -EINVAL; } static int tps65224_ldo_val2volt(int idx, int val) { int reg_base = TPS65224_LDO1_VOLT_MIN_HEX; int reg_max = TPS65224_LDO1_VOLT_MAX_HEX; int base = TPS65224_LDO1_VOLT_MIN; int max = TPS65224_LDO1_VOLT_MAX; int step = TPS65224_LDO_STEP; /* In LDOx_VOUT reg the BIT0 is reserved and the * vout value is stored from BIT1 to BIT7. * Hence the below bit shit is done. */ int mask = TPS65224_LDO_VOLT_MASK >> 1; if (idx > 0) { base = TPS65224_LDO23_VOLT_MIN; max = TPS65224_LDO23_VOLT_MAX; reg_base = TPS65224_LDO23_VOLT_MIN_HEX; reg_max = TPS65224_LDO23_VOLT_MAX_HEX; } /* The VSET register of LDO has its 0th bit as reserved * hence shifting the value to right by 1 bit. */ val = val >> 1; if (val < 0 || val > mask) return -EINVAL; if (val <= reg_base) return base; if (val >= reg_max) return max; return base + (step * (val - reg_base)); } static const struct tps65941_reg_conv_ops ldo_conv_ops[] = { [TPS65941_LDO_CONV_OPS_IDX] = { .volt_mask = TPS65941_LDO_VOLT_MASK, .volt2val = tps65941_ldo_volt2val, .val2volt = tps65941_ldo_val2volt, }, [TPS65224_LDO_CONV_OPS_IDX] = { .volt_mask = TPS65224_LDO_VOLT_MASK, .volt2val = tps65224_ldo_volt2val, .val2volt = tps65224_ldo_val2volt, }, }; static int tps65941_ldo_val(struct udevice *dev, int op, int *uV) { unsigned int hex, adr; int ret, ret_volt, idx, ldo_bypass; struct dm_regulator_uclass_plat *uc_pdata; const struct tps65941_reg_conv_ops *conv_ops; ulong chip_id; chip_id = tps65941_get_chip_id(dev); idx = dev->driver_data; if (chip_id == TPS65224) { /* idx is the ldo id number as per devicetree node which will be same * as the regulator name in the datasheet. * The idx for ldo1, ldo2, ldo3 will be 1, 2 & 3 respectively. * In the driver the numbering is from 0. Hence the -1. */ idx = idx - 1; conv_ops = &ldo_conv_ops[TPS65224_LDO_CONV_OPS_IDX]; } else { conv_ops = &ldo_conv_ops[TPS65941_LDO_CONV_OPS_IDX]; } uc_pdata = dev_get_uclass_plat(dev); if (op == PMIC_OP_GET) *uV = 0; adr = uc_pdata->volt_reg; ret = pmic_reg_read(dev->parent, adr); if (ret < 0) return ret; ldo_bypass = ret & TPS65941_LDO_BYPASS_EN; ret &= conv_ops->volt_mask; ret = ret >> TPS65941_LDO_MODE_MASK; ret_volt = conv_ops->val2volt(idx, ret); if (ret_volt < 0) return ret_volt; if (op == PMIC_OP_GET) { *uV = ret_volt; return 0; } /* TPS65224 LDO1 in BYPASS mode only supports 2.2V min to 3.6V max */ if (chip_id == TPS65224 && idx == 0 && (ret & BIT(TPS65224_LDO_BYP_CONFIG)) && *uV < TPS65224_LDO1_VOLT_BYP_MIN) return -EINVAL; /* TPS65224 LDO2 & LDO3 in BYPASS mode supports 1.5V min to 5.5V max */ if (chip_id == TPS65224 && idx > 0 && (ret & BIT(TPS65224_LDO_BYP_CONFIG)) && *uV < TPS65224_LDO23_VOLT_BYP_MIN) return -EINVAL; hex = conv_ops->volt2val(idx, *uV); if (hex < 0) return hex; if (chip_id == TPS65224) { hex = hex << TPS65941_LDO_MODE_MASK; ret &= ~TPS65224_LDO_VOLT_MASK; ret |= hex; } else { ret = hex | ldo_bypass; } ret = pmic_reg_write(dev->parent, adr, ret); return ret; } static int tps65941_ldo_probe(struct udevice *dev) { struct dm_regulator_uclass_plat *uc_pdata; int idx; ulong chip_id; chip_id = tps65941_get_chip_id(dev); uc_pdata = dev_get_uclass_plat(dev); uc_pdata->type = REGULATOR_TYPE_LDO; idx = dev->driver_data; switch (idx) { case TPS65941_LDO_ID_1: case TPS65941_LDO_ID_2: case TPS65941_LDO_ID_3: debug("Single phase regulator\n"); break; case TPS65941_LDO_ID_4: if (chip_id != TPS65224) { debug("Single phase regulator\n"); break; } default: pr_err("Wrong ID for regulator\n"); return -EINVAL; } uc_pdata->ctrl_reg = tps65941_ldo_ctrl[idx - 1]; uc_pdata->volt_reg = tps65941_ldo_vout[idx - 1]; return 0; } static int tps65941_buck_probe(struct udevice *dev) { struct dm_regulator_uclass_plat *uc_pdata; int idx; ulong chip_id; chip_id = tps65941_get_chip_id(dev); uc_pdata = dev_get_uclass_plat(dev); uc_pdata->type = REGULATOR_TYPE_BUCK; idx = dev->driver_data; switch (idx) { case TPS65941_BUCK_ID_1: case TPS65941_BUCK_ID_2: case TPS65941_BUCK_ID_3: case TPS65941_BUCK_ID_4: debug("Single phase regulator\n"); break; case TPS65941_BUCK_ID_5: if (chip_id != TPS65224) { debug("Single phase regulator\n"); } else { pr_err("Wrong ID for regulator\n"); return -EINVAL; } break; case TPS65941_BUCK_ID_12: idx = 1; break; case TPS65941_BUCK_ID_123: case TPS65941_BUCK_ID_1234: if (chip_id != TPS65224) { idx = 1; } else { pr_err("Wrong ID for regulator\n"); return -EINVAL; } break; case TPS65941_BUCK_ID_34: if (chip_id != TPS65224) { idx = 3; } else { pr_err("Wrong ID for regulator\n"); return -EINVAL; } break; default: pr_err("Wrong ID for regulator\n"); return -EINVAL; } uc_pdata->ctrl_reg = tps65941_buck_ctrl[idx - 1]; uc_pdata->volt_reg = tps65941_buck_vout[idx - 1]; return 0; } static int ldo_get_value(struct udevice *dev) { int uV; int ret; ret = tps65941_ldo_val(dev, PMIC_OP_GET, &uV); if (ret) return ret; return uV; } static int ldo_set_value(struct udevice *dev, int uV) { return tps65941_ldo_val(dev, PMIC_OP_SET, &uV); } static int ldo_get_enable(struct udevice *dev) { bool enable = false; int ret; ret = tps65941_ldo_enable(dev, PMIC_OP_GET, &enable); if (ret) return ret; return enable; } static int ldo_set_enable(struct udevice *dev, bool enable) { return tps65941_ldo_enable(dev, PMIC_OP_SET, &enable); } static int buck_get_value(struct udevice *dev) { int uV; int ret; ret = tps65941_buck_val(dev, PMIC_OP_GET, &uV); if (ret) return ret; return uV; } static int buck_set_value(struct udevice *dev, int uV) { return tps65941_buck_val(dev, PMIC_OP_SET, &uV); } static int buck_get_enable(struct udevice *dev) { bool enable = false; int ret; ret = tps65941_buck_enable(dev, PMIC_OP_GET, &enable); if (ret) return ret; return enable; } static int buck_set_enable(struct udevice *dev, bool enable) { return tps65941_buck_enable(dev, PMIC_OP_SET, &enable); } static const struct dm_regulator_ops tps65941_ldo_ops = { .get_value = ldo_get_value, .set_value = ldo_set_value, .get_enable = ldo_get_enable, .set_enable = ldo_set_enable, }; U_BOOT_DRIVER(tps65941_ldo) = { .name = TPS65941_LDO_DRIVER, .id = UCLASS_REGULATOR, .ops = &tps65941_ldo_ops, .probe = tps65941_ldo_probe, }; static const struct dm_regulator_ops tps65941_buck_ops = { .get_value = buck_get_value, .set_value = buck_set_value, .get_enable = buck_get_enable, .set_enable = buck_set_enable, }; U_BOOT_DRIVER(tps65941_buck) = { .name = TPS65941_BUCK_DRIVER, .id = UCLASS_REGULATOR, .ops = &tps65941_buck_ops, .probe = tps65941_buck_probe, };