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