1 /* 2 * arizona-ldo1.c -- LDO1 supply for Arizona devices 3 * 4 * Copyright 2012 Wolfson Microelectronics PLC. 5 * 6 * Author: Mark Brown <broonie@opensource.wolfsonmicro.com> 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published by the 10 * Free Software Foundation; either version 2 of the License, or (at your 11 * option) any later version. 12 */ 13 14 #include <linux/module.h> 15 #include <linux/moduleparam.h> 16 #include <linux/init.h> 17 #include <linux/bitops.h> 18 #include <linux/err.h> 19 #include <linux/of.h> 20 #include <linux/gpio/consumer.h> 21 #include <linux/platform_device.h> 22 #include <linux/regulator/driver.h> 23 #include <linux/regulator/machine.h> 24 #include <linux/regulator/of_regulator.h> 25 #include <linux/slab.h> 26 27 #include <linux/regulator/arizona-ldo1.h> 28 29 #include <linux/mfd/arizona/core.h> 30 #include <linux/mfd/arizona/pdata.h> 31 #include <linux/mfd/arizona/registers.h> 32 33 struct arizona_ldo1 { 34 struct regulator_dev *regulator; 35 struct regmap *regmap; 36 37 struct regulator_consumer_supply supply; 38 struct regulator_init_data init_data; 39 40 struct gpio_desc *ena_gpiod; 41 }; 42 43 static int arizona_ldo1_hc_list_voltage(struct regulator_dev *rdev, 44 unsigned int selector) 45 { 46 if (selector >= rdev->desc->n_voltages) 47 return -EINVAL; 48 49 if (selector == rdev->desc->n_voltages - 1) 50 return 1800000; 51 else 52 return rdev->desc->min_uV + (rdev->desc->uV_step * selector); 53 } 54 55 static int arizona_ldo1_hc_map_voltage(struct regulator_dev *rdev, 56 int min_uV, int max_uV) 57 { 58 int sel; 59 60 sel = DIV_ROUND_UP(min_uV - rdev->desc->min_uV, rdev->desc->uV_step); 61 if (sel >= rdev->desc->n_voltages) 62 sel = rdev->desc->n_voltages - 1; 63 64 return sel; 65 } 66 67 static int arizona_ldo1_hc_set_voltage_sel(struct regulator_dev *rdev, 68 unsigned sel) 69 { 70 struct arizona_ldo1 *ldo = rdev_get_drvdata(rdev); 71 struct regmap *regmap = ldo->regmap; 72 unsigned int val; 73 int ret; 74 75 if (sel == rdev->desc->n_voltages - 1) 76 val = ARIZONA_LDO1_HI_PWR; 77 else 78 val = 0; 79 80 ret = regmap_update_bits(regmap, ARIZONA_LDO1_CONTROL_2, 81 ARIZONA_LDO1_HI_PWR, val); 82 if (ret != 0) 83 return ret; 84 85 if (val) 86 return 0; 87 88 val = sel << ARIZONA_LDO1_VSEL_SHIFT; 89 90 return regmap_update_bits(regmap, ARIZONA_LDO1_CONTROL_1, 91 ARIZONA_LDO1_VSEL_MASK, val); 92 } 93 94 static int arizona_ldo1_hc_get_voltage_sel(struct regulator_dev *rdev) 95 { 96 struct arizona_ldo1 *ldo = rdev_get_drvdata(rdev); 97 struct regmap *regmap = ldo->regmap; 98 unsigned int val; 99 int ret; 100 101 ret = regmap_read(regmap, ARIZONA_LDO1_CONTROL_2, &val); 102 if (ret != 0) 103 return ret; 104 105 if (val & ARIZONA_LDO1_HI_PWR) 106 return rdev->desc->n_voltages - 1; 107 108 ret = regmap_read(regmap, ARIZONA_LDO1_CONTROL_1, &val); 109 if (ret != 0) 110 return ret; 111 112 return (val & ARIZONA_LDO1_VSEL_MASK) >> ARIZONA_LDO1_VSEL_SHIFT; 113 } 114 115 static const struct regulator_ops arizona_ldo1_hc_ops = { 116 .list_voltage = arizona_ldo1_hc_list_voltage, 117 .map_voltage = arizona_ldo1_hc_map_voltage, 118 .get_voltage_sel = arizona_ldo1_hc_get_voltage_sel, 119 .set_voltage_sel = arizona_ldo1_hc_set_voltage_sel, 120 .get_bypass = regulator_get_bypass_regmap, 121 .set_bypass = regulator_set_bypass_regmap, 122 }; 123 124 static const struct regulator_desc arizona_ldo1_hc = { 125 .name = "LDO1", 126 .supply_name = "LDOVDD", 127 .type = REGULATOR_VOLTAGE, 128 .ops = &arizona_ldo1_hc_ops, 129 130 .bypass_reg = ARIZONA_LDO1_CONTROL_1, 131 .bypass_mask = ARIZONA_LDO1_BYPASS, 132 .min_uV = 900000, 133 .uV_step = 50000, 134 .n_voltages = 8, 135 .enable_time = 1500, 136 .ramp_delay = 24000, 137 138 .owner = THIS_MODULE, 139 }; 140 141 static const struct regulator_ops arizona_ldo1_ops = { 142 .list_voltage = regulator_list_voltage_linear, 143 .map_voltage = regulator_map_voltage_linear, 144 .get_voltage_sel = regulator_get_voltage_sel_regmap, 145 .set_voltage_sel = regulator_set_voltage_sel_regmap, 146 }; 147 148 static const struct regulator_desc arizona_ldo1 = { 149 .name = "LDO1", 150 .supply_name = "LDOVDD", 151 .type = REGULATOR_VOLTAGE, 152 .ops = &arizona_ldo1_ops, 153 154 .vsel_reg = ARIZONA_LDO1_CONTROL_1, 155 .vsel_mask = ARIZONA_LDO1_VSEL_MASK, 156 .min_uV = 900000, 157 .uV_step = 25000, 158 .n_voltages = 13, 159 .enable_time = 500, 160 .ramp_delay = 24000, 161 162 .owner = THIS_MODULE, 163 }; 164 165 static const struct regulator_init_data arizona_ldo1_dvfs = { 166 .constraints = { 167 .min_uV = 1200000, 168 .max_uV = 1800000, 169 .valid_ops_mask = REGULATOR_CHANGE_STATUS | 170 REGULATOR_CHANGE_VOLTAGE, 171 }, 172 .num_consumer_supplies = 1, 173 }; 174 175 static const struct regulator_init_data arizona_ldo1_default = { 176 .constraints = { 177 .valid_ops_mask = REGULATOR_CHANGE_STATUS, 178 }, 179 .num_consumer_supplies = 1, 180 }; 181 182 static const struct regulator_init_data arizona_ldo1_wm5110 = { 183 .constraints = { 184 .min_uV = 1175000, 185 .max_uV = 1200000, 186 .valid_ops_mask = REGULATOR_CHANGE_STATUS | 187 REGULATOR_CHANGE_VOLTAGE, 188 }, 189 .num_consumer_supplies = 1, 190 }; 191 192 static int arizona_ldo1_of_get_pdata(struct arizona_ldo1_pdata *pdata, 193 struct regulator_config *config, 194 const struct regulator_desc *desc, 195 bool *external_dcvdd) 196 { 197 struct arizona_ldo1 *ldo1 = config->driver_data; 198 struct device_node *np = config->dev->of_node; 199 struct device_node *init_node, *dcvdd_node; 200 struct regulator_init_data *init_data; 201 202 init_node = of_get_child_by_name(np, "ldo1"); 203 dcvdd_node = of_parse_phandle(np, "DCVDD-supply", 0); 204 205 if (init_node) { 206 config->of_node = init_node; 207 208 init_data = of_get_regulator_init_data(config->dev, init_node, 209 desc); 210 if (init_data) { 211 init_data->consumer_supplies = &ldo1->supply; 212 init_data->num_consumer_supplies = 1; 213 214 if (dcvdd_node && dcvdd_node != init_node) 215 *external_dcvdd = true; 216 217 pdata->init_data = init_data; 218 } 219 } else if (dcvdd_node) { 220 *external_dcvdd = true; 221 } 222 223 of_node_put(dcvdd_node); 224 225 return 0; 226 } 227 228 static int arizona_ldo1_common_init(struct platform_device *pdev, 229 struct arizona_ldo1 *ldo1, 230 const struct regulator_desc *desc, 231 struct arizona_ldo1_pdata *pdata, 232 bool *external_dcvdd) 233 { 234 struct device *parent_dev = pdev->dev.parent; 235 struct regulator_config config = { }; 236 int ret; 237 238 *external_dcvdd = false; 239 240 ldo1->supply.supply = "DCVDD"; 241 ldo1->init_data.consumer_supplies = &ldo1->supply; 242 ldo1->supply.dev_name = dev_name(parent_dev); 243 244 config.dev = parent_dev; 245 config.driver_data = ldo1; 246 config.regmap = ldo1->regmap; 247 248 if (IS_ENABLED(CONFIG_OF)) { 249 if (!dev_get_platdata(parent_dev)) { 250 ret = arizona_ldo1_of_get_pdata(pdata, 251 &config, desc, 252 external_dcvdd); 253 if (ret < 0) 254 return ret; 255 } 256 } 257 258 /* We assume that high output = regulator off 259 * Don't use devm, since we need to get against the parent device 260 * so clean up would happen at the wrong time 261 */ 262 config.ena_gpiod = gpiod_get_optional(parent_dev, "wlf,ldoena", 263 GPIOD_OUT_LOW | GPIOD_FLAGS_BIT_NONEXCLUSIVE); 264 if (IS_ERR(config.ena_gpiod)) 265 return PTR_ERR(config.ena_gpiod); 266 267 ldo1->ena_gpiod = config.ena_gpiod; 268 269 if (pdata->init_data) 270 config.init_data = pdata->init_data; 271 else 272 config.init_data = &ldo1->init_data; 273 274 /* 275 * LDO1 can only be used to supply DCVDD so if it has no 276 * consumers then DCVDD is supplied externally. 277 */ 278 if (config.init_data->num_consumer_supplies == 0) 279 *external_dcvdd = true; 280 281 ldo1->regulator = devm_regulator_register(&pdev->dev, desc, &config); 282 283 of_node_put(config.of_node); 284 285 if (IS_ERR(ldo1->regulator)) { 286 ret = PTR_ERR(ldo1->regulator); 287 dev_err(&pdev->dev, "Failed to register LDO1 supply: %d\n", 288 ret); 289 return ret; 290 } 291 292 platform_set_drvdata(pdev, ldo1); 293 294 return 0; 295 } 296 297 static int arizona_ldo1_probe(struct platform_device *pdev) 298 { 299 struct arizona *arizona = dev_get_drvdata(pdev->dev.parent); 300 struct arizona_ldo1 *ldo1; 301 const struct regulator_desc *desc; 302 bool external_dcvdd; 303 int ret; 304 305 ldo1 = devm_kzalloc(&pdev->dev, sizeof(*ldo1), GFP_KERNEL); 306 if (!ldo1) 307 return -ENOMEM; 308 309 ldo1->regmap = arizona->regmap; 310 311 /* 312 * Since the chip usually supplies itself we provide some 313 * default init_data for it. This will be overridden with 314 * platform data if provided. 315 */ 316 switch (arizona->type) { 317 case WM5102: 318 case WM8997: 319 case WM8998: 320 case WM1814: 321 desc = &arizona_ldo1_hc; 322 ldo1->init_data = arizona_ldo1_dvfs; 323 break; 324 case WM5110: 325 case WM8280: 326 desc = &arizona_ldo1; 327 ldo1->init_data = arizona_ldo1_wm5110; 328 break; 329 default: 330 desc = &arizona_ldo1; 331 ldo1->init_data = arizona_ldo1_default; 332 break; 333 } 334 335 ret = arizona_ldo1_common_init(pdev, ldo1, desc, 336 &arizona->pdata.ldo1, 337 &external_dcvdd); 338 if (ret == 0) 339 arizona->external_dcvdd = external_dcvdd; 340 341 return ret; 342 } 343 344 static int arizona_ldo1_remove(struct platform_device *pdev) 345 { 346 struct arizona_ldo1 *ldo1 = platform_get_drvdata(pdev); 347 348 if (ldo1->ena_gpiod) 349 gpiod_put(ldo1->ena_gpiod); 350 351 return 0; 352 } 353 354 static struct platform_driver arizona_ldo1_driver = { 355 .probe = arizona_ldo1_probe, 356 .remove = arizona_ldo1_remove, 357 .driver = { 358 .name = "arizona-ldo1", 359 }, 360 }; 361 362 module_platform_driver(arizona_ldo1_driver); 363 364 /* Module information */ 365 MODULE_AUTHOR("Mark Brown <broonie@opensource.wolfsonmicro.com>"); 366 MODULE_DESCRIPTION("Arizona LDO1 driver"); 367 MODULE_LICENSE("GPL"); 368 MODULE_ALIAS("platform:arizona-ldo1"); 369