| // SPDX-License-Identifier: GPL-2.0 |
| // |
| // Copyright (C) 2018 BayLibre SAS |
| // Author: Bartosz Golaszewski <bgolaszewski@baylibre.com> |
| // |
| // Regulator driver for MAXIM 77650/77651 charger/power-supply. |
| |
| #include <linux/of.h> |
| #include <linux/mfd/max77650.h> |
| #include <linux/module.h> |
| #include <linux/platform_device.h> |
| #include <linux/regmap.h> |
| #include <linux/regulator/driver.h> |
| |
| #define MAX77650_REGULATOR_EN_CTRL_MASK GENMASK(3, 0) |
| #define MAX77650_REGULATOR_EN_CTRL_BITS(_reg) \ |
| ((_reg) & MAX77650_REGULATOR_EN_CTRL_MASK) |
| #define MAX77650_REGULATOR_ENABLED GENMASK(2, 1) |
| #define MAX77650_REGULATOR_DISABLED BIT(2) |
| |
| #define MAX77650_REGULATOR_V_LDO_MASK GENMASK(6, 0) |
| #define MAX77650_REGULATOR_V_SBB_MASK GENMASK(5, 0) |
| |
| #define MAX77650_REGULATOR_AD_MASK BIT(3) |
| #define MAX77650_REGULATOR_AD_DISABLED 0x00 |
| #define MAX77650_REGULATOR_AD_ENABLED BIT(3) |
| |
| #define MAX77650_REGULATOR_CURR_LIM_MASK GENMASK(7, 6) |
| |
| enum { |
| MAX77650_REGULATOR_ID_LDO = 0, |
| MAX77650_REGULATOR_ID_SBB0, |
| MAX77650_REGULATOR_ID_SBB1, |
| MAX77650_REGULATOR_ID_SBB2, |
| MAX77650_REGULATOR_NUM_REGULATORS, |
| }; |
| |
| struct max77650_regulator_desc { |
| struct regulator_desc desc; |
| unsigned int regA; |
| unsigned int regB; |
| }; |
| |
| static const u32 max77651_sbb1_regulator_volt_table[] = { |
| 2400000, 3200000, 4000000, 4800000, |
| 2450000, 3250000, 4050000, 4850000, |
| 2500000, 3300000, 4100000, 4900000, |
| 2550000, 3350000, 4150000, 4950000, |
| 2600000, 3400000, 4200000, 5000000, |
| 2650000, 3450000, 4250000, 5050000, |
| 2700000, 3500000, 4300000, 5100000, |
| 2750000, 3550000, 4350000, 5150000, |
| 2800000, 3600000, 4400000, 5200000, |
| 2850000, 3650000, 4450000, 5250000, |
| 2900000, 3700000, 4500000, 0, |
| 2950000, 3750000, 4550000, 0, |
| 3000000, 3800000, 4600000, 0, |
| 3050000, 3850000, 4650000, 0, |
| 3100000, 3900000, 4700000, 0, |
| 3150000, 3950000, 4750000, 0, |
| }; |
| |
| #define MAX77651_REGULATOR_SBB1_SEL_DEC(_val) \ |
| (((_val & 0x3c) >> 2) | ((_val & 0x03) << 4)) |
| #define MAX77651_REGULATOR_SBB1_SEL_ENC(_val) \ |
| (((_val & 0x30) >> 4) | ((_val & 0x0f) << 2)) |
| |
| #define MAX77650_REGULATOR_SBB1_SEL_DECR(_val) \ |
| do { \ |
| _val = MAX77651_REGULATOR_SBB1_SEL_DEC(_val); \ |
| _val--; \ |
| _val = MAX77651_REGULATOR_SBB1_SEL_ENC(_val); \ |
| } while (0) |
| |
| #define MAX77650_REGULATOR_SBB1_SEL_INCR(_val) \ |
| do { \ |
| _val = MAX77651_REGULATOR_SBB1_SEL_DEC(_val); \ |
| _val++; \ |
| _val = MAX77651_REGULATOR_SBB1_SEL_ENC(_val); \ |
| } while (0) |
| |
| static const unsigned int max77650_current_limit_table[] = { |
| 1000000, 866000, 707000, 500000, |
| }; |
| |
| static int max77650_regulator_is_enabled(struct regulator_dev *rdev) |
| { |
| struct max77650_regulator_desc *rdesc; |
| struct regmap *map; |
| int val, rv, en; |
| |
| rdesc = rdev_get_drvdata(rdev); |
| map = rdev_get_regmap(rdev); |
| |
| rv = regmap_read(map, rdesc->regB, &val); |
| if (rv) |
| return rv; |
| |
| en = MAX77650_REGULATOR_EN_CTRL_BITS(val); |
| |
| return en != MAX77650_REGULATOR_DISABLED; |
| } |
| |
| static int max77650_regulator_enable(struct regulator_dev *rdev) |
| { |
| struct max77650_regulator_desc *rdesc; |
| struct regmap *map; |
| |
| rdesc = rdev_get_drvdata(rdev); |
| map = rdev_get_regmap(rdev); |
| |
| return regmap_update_bits(map, rdesc->regB, |
| MAX77650_REGULATOR_EN_CTRL_MASK, |
| MAX77650_REGULATOR_ENABLED); |
| } |
| |
| static int max77650_regulator_disable(struct regulator_dev *rdev) |
| { |
| struct max77650_regulator_desc *rdesc; |
| struct regmap *map; |
| |
| rdesc = rdev_get_drvdata(rdev); |
| map = rdev_get_regmap(rdev); |
| |
| return regmap_update_bits(map, rdesc->regB, |
| MAX77650_REGULATOR_EN_CTRL_MASK, |
| MAX77650_REGULATOR_DISABLED); |
| } |
| |
| static int max77650_regulator_set_voltage_sel(struct regulator_dev *rdev, |
| unsigned int sel) |
| { |
| int rv = 0, curr, diff; |
| bool ascending; |
| |
| /* |
| * If the regulator is disabled, we can program the desired |
| * voltage right away. |
| */ |
| if (!max77650_regulator_is_enabled(rdev)) |
| return regulator_set_voltage_sel_regmap(rdev, sel); |
| |
| /* |
| * Otherwise we need to manually ramp the output voltage up/down |
| * one step at a time. |
| */ |
| |
| curr = regulator_get_voltage_sel_regmap(rdev); |
| if (curr < 0) |
| return curr; |
| |
| diff = curr - sel; |
| if (diff == 0) |
| return 0; /* Already there. */ |
| else if (diff > 0) |
| ascending = false; |
| else |
| ascending = true; |
| |
| /* |
| * Make sure we'll get to the right voltage and break the loop even if |
| * the selector equals 0. |
| */ |
| for (ascending ? curr++ : curr--;; ascending ? curr++ : curr--) { |
| rv = regulator_set_voltage_sel_regmap(rdev, curr); |
| if (rv) |
| return rv; |
| |
| if (curr == sel) |
| break; |
| } |
| |
| return 0; |
| } |
| |
| /* |
| * Special case: non-linear voltage table for max77651 SBB1 - software |
| * must ensure the voltage is ramped in 50mV increments. |
| */ |
| static int max77651_regulator_sbb1_set_voltage_sel(struct regulator_dev *rdev, |
| unsigned int sel) |
| { |
| int rv = 0, curr, vcurr, vdest, vdiff; |
| |
| /* |
| * If the regulator is disabled, we can program the desired |
| * voltage right away. |
| */ |
| if (!max77650_regulator_is_enabled(rdev)) |
| return regulator_set_voltage_sel_regmap(rdev, sel); |
| |
| curr = regulator_get_voltage_sel_regmap(rdev); |
| if (curr < 0) |
| return curr; |
| |
| if (curr == sel) |
| return 0; /* Already there. */ |
| |
| vcurr = max77651_sbb1_regulator_volt_table[curr]; |
| vdest = max77651_sbb1_regulator_volt_table[sel]; |
| vdiff = vcurr - vdest; |
| |
| for (;;) { |
| if (vdiff > 0) |
| MAX77650_REGULATOR_SBB1_SEL_DECR(curr); |
| else |
| MAX77650_REGULATOR_SBB1_SEL_INCR(curr); |
| |
| rv = regulator_set_voltage_sel_regmap(rdev, curr); |
| if (rv) |
| return rv; |
| |
| if (curr == sel) |
| break; |
| }; |
| |
| return 0; |
| } |
| |
| static const struct regulator_ops max77650_regulator_LDO_ops = { |
| .is_enabled = max77650_regulator_is_enabled, |
| .enable = max77650_regulator_enable, |
| .disable = max77650_regulator_disable, |
| .list_voltage = regulator_list_voltage_linear, |
| .map_voltage = regulator_map_voltage_linear, |
| .get_voltage_sel = regulator_get_voltage_sel_regmap, |
| .set_voltage_sel = max77650_regulator_set_voltage_sel, |
| .set_active_discharge = regulator_set_active_discharge_regmap, |
| }; |
| |
| static const struct regulator_ops max77650_regulator_SBB_ops = { |
| .is_enabled = max77650_regulator_is_enabled, |
| .enable = max77650_regulator_enable, |
| .disable = max77650_regulator_disable, |
| .list_voltage = regulator_list_voltage_linear, |
| .map_voltage = regulator_map_voltage_linear, |
| .get_voltage_sel = regulator_get_voltage_sel_regmap, |
| .set_voltage_sel = max77650_regulator_set_voltage_sel, |
| .get_current_limit = regulator_get_current_limit_regmap, |
| .set_current_limit = regulator_set_current_limit_regmap, |
| .set_active_discharge = regulator_set_active_discharge_regmap, |
| }; |
| |
| /* Special case for max77651 SBB1 - non-linear voltage mapping. */ |
| static const struct regulator_ops max77651_SBB1_regulator_ops = { |
| .is_enabled = max77650_regulator_is_enabled, |
| .enable = max77650_regulator_enable, |
| .disable = max77650_regulator_disable, |
| .list_voltage = regulator_list_voltage_table, |
| .get_voltage_sel = regulator_get_voltage_sel_regmap, |
| .set_voltage_sel = max77651_regulator_sbb1_set_voltage_sel, |
| .get_current_limit = regulator_get_current_limit_regmap, |
| .set_current_limit = regulator_set_current_limit_regmap, |
| .set_active_discharge = regulator_set_active_discharge_regmap, |
| }; |
| |
| static struct max77650_regulator_desc max77650_LDO_desc = { |
| .desc = { |
| .name = "ldo", |
| .of_match = of_match_ptr("ldo"), |
| .regulators_node = of_match_ptr("regulators"), |
| .supply_name = "in-ldo", |
| .id = MAX77650_REGULATOR_ID_LDO, |
| .ops = &max77650_regulator_LDO_ops, |
| .min_uV = 1350000, |
| .uV_step = 12500, |
| .n_voltages = 128, |
| .vsel_mask = MAX77650_REGULATOR_V_LDO_MASK, |
| .vsel_reg = MAX77650_REG_CNFG_LDO_A, |
| .active_discharge_off = MAX77650_REGULATOR_AD_DISABLED, |
| .active_discharge_on = MAX77650_REGULATOR_AD_ENABLED, |
| .active_discharge_mask = MAX77650_REGULATOR_AD_MASK, |
| .active_discharge_reg = MAX77650_REG_CNFG_LDO_B, |
| .enable_time = 100, |
| .type = REGULATOR_VOLTAGE, |
| .owner = THIS_MODULE, |
| }, |
| .regA = MAX77650_REG_CNFG_LDO_A, |
| .regB = MAX77650_REG_CNFG_LDO_B, |
| }; |
| |
| static struct max77650_regulator_desc max77650_SBB0_desc = { |
| .desc = { |
| .name = "sbb0", |
| .of_match = of_match_ptr("sbb0"), |
| .regulators_node = of_match_ptr("regulators"), |
| .supply_name = "in-sbb0", |
| .id = MAX77650_REGULATOR_ID_SBB0, |
| .ops = &max77650_regulator_SBB_ops, |
| .min_uV = 800000, |
| .uV_step = 25000, |
| .n_voltages = 64, |
| .vsel_mask = MAX77650_REGULATOR_V_SBB_MASK, |
| .vsel_reg = MAX77650_REG_CNFG_SBB0_A, |
| .active_discharge_off = MAX77650_REGULATOR_AD_DISABLED, |
| .active_discharge_on = MAX77650_REGULATOR_AD_ENABLED, |
| .active_discharge_mask = MAX77650_REGULATOR_AD_MASK, |
| .active_discharge_reg = MAX77650_REG_CNFG_SBB0_B, |
| .enable_time = 100, |
| .type = REGULATOR_VOLTAGE, |
| .owner = THIS_MODULE, |
| .csel_reg = MAX77650_REG_CNFG_SBB0_A, |
| .csel_mask = MAX77650_REGULATOR_CURR_LIM_MASK, |
| .curr_table = max77650_current_limit_table, |
| .n_current_limits = ARRAY_SIZE(max77650_current_limit_table), |
| }, |
| .regA = MAX77650_REG_CNFG_SBB0_A, |
| .regB = MAX77650_REG_CNFG_SBB0_B, |
| }; |
| |
| static struct max77650_regulator_desc max77650_SBB1_desc = { |
| .desc = { |
| .name = "sbb1", |
| .of_match = of_match_ptr("sbb1"), |
| .regulators_node = of_match_ptr("regulators"), |
| .supply_name = "in-sbb1", |
| .id = MAX77650_REGULATOR_ID_SBB1, |
| .ops = &max77650_regulator_SBB_ops, |
| .min_uV = 800000, |
| .uV_step = 12500, |
| .n_voltages = 64, |
| .vsel_mask = MAX77650_REGULATOR_V_SBB_MASK, |
| .vsel_reg = MAX77650_REG_CNFG_SBB1_A, |
| .active_discharge_off = MAX77650_REGULATOR_AD_DISABLED, |
| .active_discharge_on = MAX77650_REGULATOR_AD_ENABLED, |
| .active_discharge_mask = MAX77650_REGULATOR_AD_MASK, |
| .active_discharge_reg = MAX77650_REG_CNFG_SBB1_B, |
| .enable_time = 100, |
| .type = REGULATOR_VOLTAGE, |
| .owner = THIS_MODULE, |
| .csel_reg = MAX77650_REG_CNFG_SBB1_A, |
| .csel_mask = MAX77650_REGULATOR_CURR_LIM_MASK, |
| .curr_table = max77650_current_limit_table, |
| .n_current_limits = ARRAY_SIZE(max77650_current_limit_table), |
| }, |
| .regA = MAX77650_REG_CNFG_SBB1_A, |
| .regB = MAX77650_REG_CNFG_SBB1_B, |
| }; |
| |
| static struct max77650_regulator_desc max77651_SBB1_desc = { |
| .desc = { |
| .name = "sbb1", |
| .of_match = of_match_ptr("sbb1"), |
| .regulators_node = of_match_ptr("regulators"), |
| .supply_name = "in-sbb1", |
| .id = MAX77650_REGULATOR_ID_SBB1, |
| .ops = &max77651_SBB1_regulator_ops, |
| .volt_table = max77651_sbb1_regulator_volt_table, |
| .n_voltages = ARRAY_SIZE(max77651_sbb1_regulator_volt_table), |
| .vsel_mask = MAX77650_REGULATOR_V_SBB_MASK, |
| .vsel_reg = MAX77650_REG_CNFG_SBB1_A, |
| .active_discharge_off = MAX77650_REGULATOR_AD_DISABLED, |
| .active_discharge_on = MAX77650_REGULATOR_AD_ENABLED, |
| .active_discharge_mask = MAX77650_REGULATOR_AD_MASK, |
| .active_discharge_reg = MAX77650_REG_CNFG_SBB1_B, |
| .enable_time = 100, |
| .type = REGULATOR_VOLTAGE, |
| .owner = THIS_MODULE, |
| .csel_reg = MAX77650_REG_CNFG_SBB1_A, |
| .csel_mask = MAX77650_REGULATOR_CURR_LIM_MASK, |
| .curr_table = max77650_current_limit_table, |
| .n_current_limits = ARRAY_SIZE(max77650_current_limit_table), |
| }, |
| .regA = MAX77650_REG_CNFG_SBB1_A, |
| .regB = MAX77650_REG_CNFG_SBB1_B, |
| }; |
| |
| static struct max77650_regulator_desc max77650_SBB2_desc = { |
| .desc = { |
| .name = "sbb2", |
| .of_match = of_match_ptr("sbb2"), |
| .regulators_node = of_match_ptr("regulators"), |
| .supply_name = "in-sbb0", |
| .id = MAX77650_REGULATOR_ID_SBB2, |
| .ops = &max77650_regulator_SBB_ops, |
| .min_uV = 800000, |
| .uV_step = 50000, |
| .n_voltages = 64, |
| .vsel_mask = MAX77650_REGULATOR_V_SBB_MASK, |
| .vsel_reg = MAX77650_REG_CNFG_SBB2_A, |
| .active_discharge_off = MAX77650_REGULATOR_AD_DISABLED, |
| .active_discharge_on = MAX77650_REGULATOR_AD_ENABLED, |
| .active_discharge_mask = MAX77650_REGULATOR_AD_MASK, |
| .active_discharge_reg = MAX77650_REG_CNFG_SBB2_B, |
| .enable_time = 100, |
| .type = REGULATOR_VOLTAGE, |
| .owner = THIS_MODULE, |
| .csel_reg = MAX77650_REG_CNFG_SBB2_A, |
| .csel_mask = MAX77650_REGULATOR_CURR_LIM_MASK, |
| .curr_table = max77650_current_limit_table, |
| .n_current_limits = ARRAY_SIZE(max77650_current_limit_table), |
| }, |
| .regA = MAX77650_REG_CNFG_SBB2_A, |
| .regB = MAX77650_REG_CNFG_SBB2_B, |
| }; |
| |
| static struct max77650_regulator_desc max77651_SBB2_desc = { |
| .desc = { |
| .name = "sbb2", |
| .of_match = of_match_ptr("sbb2"), |
| .regulators_node = of_match_ptr("regulators"), |
| .supply_name = "in-sbb0", |
| .id = MAX77650_REGULATOR_ID_SBB2, |
| .ops = &max77650_regulator_SBB_ops, |
| .min_uV = 2400000, |
| .uV_step = 50000, |
| .n_voltages = 64, |
| .vsel_mask = MAX77650_REGULATOR_V_SBB_MASK, |
| .vsel_reg = MAX77650_REG_CNFG_SBB2_A, |
| .active_discharge_off = MAX77650_REGULATOR_AD_DISABLED, |
| .active_discharge_on = MAX77650_REGULATOR_AD_ENABLED, |
| .active_discharge_mask = MAX77650_REGULATOR_AD_MASK, |
| .active_discharge_reg = MAX77650_REG_CNFG_SBB2_B, |
| .enable_time = 100, |
| .type = REGULATOR_VOLTAGE, |
| .owner = THIS_MODULE, |
| .csel_reg = MAX77650_REG_CNFG_SBB2_A, |
| .csel_mask = MAX77650_REGULATOR_CURR_LIM_MASK, |
| .curr_table = max77650_current_limit_table, |
| .n_current_limits = ARRAY_SIZE(max77650_current_limit_table), |
| }, |
| .regA = MAX77650_REG_CNFG_SBB2_A, |
| .regB = MAX77650_REG_CNFG_SBB2_B, |
| }; |
| |
| static int max77650_regulator_probe(struct platform_device *pdev) |
| { |
| struct max77650_regulator_desc **rdescs; |
| struct max77650_regulator_desc *rdesc; |
| struct regulator_config config = { }; |
| struct device *dev, *parent; |
| struct regulator_dev *rdev; |
| struct regmap *map; |
| unsigned int val; |
| int i, rv; |
| |
| dev = &pdev->dev; |
| parent = dev->parent; |
| |
| if (!dev->of_node) |
| dev->of_node = parent->of_node; |
| |
| rdescs = devm_kcalloc(dev, MAX77650_REGULATOR_NUM_REGULATORS, |
| sizeof(*rdescs), GFP_KERNEL); |
| if (!rdescs) |
| return -ENOMEM; |
| |
| map = dev_get_regmap(parent, NULL); |
| if (!map) |
| return -ENODEV; |
| |
| rv = regmap_read(map, MAX77650_REG_CID, &val); |
| if (rv) |
| return rv; |
| |
| rdescs[MAX77650_REGULATOR_ID_LDO] = &max77650_LDO_desc; |
| rdescs[MAX77650_REGULATOR_ID_SBB0] = &max77650_SBB0_desc; |
| |
| switch (MAX77650_CID_BITS(val)) { |
| case MAX77650_CID_77650A: |
| case MAX77650_CID_77650C: |
| rdescs[MAX77650_REGULATOR_ID_SBB1] = &max77650_SBB1_desc; |
| rdescs[MAX77650_REGULATOR_ID_SBB2] = &max77650_SBB2_desc; |
| break; |
| case MAX77650_CID_77651A: |
| case MAX77650_CID_77651B: |
| rdescs[MAX77650_REGULATOR_ID_SBB1] = &max77651_SBB1_desc; |
| rdescs[MAX77650_REGULATOR_ID_SBB2] = &max77651_SBB2_desc; |
| break; |
| default: |
| return -ENODEV; |
| } |
| |
| config.dev = parent; |
| |
| for (i = 0; i < MAX77650_REGULATOR_NUM_REGULATORS; i++) { |
| rdesc = rdescs[i]; |
| config.driver_data = rdesc; |
| |
| rdev = devm_regulator_register(dev, &rdesc->desc, &config); |
| if (IS_ERR(rdev)) |
| return PTR_ERR(rdev); |
| } |
| |
| return 0; |
| } |
| |
| static struct platform_driver max77650_regulator_driver = { |
| .driver = { |
| .name = "max77650-regulator", |
| }, |
| .probe = max77650_regulator_probe, |
| }; |
| module_platform_driver(max77650_regulator_driver); |
| |
| MODULE_DESCRIPTION("MAXIM 77650/77651 regulator driver"); |
| MODULE_AUTHOR("Bartosz Golaszewski <bgolaszewski@baylibre.com>"); |
| MODULE_LICENSE("GPL v2"); |
