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 .get_voltage_sel = regulator_get_voltage_sel_regmap, 74 .set_voltage_sel = regulator_set_voltage_sel_regmap, 75 76 .is_enabled = regulator_is_enabled_regmap, 77 .enable = regulator_enable_regmap, 78 .disable = regulator_disable_regmap, 79 }; 80 81 static struct regulator_ops tps6586x_sys_regulator_ops = { 82 }; 83 84 static const unsigned int tps6586x_ldo0_voltages[] = { 85 1200000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000, 86 }; 87 88 static const unsigned int tps6586x_ldo4_voltages[] = { 89 1700000, 1725000, 1750000, 1775000, 1800000, 1825000, 1850000, 1875000, 90 1900000, 1925000, 1950000, 1975000, 2000000, 2025000, 2050000, 2075000, 91 2100000, 2125000, 2150000, 2175000, 2200000, 2225000, 2250000, 2275000, 92 2300000, 2325000, 2350000, 2375000, 2400000, 2425000, 2450000, 2475000, 93 }; 94 95 static const unsigned int tps6586x_ldo_voltages[] = { 96 1250000, 1500000, 1800000, 2500000, 2700000, 2850000, 3100000, 3300000, 97 }; 98 99 static const unsigned int tps6586x_sm2_voltages[] = { 100 3000000, 3050000, 3100000, 3150000, 3200000, 3250000, 3300000, 3350000, 101 3400000, 3450000, 3500000, 3550000, 3600000, 3650000, 3700000, 3750000, 102 3800000, 3850000, 3900000, 3950000, 4000000, 4050000, 4100000, 4150000, 103 4200000, 4250000, 4300000, 4350000, 4400000, 4450000, 4500000, 4550000, 104 }; 105 106 static const unsigned int tps6586x_dvm_voltages[] = { 107 725000, 750000, 775000, 800000, 825000, 850000, 875000, 900000, 108 925000, 950000, 975000, 1000000, 1025000, 1050000, 1075000, 1100000, 109 1125000, 1150000, 1175000, 1200000, 1225000, 1250000, 1275000, 1300000, 110 1325000, 1350000, 1375000, 1400000, 1425000, 1450000, 1475000, 1500000, 111 }; 112 113 #define TPS6586X_REGULATOR(_id, _pin_name, vdata, vreg, shift, nbits, \ 114 ereg0, ebit0, ereg1, ebit1, goreg, gobit) \ 115 .desc = { \ 116 .supply_name = _pin_name, \ 117 .name = "REG-" #_id, \ 118 .ops = &tps6586x_regulator_ops, \ 119 .type = REGULATOR_VOLTAGE, \ 120 .id = TPS6586X_ID_##_id, \ 121 .n_voltages = ARRAY_SIZE(tps6586x_##vdata##_voltages), \ 122 .volt_table = tps6586x_##vdata##_voltages, \ 123 .owner = THIS_MODULE, \ 124 .enable_reg = TPS6586X_SUPPLY##ereg0, \ 125 .enable_mask = 1 << (ebit0), \ 126 .vsel_reg = TPS6586X_##vreg, \ 127 .vsel_mask = ((1 << (nbits)) - 1) << (shift), \ 128 .apply_reg = (goreg), \ 129 .apply_bit = (gobit), \ 130 }, \ 131 .enable_reg[0] = TPS6586X_SUPPLY##ereg0, \ 132 .enable_bit[0] = (ebit0), \ 133 .enable_reg[1] = TPS6586X_SUPPLY##ereg1, \ 134 .enable_bit[1] = (ebit1), 135 136 #define TPS6586X_LDO(_id, _pname, vdata, vreg, shift, nbits, \ 137 ereg0, ebit0, ereg1, ebit1) \ 138 { \ 139 TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits, \ 140 ereg0, ebit0, ereg1, ebit1, 0, 0) \ 141 } 142 143 #define TPS6586X_DVM(_id, _pname, vdata, vreg, shift, nbits, \ 144 ereg0, ebit0, ereg1, ebit1, goreg, gobit) \ 145 { \ 146 TPS6586X_REGULATOR(_id, _pname, vdata, vreg, shift, nbits, \ 147 ereg0, ebit0, ereg1, ebit1, goreg, gobit) \ 148 } 149 150 #define TPS6586X_SYS_REGULATOR() \ 151 { \ 152 .desc = { \ 153 .supply_name = "sys", \ 154 .name = "REG-SYS", \ 155 .ops = &tps6586x_sys_regulator_ops, \ 156 .type = REGULATOR_VOLTAGE, \ 157 .id = TPS6586X_ID_SYS, \ 158 .owner = THIS_MODULE, \ 159 }, \ 160 } 161 162 static struct tps6586x_regulator tps6586x_regulator[] = { 163 TPS6586X_SYS_REGULATOR(), 164 TPS6586X_LDO(LDO_0, "vinldo01", ldo0, SUPPLYV1, 5, 3, ENC, 0, END, 0), 165 TPS6586X_LDO(LDO_3, "vinldo23", ldo, SUPPLYV4, 0, 3, ENC, 2, END, 2), 166 TPS6586X_LDO(LDO_5, "REG-SYS", ldo, SUPPLYV6, 0, 3, ENE, 6, ENE, 6), 167 TPS6586X_LDO(LDO_6, "vinldo678", ldo, SUPPLYV3, 0, 3, ENC, 4, END, 4), 168 TPS6586X_LDO(LDO_7, "vinldo678", ldo, SUPPLYV3, 3, 3, ENC, 5, END, 5), 169 TPS6586X_LDO(LDO_8, "vinldo678", ldo, SUPPLYV2, 5, 3, ENC, 6, END, 6), 170 TPS6586X_LDO(LDO_9, "vinldo9", ldo, SUPPLYV6, 3, 3, ENE, 7, ENE, 7), 171 TPS6586X_LDO(LDO_RTC, "REG-SYS", ldo, SUPPLYV4, 3, 3, V4, 7, V4, 7), 172 TPS6586X_LDO(LDO_1, "vinldo01", dvm, SUPPLYV1, 0, 5, ENC, 1, END, 1), 173 TPS6586X_LDO(SM_2, "vin-sm2", sm2, SUPPLYV2, 0, 5, ENC, 7, END, 7), 174 175 TPS6586X_DVM(LDO_2, "vinldo23", dvm, LDO2BV1, 0, 5, ENA, 3, 176 ENB, 3, TPS6586X_VCC2, BIT(6)), 177 TPS6586X_DVM(LDO_4, "vinldo4", ldo4, LDO4V1, 0, 5, ENC, 3, 178 END, 3, TPS6586X_VCC1, BIT(6)), 179 TPS6586X_DVM(SM_0, "vin-sm0", dvm, SM0V1, 0, 5, ENA, 1, 180 ENB, 1, TPS6586X_VCC1, BIT(2)), 181 TPS6586X_DVM(SM_1, "vin-sm1", dvm, SM1V1, 0, 5, ENA, 0, 182 ENB, 0, TPS6586X_VCC1, BIT(0)), 183 }; 184 185 /* 186 * TPS6586X has 2 enable bits that are OR'ed to determine the actual 187 * regulator state. Clearing one of this bits allows switching 188 * regulator on and of with single register write. 189 */ 190 static inline int tps6586x_regulator_preinit(struct device *parent, 191 struct tps6586x_regulator *ri) 192 { 193 uint8_t val1, val2; 194 int ret; 195 196 if (ri->enable_reg[0] == ri->enable_reg[1] && 197 ri->enable_bit[0] == ri->enable_bit[1]) 198 return 0; 199 200 ret = tps6586x_read(parent, ri->enable_reg[0], &val1); 201 if (ret) 202 return ret; 203 204 ret = tps6586x_read(parent, ri->enable_reg[1], &val2); 205 if (ret) 206 return ret; 207 208 if (!(val2 & (1 << ri->enable_bit[1]))) 209 return 0; 210 211 /* 212 * The regulator is on, but it's enabled with the bit we don't 213 * want to use, so we switch the enable bits 214 */ 215 if (!(val1 & (1 << ri->enable_bit[0]))) { 216 ret = tps6586x_set_bits(parent, ri->enable_reg[0], 217 1 << ri->enable_bit[0]); 218 if (ret) 219 return ret; 220 } 221 222 return tps6586x_clr_bits(parent, ri->enable_reg[1], 223 1 << ri->enable_bit[1]); 224 } 225 226 static int tps6586x_regulator_set_slew_rate(struct platform_device *pdev, 227 int id, struct regulator_init_data *p) 228 { 229 struct device *parent = pdev->dev.parent; 230 struct tps6586x_settings *setting = p->driver_data; 231 uint8_t reg; 232 233 if (setting == NULL) 234 return 0; 235 236 if (!(setting->slew_rate & TPS6586X_SLEW_RATE_SET)) 237 return 0; 238 239 /* only SM0 and SM1 can have the slew rate settings */ 240 switch (id) { 241 case TPS6586X_ID_SM_0: 242 reg = TPS6586X_SM0SL; 243 break; 244 case TPS6586X_ID_SM_1: 245 reg = TPS6586X_SM1SL; 246 break; 247 default: 248 dev_warn(&pdev->dev, "Only SM0/SM1 can set slew rate\n"); 249 return -EINVAL; 250 } 251 252 return tps6586x_write(parent, reg, 253 setting->slew_rate & TPS6586X_SLEW_RATE_MASK); 254 } 255 256 static inline struct tps6586x_regulator *find_regulator_info(int id) 257 { 258 struct tps6586x_regulator *ri; 259 int i; 260 261 for (i = 0; i < ARRAY_SIZE(tps6586x_regulator); i++) { 262 ri = &tps6586x_regulator[i]; 263 if (ri->desc.id == id) 264 return ri; 265 } 266 return NULL; 267 } 268 269 #ifdef CONFIG_OF 270 static struct of_regulator_match tps6586x_matches[] = { 271 { .name = "sys", .driver_data = (void *)TPS6586X_ID_SYS }, 272 { .name = "sm0", .driver_data = (void *)TPS6586X_ID_SM_0 }, 273 { .name = "sm1", .driver_data = (void *)TPS6586X_ID_SM_1 }, 274 { .name = "sm2", .driver_data = (void *)TPS6586X_ID_SM_2 }, 275 { .name = "ldo0", .driver_data = (void *)TPS6586X_ID_LDO_0 }, 276 { .name = "ldo1", .driver_data = (void *)TPS6586X_ID_LDO_1 }, 277 { .name = "ldo2", .driver_data = (void *)TPS6586X_ID_LDO_2 }, 278 { .name = "ldo3", .driver_data = (void *)TPS6586X_ID_LDO_3 }, 279 { .name = "ldo4", .driver_data = (void *)TPS6586X_ID_LDO_4 }, 280 { .name = "ldo5", .driver_data = (void *)TPS6586X_ID_LDO_5 }, 281 { .name = "ldo6", .driver_data = (void *)TPS6586X_ID_LDO_6 }, 282 { .name = "ldo7", .driver_data = (void *)TPS6586X_ID_LDO_7 }, 283 { .name = "ldo8", .driver_data = (void *)TPS6586X_ID_LDO_8 }, 284 { .name = "ldo9", .driver_data = (void *)TPS6586X_ID_LDO_9 }, 285 { .name = "ldo_rtc", .driver_data = (void *)TPS6586X_ID_LDO_RTC }, 286 }; 287 288 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt( 289 struct platform_device *pdev, 290 struct of_regulator_match **tps6586x_reg_matches) 291 { 292 const unsigned int num = ARRAY_SIZE(tps6586x_matches); 293 struct device_node *np = pdev->dev.parent->of_node; 294 struct device_node *regs; 295 const char *sys_rail = NULL; 296 unsigned int i; 297 struct tps6586x_platform_data *pdata; 298 int err; 299 300 regs = of_find_node_by_name(np, "regulators"); 301 if (!regs) { 302 dev_err(&pdev->dev, "regulator node not found\n"); 303 return NULL; 304 } 305 306 err = of_regulator_match(&pdev->dev, regs, tps6586x_matches, num); 307 if (err < 0) { 308 dev_err(&pdev->dev, "Regulator match failed, e %d\n", err); 309 of_node_put(regs); 310 return NULL; 311 } 312 313 of_node_put(regs); 314 315 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 316 if (!pdata) { 317 dev_err(&pdev->dev, "Memory alloction failed\n"); 318 return NULL; 319 } 320 321 for (i = 0; i < num; i++) { 322 int id; 323 if (!tps6586x_matches[i].init_data) 324 continue; 325 326 pdata->reg_init_data[i] = tps6586x_matches[i].init_data; 327 id = (int)tps6586x_matches[i].driver_data; 328 if (id == TPS6586X_ID_SYS) 329 sys_rail = pdata->reg_init_data[i]->constraints.name; 330 331 if ((id == TPS6586X_ID_LDO_5) || (id == TPS6586X_ID_LDO_RTC)) 332 pdata->reg_init_data[i]->supply_regulator = sys_rail; 333 } 334 *tps6586x_reg_matches = tps6586x_matches; 335 return pdata; 336 } 337 #else 338 static struct tps6586x_platform_data *tps6586x_parse_regulator_dt( 339 struct platform_device *pdev, 340 struct of_regulator_match **tps6586x_reg_matches) 341 { 342 *tps6586x_reg_matches = NULL; 343 return NULL; 344 } 345 #endif 346 347 static int tps6586x_regulator_probe(struct platform_device *pdev) 348 { 349 struct tps6586x_regulator *ri = NULL; 350 struct regulator_config config = { }; 351 struct regulator_dev **rdev; 352 struct regulator_init_data *reg_data; 353 struct tps6586x_platform_data *pdata; 354 struct of_regulator_match *tps6586x_reg_matches = NULL; 355 int id; 356 int err; 357 358 dev_dbg(&pdev->dev, "Probing regulator\n"); 359 360 pdata = dev_get_platdata(pdev->dev.parent); 361 if ((!pdata) && (pdev->dev.parent->of_node)) 362 pdata = tps6586x_parse_regulator_dt(pdev, 363 &tps6586x_reg_matches); 364 365 if (!pdata) { 366 dev_err(&pdev->dev, "Platform data not available, exiting\n"); 367 return -ENODEV; 368 } 369 370 rdev = devm_kzalloc(&pdev->dev, TPS6586X_ID_MAX_REGULATOR * 371 sizeof(*rdev), GFP_KERNEL); 372 if (!rdev) { 373 dev_err(&pdev->dev, "Mmemory alloc failed\n"); 374 return -ENOMEM; 375 } 376 377 for (id = 0; id < TPS6586X_ID_MAX_REGULATOR; ++id) { 378 reg_data = pdata->reg_init_data[id]; 379 380 ri = find_regulator_info(id); 381 if (!ri) { 382 dev_err(&pdev->dev, "invalid regulator ID specified\n"); 383 err = -EINVAL; 384 goto fail; 385 } 386 387 err = tps6586x_regulator_preinit(pdev->dev.parent, ri); 388 if (err) { 389 dev_err(&pdev->dev, 390 "regulator %d preinit failed, e %d\n", id, err); 391 goto fail; 392 } 393 394 config.dev = pdev->dev.parent; 395 config.init_data = reg_data; 396 config.driver_data = ri; 397 398 if (tps6586x_reg_matches) 399 config.of_node = tps6586x_reg_matches[id].of_node; 400 401 rdev[id] = regulator_register(&ri->desc, &config); 402 if (IS_ERR(rdev[id])) { 403 dev_err(&pdev->dev, "failed to register regulator %s\n", 404 ri->desc.name); 405 err = PTR_ERR(rdev[id]); 406 goto fail; 407 } 408 409 if (reg_data) { 410 err = tps6586x_regulator_set_slew_rate(pdev, id, 411 reg_data); 412 if (err < 0) { 413 dev_err(&pdev->dev, 414 "Slew rate config failed, e %d\n", err); 415 regulator_unregister(rdev[id]); 416 goto fail; 417 } 418 } 419 } 420 421 platform_set_drvdata(pdev, rdev); 422 return 0; 423 424 fail: 425 while (--id >= 0) 426 regulator_unregister(rdev[id]); 427 return err; 428 } 429 430 static int tps6586x_regulator_remove(struct platform_device *pdev) 431 { 432 struct regulator_dev **rdev = platform_get_drvdata(pdev); 433 int id = TPS6586X_ID_MAX_REGULATOR; 434 435 while (--id >= 0) 436 regulator_unregister(rdev[id]); 437 438 return 0; 439 } 440 441 static struct platform_driver tps6586x_regulator_driver = { 442 .driver = { 443 .name = "tps6586x-pmic", 444 .owner = THIS_MODULE, 445 }, 446 .probe = tps6586x_regulator_probe, 447 .remove = tps6586x_regulator_remove, 448 }; 449 450 static int __init tps6586x_regulator_init(void) 451 { 452 return platform_driver_register(&tps6586x_regulator_driver); 453 } 454 subsys_initcall(tps6586x_regulator_init); 455 456 static void __exit tps6586x_regulator_exit(void) 457 { 458 platform_driver_unregister(&tps6586x_regulator_driver); 459 } 460 module_exit(tps6586x_regulator_exit); 461 462 MODULE_LICENSE("GPL"); 463 MODULE_AUTHOR("Mike Rapoport <mike@compulab.co.il>"); 464 MODULE_DESCRIPTION("Regulator Driver for TI TPS6586X PMIC"); 465 MODULE_ALIAS("platform:tps6586x-regulator"); 466