1 /* 2 * Regulator driver for TI TPS6586x 3 * 4 * Copyright (C) 2010 Compulab Ltd. 5 * Author: Mike Rapoport <mike@compulab.co.il> 6 * 7 * Based on da903x 8 * Copyright (C) 2006-2008 Marvell International Ltd. 9 * Copyright (C) 2008 Compulab Ltd. 10 * 11 * This program is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License version 2 as 13 * published by the Free Software Foundation. 14 */ 15 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/init.h> 19 #include <linux/err.h> 20 #include <linux/of.h> 21 #include <linux/slab.h> 22 #include <linux/platform_device.h> 23 #include <linux/regulator/driver.h> 24 #include <linux/regulator/machine.h> 25 #include <linux/regulator/of_regulator.h> 26 #include <linux/mfd/tps6586x.h> 27 28 /* supply control and voltage setting */ 29 #define TPS6586X_SUPPLYENA 0x10 30 #define TPS6586X_SUPPLYENB 0x11 31 #define TPS6586X_SUPPLYENC 0x12 32 #define TPS6586X_SUPPLYEND 0x13 33 #define TPS6586X_SUPPLYENE 0x14 34 #define TPS6586X_VCC1 0x20 35 #define TPS6586X_VCC2 0x21 36 #define TPS6586X_SM1V1 0x23 37 #define TPS6586X_SM1V2 0x24 38 #define TPS6586X_SM1SL 0x25 39 #define TPS6586X_SM0V1 0x26 40 #define TPS6586X_SM0V2 0x27 41 #define TPS6586X_SM0SL 0x28 42 #define TPS6586X_LDO2AV1 0x29 43 #define TPS6586X_LDO2AV2 0x2A 44 #define TPS6586X_LDO2BV1 0x2F 45 #define TPS6586X_LDO2BV2 0x30 46 #define TPS6586X_LDO4V1 0x32 47 #define TPS6586X_LDO4V2 0x33 48 49 /* converter settings */ 50 #define TPS6586X_SUPPLYV1 0x41 51 #define TPS6586X_SUPPLYV2 0x42 52 #define TPS6586X_SUPPLYV3 0x43 53 #define TPS6586X_SUPPLYV4 0x44 54 #define TPS6586X_SUPPLYV5 0x45 55 #define TPS6586X_SUPPLYV6 0x46 56 #define TPS6586X_SMODE1 0x47 57 #define TPS6586X_SMODE2 0x48 58 59 struct tps6586x_regulator { 60 struct regulator_desc desc; 61 62 int enable_bit[2]; 63 int enable_reg[2]; 64 }; 65 66 static inline struct device *to_tps6586x_dev(struct regulator_dev *rdev) 67 { 68 return rdev_get_dev(rdev)->parent; 69 } 70 71 static struct regulator_ops tps6586x_regulator_ops = { 72 .list_voltage = regulator_list_voltage_table, 73 .map_voltage = regulator_map_voltage_ascend, 74 .get_voltage_sel = regulator_get_voltage_sel_regmap, 75 .set_voltage_sel = regulator_set_voltage_sel_regmap, 76 77 .is_enabled = regulator_is_enabled_regmap, 78 .enable = regulator_enable_regmap, 79 .disable = regulator_disable_regmap, 80 }; 81 82 static struct regulator_ops tps6586x_sys_regulator_ops = { 83 }; 84 85 static const unsigned int tps6586x_ldo0_voltages[] = { 86 1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000, 87 }; 88 89 static const unsigned int tps6586x_ldo4_voltages[] = { 90 1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000, 91 1900000, 1925000, 1950000, 1975000, 2000000, 2025000, 2050000, 2075000, 92 2100000, 2125000, 2150000, 2175000, 2200000, 2225000, 2250000, 2275000, 93 2300000, 2325000, 2350000, 2375000, 2400000, 2425000, 2450000, 2475000, 94 }; 95 96 static const unsigned int tps6586x_ldo_voltages[] = { 97 1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000, 98 }; 99 100 static const unsigned int tps6586x_sm2_voltages[] = { 101 3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000, 3350000, 102 3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000, 3750000, 103 3800000, 3850000, 3900000, 3950000, 4000000, 4050000, 4100000, 4150000, 104 4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000, 105 }; 106 107 static const unsigned int tps6586x_dvm_voltages[] = { 108 725000, 750000, 775000, 800000, 825000, 850000, 875000, 900000, 109 925000, 950000, 975000, 1000000, 1025000, 1050000, 1075000, 1100000, 110 1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000, 111 1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000, 112 }; 113 114 #define TPS6586X_REGULATOR(_id, _pin_name, vdata, vreg, shift, nbits, \ 115 ereg0, ebit0, ereg1, ebit1, goreg, gobit) \ 116 .desc = { \ 117 .supply_name = _pin_name, \ 118 .name = "REG-" #_id, \ 119 .ops = &tps6586x_regulator_ops, \ 120 .type = REGULATOR_VOLTAGE, \ 121 .id = TPS6586X_ID_##_id, \ 122 .n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages), \ 123 .volt_table = tps6586x_##vdata##_voltages, \ 124 .owner = THIS_MODULE, \ 125 .enable_reg = TPS6586X_SUPPLY##ereg0, \ 126 .enable_mask = 1 << (ebit0), \ 127 .vsel_reg = TPS6586X_##vreg, \ 128 .vsel_mask = ((1 << (nbits)) - 1) << (shift), \ 129 .apply_reg = (goreg), \ 130 .apply_bit = (gobit), \ 131 }, \ 132 .enable_reg[0] = TPS6586X_SUPPLY##ereg0, \ 133 .enable_bit[0] = (ebit0), \ 134 .enable_reg[1] = TPS6586X_SUPPLY##ereg1, \ 135 .enable_bit[1] = (ebit1), 136 137 #define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits, \ 138 ereg0, ebit0, ereg1, ebit1) \ 139 { \ 140 TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits, \ 141 ereg0, ebit0, ereg1, ebit1, 0, 0) \ 142 } 143 144 #define TPS6586X_DVM(_id, _pname, vdata, vreg, shift, nbits, \ 145 ereg0, ebit0, ereg1, ebit1, goreg, gobit) \ 146 { \ 147 TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits, \ 148 ereg0, ebit0, ereg1, ebit1, goreg, gobit) \ 149 } 150 151 #define TPS6586X_SYS_REGULATOR() \ 152 { \ 153 .desc = { \ 154 .supply_name = "sys", \ 155 .name = "REG-SYS", \ 156 .ops = &tps6586x_sys_regulator_ops, \ 157 .type = REGULATOR_VOLTAGE, \ 158 .id = TPS6586X_ID_SYS, \ 159 .owner = THIS_MODULE, \ 160 }, \ 161 } 162 163 static struct tps6586x_regulator tps6586x_regulator[] = { 164 TPS6586X_SYS_REGULATOR(), 165 TPS6586X_LDO(LDO_0, "vinldo01", ldo0, SUPPLYV1, 5, 3, ENC, 0, END, 0), 166 TPS6586X_LDO(LDO_3, "vinldo23", ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2), 167 TPS6586X_LDO(LDO_5, "REG-SYS", ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6), 168 TPS6586X_LDO(LDO_6, "vinldo678", ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4), 169 TPS6586X_LDO(LDO_7, "vinldo678", ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5), 170 TPS6586X_LDO(LDO_8, "vinldo678", ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6), 171 TPS6586X_LDO(LDO_9, "vinldo9", ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7), 172 TPS6586X_LDO(LDO_RTC, "REG-SYS", ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7), 173 TPS6586X_LDO(LDO_1, "vinldo01", dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1), 174 TPS6586X_LDO(SM_2, "vin-sm2", sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7), 175 176 TPS6586X_DVM(LDO_2, "vinldo23", dvm, LDO2BV1, 0, 5, ENA, 3, 177 ENB, 3, TPS6586X_VCC2, BIT(6)), 178 TPS6586X_DVM(LDO_4, "vinldo4", ldo4, LDO4V1, 0, 5, ENC, 3, 179 END, 3, TPS6586X_VCC1, BIT(6)), 180 TPS6586X_DVM(SM_0, "vin-sm0", dvm, SM0V1, 0, 5, ENA, 1, 181 ENB, 1, TPS6586X_VCC1, BIT(2)), 182 TPS6586X_DVM(SM_1, "vin-sm1", dvm, SM1V1, 0, 5, ENA, 0, 183 ENB, 0, TPS6586X_VCC1, BIT(0)), 184 }; 185 186 /* 187 * TPS6586X has 2 enable bits that are OR'ed to determine the actual 188 * regulator state. Clearing one of this bits allows switching 189 * regulator on and of with single register write. 190 */ 191 static inline int tps6586x_regulator_preinit(struct device *parent, 192 struct tps6586x_regulator *ri) 193 { 194 uint8_t val1, val2; 195 int ret; 196 197 if (ri->enable_reg[0] == ri->enable_reg[1] && 198 ri->enable_bit[0] == ri->enable_bit[1]) 199 return 0; 200 201 ret = tps6586x_read(parent, ri->enable_reg[0], &val1); 202 if (ret) 203 return ret; 204 205 ret = tps6586x_read(parent, ri->enable_reg[1], &val2); 206 if (ret) 207 return ret; 208 209 if (!(val2 & (1 << ri->enable_bit[1]))) 210 return 0; 211 212 /* 213 * The regulator is on, but it's enabled with the bit we don't 214 * want to use, so we switch the enable bits 215 */ 216 if (!(val1 & (1 << ri->enable_bit[0]))) { 217 ret = tps6586x_set_bits(parent, ri->enable_reg[0], 218 1 << ri->enable_bit[0]); 219 if (ret) 220 return ret; 221 } 222 223 return tps6586x_clr_bits(parent, ri->enable_reg[1], 224 1 << ri->enable_bit[1]); 225 } 226 227 static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev, 228 int id, struct regulator_init_data *p) 229 { 230 struct device *parent = pdev->dev.parent; 231 struct tps6586x_settings *setting = p->driver_data; 232 uint8_t reg; 233 234 if (setting == NULL) 235 return 0; 236 237 if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET)) 238 return 0; 239 240 /* only SM0 and SM1 can have the slew rate settings */ 241 switch (id) { 242 case TPS6586X_ID_SM_0: 243 reg = TPS6586X_SM0SL; 244 break; 245 case TPS6586X_ID_SM_1: 246 reg = TPS6586X_SM1SL; 247 break; 248 default: 249 dev_err(&pdev->dev, "Only SM0/SM1 can set slew rate\n"); 250 return -EINVAL; 251 } 252 253 return tps6586x_write(parent, reg, 254 setting->slew_rate & TPS6586X_SLEW_RATE_MASK); 255 } 256 257 static inline struct tps6586x_regulator *find_regulator_info(int id) 258 { 259 struct tps6586x_regulator *ri; 260 int i; 261 262 for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) { 263 ri = &tps6586x_regulator[i]; 264 if (ri->desc.id == id) 265 return ri; 266 } 267 return NULL; 268 } 269 270 #ifdef CONFIG_OF 271 static struct of_regulator_match tps6586x_matches[] = { 272 { .name = "sys", .driver_data = (void *)TPS6586X_ID_SYS }, 273 { .name = "sm0", .driver_data = (void *)TPS6586X_ID_SM_0 }, 274 { .name = "sm1", .driver_data = (void *)TPS6586X_ID_SM_1 }, 275 { .name = "sm2", .driver_data = (void *)TPS6586X_ID_SM_2 }, 276 { .name = "ldo0", .driver_data = (void *)TPS6586X_ID_LDO_0 }, 277 { .name = "ldo1", .driver_data = (void *)TPS6586X_ID_LDO_1 }, 278 { .name = "ldo2", .driver_data = (void *)TPS6586X_ID_LDO_2 }, 279 { .name = "ldo3", .driver_data = (void *)TPS6586X_ID_LDO_3 }, 280 { .name = "ldo4", .driver_data = (void *)TPS6586X_ID_LDO_4 }, 281 { .name = "ldo5", .driver_data = (void *)TPS6586X_ID_LDO_5 }, 282 { .name = "ldo6", .driver_data = (void *)TPS6586X_ID_LDO_6 }, 283 { .name = "ldo7", .driver_data = (void *)TPS6586X_ID_LDO_7 }, 284 { .name = "ldo8", .driver_data = (void *)TPS6586X_ID_LDO_8 }, 285 { .name = "ldo9", .driver_data = (void *)TPS6586X_ID_LDO_9 }, 286 { .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC }, 287 }; 288 289 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt( 290 struct platform_device *pdev, 291 struct of_regulator_match **tps6586x_reg_matches) 292 { 293 const unsigned int num = ARRAY_SIZE(tps6586x_matches); 294 struct device_node *np = pdev->dev.parent->of_node; 295 struct device_node *regs; 296 const char *sys_rail = NULL; 297 unsigned int i; 298 struct tps6586x_platform_data *pdata; 299 int err; 300 301 regs = of_get_child_by_name(np, "regulators"); 302 if (!regs) { 303 dev_err(&pdev->dev, "regulator node not found\n"); 304 return NULL; 305 } 306 307 err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num); 308 of_node_put(regs); 309 if (err < 0) { 310 dev_err(&pdev->dev, "Regulator match failed, e %d\n", err); 311 return NULL; 312 } 313 314 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 315 if (!pdata) { 316 dev_err(&pdev->dev, "Memory alloction failed\n"); 317 return NULL; 318 } 319 320 for (i = 0; i < num; i++) { 321 int id; 322 if (!tps6586x_matches[i].init_data) 323 continue; 324 325 pdata->reg_init_data[i] = tps6586x_matches[i].init_data; 326 id = (int)tps6586x_matches[i].driver_data; 327 if (id == TPS6586X_ID_SYS) 328 sys_rail = pdata->reg_init_data[i]->constraints.name; 329 330 if ((id == TPS6586X_ID_LDO_5) || (id == TPS6586X_ID_LDO_RTC)) 331 pdata->reg_init_data[i]->supply_regulator = sys_rail; 332 } 333 *tps6586x_reg_matches = tps6586x_matches; 334 return pdata; 335 } 336 #else 337 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt( 338 struct platform_device *pdev, 339 struct of_regulator_match **tps6586x_reg_matches) 340 { 341 *tps6586x_reg_matches = NULL; 342 return NULL; 343 } 344 #endif 345 346 static int tps6586x_regulator_probe(struct platform_device *pdev) 347 { 348 struct tps6586x_regulator *ri = NULL; 349 struct regulator_config config = { }; 350 struct regulator_dev **rdev; 351 struct regulator_init_data *reg_data; 352 struct tps6586x_platform_data *pdata; 353 struct of_regulator_match *tps6586x_reg_matches = NULL; 354 int id; 355 int err; 356 357 dev_dbg(&pdev->dev, "Probing regulator\n"); 358 359 pdata = dev_get_platdata(pdev->dev.parent); 360 if ((!pdata) && (pdev->dev.parent->of_node)) 361 pdata = tps6586x_parse_regulator_dt(pdev, 362 &tps6586x_reg_matches); 363 364 if (!pdata) { 365 dev_err(&pdev->dev, "Platform data not available, exiting\n"); 366 return -ENODEV; 367 } 368 369 rdev = devm_kzalloc(&pdev->dev, TPS6586X_ID_MAX_REGULATOR * 370 sizeof(*rdev), GFP_KERNEL); 371 if (!rdev) { 372 dev_err(&pdev->dev, "Mmemory alloc failed\n"); 373 return -ENOMEM; 374 } 375 376 for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) { 377 reg_data = pdata->reg_init_data[id]; 378 379 ri = find_regulator_info(id); 380 if (!ri) { 381 dev_err(&pdev->dev, "invalid regulator ID specified\n"); 382 return -EINVAL; 383 } 384 385 err = tps6586x_regulator_preinit(pdev->dev.parent, ri); 386 if (err) { 387 dev_err(&pdev->dev, 388 "regulator %d preinit failed, e %d\n", id, err); 389 return err; 390 } 391 392 config.dev = pdev->dev.parent; 393 config.init_data = reg_data; 394 config.driver_data = ri; 395 396 if (tps6586x_reg_matches) 397 config.of_node = tps6586x_reg_matches[id].of_node; 398 399 rdev[id] = devm_regulator_register(&pdev->dev, &ri->desc, 400 &config); 401 if (IS_ERR(rdev[id])) { 402 dev_err(&pdev->dev, "failed to register regulator %s\n", 403 ri->desc.name); 404 return PTR_ERR(rdev[id]); 405 } 406 407 if (reg_data) { 408 err = tps6586x_regulator_set_slew_rate(pdev, id, 409 reg_data); 410 if (err < 0) { 411 dev_err(&pdev->dev, 412 "Slew rate config failed, e %d\n", err); 413 return err; 414 } 415 } 416 } 417 418 platform_set_drvdata(pdev, rdev); 419 return 0; 420 } 421 422 static struct platform_driver tps6586x_regulator_driver = { 423 .driver = { 424 .name = "tps6586x-regulator", 425 .owner = THIS_MODULE, 426 }, 427 .probe = tps6586x_regulator_probe, 428 }; 429 430 static int __init tps6586x_regulator_init(void) 431 { 432 return platform_driver_register(&tps6586x_regulator_driver); 433 } 434 subsys_initcall(tps6586x_regulator_init); 435 436 static void __exit tps6586x_regulator_exit(void) 437 { 438 platform_driver_unregister(&tps6586x_regulator_driver); 439 } 440 module_exit(tps6586x_regulator_exit); 441 442 MODULE_LICENSE("GPL"); 443 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>"); 444 MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC"); 445 MODULE_ALIAS("platform:tps6586x-regulator"); 446