1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Device driver for regulators in Hisi IC 4 // 5 // Copyright (c) 2013 Linaro Ltd. 6 // Copyright (c) 2011 Hisilicon. 7 // Copyright (c) 2020-2021 Huawei Technologies Co., Ltd 8 // 9 // Guodong Xu <guodong.xu@linaro.org> 10 11 #include <linux/delay.h> 12 #include <linux/mfd/hi6421-spmi-pmic.h> 13 #include <linux/module.h> 14 #include <linux/platform_device.h> 15 #include <linux/regmap.h> 16 #include <linux/regulator/driver.h> 17 #include <linux/spmi.h> 18 19 struct hi6421_spmi_reg_info { 20 struct regulator_desc desc; 21 u8 eco_mode_mask; 22 u32 eco_uA; 23 24 /* Serialize regulator enable logic */ 25 struct mutex enable_mutex; 26 }; 27 28 static const unsigned int ldo3_voltages[] = { 29 1500000, 1550000, 1600000, 1650000, 30 1700000, 1725000, 1750000, 1775000, 31 1800000, 1825000, 1850000, 1875000, 32 1900000, 1925000, 1950000, 2000000 33 }; 34 35 static const unsigned int ldo4_voltages[] = { 36 1725000, 1750000, 1775000, 1800000, 37 1825000, 1850000, 1875000, 1900000 38 }; 39 40 static const unsigned int ldo9_voltages[] = { 41 1750000, 1800000, 1825000, 2800000, 42 2850000, 2950000, 3000000, 3300000 43 }; 44 45 static const unsigned int ldo15_voltages[] = { 46 1800000, 1850000, 2400000, 2600000, 47 2700000, 2850000, 2950000, 3000000 48 }; 49 50 static const unsigned int ldo17_voltages[] = { 51 2500000, 2600000, 2700000, 2800000, 52 3000000, 3100000, 3200000, 3300000 53 }; 54 55 static const unsigned int ldo34_voltages[] = { 56 2600000, 2700000, 2800000, 2900000, 57 3000000, 3100000, 3200000, 3300000 58 }; 59 60 /** 61 * HI6421V600_LDO() - specify a LDO power line 62 * @_id: LDO id name string 63 * @vtable: voltage table 64 * @ereg: enable register 65 * @emask: enable mask 66 * @vreg: voltage select register 67 * @odelay: off/on delay time in uS 68 * @etime: enable time in uS 69 * @ecomask: eco mode mask 70 * @ecoamp: eco mode load uppler limit in uA 71 */ 72 #define HI6421V600_LDO(_id, vtable, ereg, emask, vreg, \ 73 odelay, etime, ecomask, ecoamp) \ 74 [HI6421V600_##_id] = { \ 75 .desc = { \ 76 .name = #_id, \ 77 .of_match = of_match_ptr(#_id), \ 78 .regulators_node = of_match_ptr("regulators"), \ 79 .ops = &hi6421_spmi_ldo_rops, \ 80 .type = REGULATOR_VOLTAGE, \ 81 .id = HI6421V600_##_id, \ 82 .owner = THIS_MODULE, \ 83 .volt_table = vtable, \ 84 .n_voltages = ARRAY_SIZE(vtable), \ 85 .vsel_mask = (1 << (ARRAY_SIZE(vtable) - 1)) - 1, \ 86 .vsel_reg = vreg, \ 87 .enable_reg = ereg, \ 88 .enable_mask = emask, \ 89 .enable_time = etime, \ 90 .ramp_delay = etime, \ 91 .off_on_delay = odelay, \ 92 }, \ 93 .eco_mode_mask = ecomask, \ 94 .eco_uA = ecoamp, \ 95 } 96 97 static int hi6421_spmi_regulator_enable(struct regulator_dev *rdev) 98 { 99 struct hi6421_spmi_reg_info *sreg = rdev_get_drvdata(rdev); 100 int ret; 101 102 /* cannot enable more than one regulator at one time */ 103 mutex_lock(&sreg->enable_mutex); 104 105 ret = regmap_update_bits(rdev->regmap, rdev->desc->enable_reg, 106 rdev->desc->enable_mask, 107 rdev->desc->enable_mask); 108 109 /* Avoid powering up multiple devices at the same time */ 110 usleep_range(rdev->desc->off_on_delay, rdev->desc->off_on_delay + 60); 111 112 mutex_unlock(&sreg->enable_mutex); 113 114 return ret; 115 } 116 117 static unsigned int hi6421_spmi_regulator_get_mode(struct regulator_dev *rdev) 118 { 119 struct hi6421_spmi_reg_info *sreg = rdev_get_drvdata(rdev); 120 u32 reg_val; 121 122 regmap_read(rdev->regmap, rdev->desc->enable_reg, ®_val); 123 124 if (reg_val & sreg->eco_mode_mask) 125 return REGULATOR_MODE_IDLE; 126 127 return REGULATOR_MODE_NORMAL; 128 } 129 130 static int hi6421_spmi_regulator_set_mode(struct regulator_dev *rdev, 131 unsigned int mode) 132 { 133 struct hi6421_spmi_reg_info *sreg = rdev_get_drvdata(rdev); 134 u32 val; 135 136 switch (mode) { 137 case REGULATOR_MODE_NORMAL: 138 val = 0; 139 break; 140 case REGULATOR_MODE_IDLE: 141 val = sreg->eco_mode_mask << (ffs(sreg->eco_mode_mask) - 1); 142 break; 143 default: 144 return -EINVAL; 145 } 146 147 return regmap_update_bits(rdev->regmap, rdev->desc->enable_reg, 148 sreg->eco_mode_mask, val); 149 } 150 151 static unsigned int 152 hi6421_spmi_regulator_get_optimum_mode(struct regulator_dev *rdev, 153 int input_uV, int output_uV, 154 int load_uA) 155 { 156 struct hi6421_spmi_reg_info *sreg = rdev_get_drvdata(rdev); 157 158 if (!sreg->eco_uA || ((unsigned int)load_uA > sreg->eco_uA)) 159 return REGULATOR_MODE_NORMAL; 160 161 return REGULATOR_MODE_IDLE; 162 } 163 164 static const struct regulator_ops hi6421_spmi_ldo_rops = { 165 .is_enabled = regulator_is_enabled_regmap, 166 .enable = hi6421_spmi_regulator_enable, 167 .disable = regulator_disable_regmap, 168 .list_voltage = regulator_list_voltage_table, 169 .map_voltage = regulator_map_voltage_iterate, 170 .get_voltage_sel = regulator_get_voltage_sel_regmap, 171 .set_voltage_sel = regulator_set_voltage_sel_regmap, 172 .get_mode = hi6421_spmi_regulator_get_mode, 173 .set_mode = hi6421_spmi_regulator_set_mode, 174 .get_optimum_mode = hi6421_spmi_regulator_get_optimum_mode, 175 }; 176 177 /* HI6421v600 regulators with known registers */ 178 enum hi6421_spmi_regulator_id { 179 HI6421V600_LDO3, 180 HI6421V600_LDO4, 181 HI6421V600_LDO9, 182 HI6421V600_LDO15, 183 HI6421V600_LDO16, 184 HI6421V600_LDO17, 185 HI6421V600_LDO33, 186 HI6421V600_LDO34, 187 }; 188 189 static struct hi6421_spmi_reg_info regulator_info[] = { 190 HI6421V600_LDO(LDO3, ldo3_voltages, 191 0x16, 0x01, 0x51, 192 20000, 120, 193 0, 0), 194 HI6421V600_LDO(LDO4, ldo4_voltages, 195 0x17, 0x01, 0x52, 196 20000, 120, 197 0x10, 10000), 198 HI6421V600_LDO(LDO9, ldo9_voltages, 199 0x1c, 0x01, 0x57, 200 20000, 360, 201 0x10, 10000), 202 HI6421V600_LDO(LDO15, ldo15_voltages, 203 0x21, 0x01, 0x5c, 204 20000, 360, 205 0x10, 10000), 206 HI6421V600_LDO(LDO16, ldo15_voltages, 207 0x22, 0x01, 0x5d, 208 20000, 360, 209 0x10, 10000), 210 HI6421V600_LDO(LDO17, ldo17_voltages, 211 0x23, 0x01, 0x5e, 212 20000, 120, 213 0x10, 10000), 214 HI6421V600_LDO(LDO33, ldo17_voltages, 215 0x32, 0x01, 0x6d, 216 20000, 120, 217 0, 0), 218 HI6421V600_LDO(LDO34, ldo34_voltages, 219 0x33, 0x01, 0x6e, 220 20000, 120, 221 0, 0), 222 }; 223 224 static int hi6421_spmi_regulator_probe(struct platform_device *pdev) 225 { 226 struct device *pmic_dev = pdev->dev.parent; 227 struct regulator_config config = { }; 228 struct hi6421_spmi_reg_info *sreg; 229 struct hi6421_spmi_reg_info *info; 230 struct device *dev = &pdev->dev; 231 struct hi6421_spmi_pmic *pmic; 232 struct regulator_dev *rdev; 233 int i; 234 235 /* 236 * This driver is meant to be called by hi6421-spmi-core, 237 * which should first set drvdata. If this doesn't happen, hit 238 * a warn on and return. 239 */ 240 pmic = dev_get_drvdata(pmic_dev); 241 if (WARN_ON(!pmic)) 242 return -ENODEV; 243 244 sreg = devm_kzalloc(dev, sizeof(*sreg), GFP_KERNEL); 245 if (!sreg) 246 return -ENOMEM; 247 248 mutex_init(&sreg->enable_mutex); 249 250 for (i = 0; i < ARRAY_SIZE(regulator_info); i++) { 251 info = ®ulator_info[i]; 252 253 config.dev = pdev->dev.parent; 254 config.driver_data = sreg; 255 config.regmap = pmic->regmap; 256 257 rdev = devm_regulator_register(dev, &info->desc, &config); 258 if (IS_ERR(rdev)) { 259 dev_err(dev, "failed to register %s\n", 260 info->desc.name); 261 return PTR_ERR(rdev); 262 } 263 } 264 265 return 0; 266 } 267 268 static const struct platform_device_id hi6421_spmi_regulator_table[] = { 269 { .name = "hi6421v600-regulator" }, 270 {}, 271 }; 272 MODULE_DEVICE_TABLE(platform, hi6421_spmi_regulator_table); 273 274 static struct platform_driver hi6421_spmi_regulator_driver = { 275 .id_table = hi6421_spmi_regulator_table, 276 .driver = { 277 .name = "hi6421v600-regulator", 278 }, 279 .probe = hi6421_spmi_regulator_probe, 280 }; 281 module_platform_driver(hi6421_spmi_regulator_driver); 282 283 MODULE_DESCRIPTION("Hi6421v600 SPMI regulator driver"); 284 MODULE_LICENSE("GPL v2"); 285 286