1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * tps6507x-regulator.c 4 * 5 * Regulator driver for TPS65073 PMIC 6 * 7 * Copyright (C) 2009 Texas Instrument Incorporated - https://www.ti.com/ 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/init.h> 13 #include <linux/err.h> 14 #include <linux/platform_device.h> 15 #include <linux/regulator/driver.h> 16 #include <linux/regulator/machine.h> 17 #include <linux/regulator/tps6507x.h> 18 #include <linux/of.h> 19 #include <linux/slab.h> 20 #include <linux/mfd/tps6507x.h> 21 #include <linux/regulator/of_regulator.h> 22 23 /* DCDC's */ 24 #define TPS6507X_DCDC_1 0 25 #define TPS6507X_DCDC_2 1 26 #define TPS6507X_DCDC_3 2 27 /* LDOs */ 28 #define TPS6507X_LDO_1 3 29 #define TPS6507X_LDO_2 4 30 31 #define TPS6507X_MAX_REG_ID TPS6507X_LDO_2 32 33 /* Number of step-down converters available */ 34 #define TPS6507X_NUM_DCDC 3 35 /* Number of LDO voltage regulators available */ 36 #define TPS6507X_NUM_LDO 2 37 /* Number of total regulators available */ 38 #define TPS6507X_NUM_REGULATOR (TPS6507X_NUM_DCDC + TPS6507X_NUM_LDO) 39 40 /* Supported voltage values for regulators (in microVolts) */ 41 static const unsigned int VDCDCx_VSEL_table[] = { 42 725000, 750000, 775000, 800000, 43 825000, 850000, 875000, 900000, 44 925000, 950000, 975000, 1000000, 45 1025000, 1050000, 1075000, 1100000, 46 1125000, 1150000, 1175000, 1200000, 47 1225000, 1250000, 1275000, 1300000, 48 1325000, 1350000, 1375000, 1400000, 49 1425000, 1450000, 1475000, 1500000, 50 1550000, 1600000, 1650000, 1700000, 51 1750000, 1800000, 1850000, 1900000, 52 1950000, 2000000, 2050000, 2100000, 53 2150000, 2200000, 2250000, 2300000, 54 2350000, 2400000, 2450000, 2500000, 55 2550000, 2600000, 2650000, 2700000, 56 2750000, 2800000, 2850000, 2900000, 57 3000000, 3100000, 3200000, 3300000, 58 }; 59 60 static const unsigned int LDO1_VSEL_table[] = { 61 1000000, 1100000, 1200000, 1250000, 62 1300000, 1350000, 1400000, 1500000, 63 1600000, 1800000, 2500000, 2750000, 64 2800000, 3000000, 3100000, 3300000, 65 }; 66 67 /* The voltage mapping table for LDO2 is the same as VDCDCx */ 68 #define LDO2_VSEL_table VDCDCx_VSEL_table 69 70 struct tps_info { 71 const char *name; 72 u8 table_len; 73 const unsigned int *table; 74 75 /* Does DCDC high or the low register defines output voltage? */ 76 bool defdcdc_default; 77 }; 78 79 static struct tps_info tps6507x_pmic_regs[] = { 80 { 81 .name = "VDCDC1", 82 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 83 .table = VDCDCx_VSEL_table, 84 }, 85 { 86 .name = "VDCDC2", 87 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 88 .table = VDCDCx_VSEL_table, 89 }, 90 { 91 .name = "VDCDC3", 92 .table_len = ARRAY_SIZE(VDCDCx_VSEL_table), 93 .table = VDCDCx_VSEL_table, 94 }, 95 { 96 .name = "LDO1", 97 .table_len = ARRAY_SIZE(LDO1_VSEL_table), 98 .table = LDO1_VSEL_table, 99 }, 100 { 101 .name = "LDO2", 102 .table_len = ARRAY_SIZE(LDO2_VSEL_table), 103 .table = LDO2_VSEL_table, 104 }, 105 }; 106 107 struct tps6507x_pmic { 108 struct regulator_desc desc[TPS6507X_NUM_REGULATOR]; 109 struct tps6507x_dev *mfd; 110 struct tps_info *info[TPS6507X_NUM_REGULATOR]; 111 struct mutex io_lock; 112 }; 113 static inline int tps6507x_pmic_read(struct tps6507x_pmic *tps, u8 reg) 114 { 115 u8 val; 116 int err; 117 118 err = tps->mfd->read_dev(tps->mfd, reg, 1, &val); 119 120 if (err) 121 return err; 122 123 return val; 124 } 125 126 static inline int tps6507x_pmic_write(struct tps6507x_pmic *tps, u8 reg, u8 val) 127 { 128 return tps->mfd->write_dev(tps->mfd, reg, 1, &val); 129 } 130 131 static int tps6507x_pmic_set_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask) 132 { 133 int err, data; 134 135 mutex_lock(&tps->io_lock); 136 137 data = tps6507x_pmic_read(tps, reg); 138 if (data < 0) { 139 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 140 err = data; 141 goto out; 142 } 143 144 data |= mask; 145 err = tps6507x_pmic_write(tps, reg, data); 146 if (err) 147 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 148 149 out: 150 mutex_unlock(&tps->io_lock); 151 return err; 152 } 153 154 static int tps6507x_pmic_clear_bits(struct tps6507x_pmic *tps, u8 reg, u8 mask) 155 { 156 int err, data; 157 158 mutex_lock(&tps->io_lock); 159 160 data = tps6507x_pmic_read(tps, reg); 161 if (data < 0) { 162 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 163 err = data; 164 goto out; 165 } 166 167 data &= ~mask; 168 err = tps6507x_pmic_write(tps, reg, data); 169 if (err) 170 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 171 172 out: 173 mutex_unlock(&tps->io_lock); 174 return err; 175 } 176 177 static int tps6507x_pmic_reg_read(struct tps6507x_pmic *tps, u8 reg) 178 { 179 int data; 180 181 mutex_lock(&tps->io_lock); 182 183 data = tps6507x_pmic_read(tps, reg); 184 if (data < 0) 185 dev_err(tps->mfd->dev, "Read from reg 0x%x failed\n", reg); 186 187 mutex_unlock(&tps->io_lock); 188 return data; 189 } 190 191 static int tps6507x_pmic_reg_write(struct tps6507x_pmic *tps, u8 reg, u8 val) 192 { 193 int err; 194 195 mutex_lock(&tps->io_lock); 196 197 err = tps6507x_pmic_write(tps, reg, val); 198 if (err < 0) 199 dev_err(tps->mfd->dev, "Write for reg 0x%x failed\n", reg); 200 201 mutex_unlock(&tps->io_lock); 202 return err; 203 } 204 205 static int tps6507x_pmic_is_enabled(struct regulator_dev *dev) 206 { 207 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 208 int data, rid = rdev_get_id(dev); 209 u8 shift; 210 211 if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2) 212 return -EINVAL; 213 214 shift = TPS6507X_MAX_REG_ID - rid; 215 data = tps6507x_pmic_reg_read(tps, TPS6507X_REG_CON_CTRL1); 216 217 if (data < 0) 218 return data; 219 else 220 return (data & 1<<shift) ? 1 : 0; 221 } 222 223 static int tps6507x_pmic_enable(struct regulator_dev *dev) 224 { 225 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 226 int rid = rdev_get_id(dev); 227 u8 shift; 228 229 if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2) 230 return -EINVAL; 231 232 shift = TPS6507X_MAX_REG_ID - rid; 233 return tps6507x_pmic_set_bits(tps, TPS6507X_REG_CON_CTRL1, 1 << shift); 234 } 235 236 static int tps6507x_pmic_disable(struct regulator_dev *dev) 237 { 238 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 239 int rid = rdev_get_id(dev); 240 u8 shift; 241 242 if (rid < TPS6507X_DCDC_1 || rid > TPS6507X_LDO_2) 243 return -EINVAL; 244 245 shift = TPS6507X_MAX_REG_ID - rid; 246 return tps6507x_pmic_clear_bits(tps, TPS6507X_REG_CON_CTRL1, 247 1 << shift); 248 } 249 250 static int tps6507x_pmic_get_voltage_sel(struct regulator_dev *dev) 251 { 252 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 253 int data, rid = rdev_get_id(dev); 254 u8 reg, mask; 255 256 switch (rid) { 257 case TPS6507X_DCDC_1: 258 reg = TPS6507X_REG_DEFDCDC1; 259 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 260 break; 261 case TPS6507X_DCDC_2: 262 if (tps->info[rid]->defdcdc_default) 263 reg = TPS6507X_REG_DEFDCDC2_HIGH; 264 else 265 reg = TPS6507X_REG_DEFDCDC2_LOW; 266 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 267 break; 268 case TPS6507X_DCDC_3: 269 if (tps->info[rid]->defdcdc_default) 270 reg = TPS6507X_REG_DEFDCDC3_HIGH; 271 else 272 reg = TPS6507X_REG_DEFDCDC3_LOW; 273 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 274 break; 275 case TPS6507X_LDO_1: 276 reg = TPS6507X_REG_LDO_CTRL1; 277 mask = TPS6507X_REG_LDO_CTRL1_LDO1_MASK; 278 break; 279 case TPS6507X_LDO_2: 280 reg = TPS6507X_REG_DEFLDO2; 281 mask = TPS6507X_REG_DEFLDO2_LDO2_MASK; 282 break; 283 default: 284 return -EINVAL; 285 } 286 287 data = tps6507x_pmic_reg_read(tps, reg); 288 if (data < 0) 289 return data; 290 291 data &= mask; 292 return data; 293 } 294 295 static int tps6507x_pmic_set_voltage_sel(struct regulator_dev *dev, 296 unsigned selector) 297 { 298 struct tps6507x_pmic *tps = rdev_get_drvdata(dev); 299 int data, rid = rdev_get_id(dev); 300 u8 reg, mask; 301 302 switch (rid) { 303 case TPS6507X_DCDC_1: 304 reg = TPS6507X_REG_DEFDCDC1; 305 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 306 break; 307 case TPS6507X_DCDC_2: 308 if (tps->info[rid]->defdcdc_default) 309 reg = TPS6507X_REG_DEFDCDC2_HIGH; 310 else 311 reg = TPS6507X_REG_DEFDCDC2_LOW; 312 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 313 break; 314 case TPS6507X_DCDC_3: 315 if (tps->info[rid]->defdcdc_default) 316 reg = TPS6507X_REG_DEFDCDC3_HIGH; 317 else 318 reg = TPS6507X_REG_DEFDCDC3_LOW; 319 mask = TPS6507X_DEFDCDCX_DCDC_MASK; 320 break; 321 case TPS6507X_LDO_1: 322 reg = TPS6507X_REG_LDO_CTRL1; 323 mask = TPS6507X_REG_LDO_CTRL1_LDO1_MASK; 324 break; 325 case TPS6507X_LDO_2: 326 reg = TPS6507X_REG_DEFLDO2; 327 mask = TPS6507X_REG_DEFLDO2_LDO2_MASK; 328 break; 329 default: 330 return -EINVAL; 331 } 332 333 data = tps6507x_pmic_reg_read(tps, reg); 334 if (data < 0) 335 return data; 336 337 data &= ~mask; 338 data |= selector; 339 340 return tps6507x_pmic_reg_write(tps, reg, data); 341 } 342 343 static const struct regulator_ops tps6507x_pmic_ops = { 344 .is_enabled = tps6507x_pmic_is_enabled, 345 .enable = tps6507x_pmic_enable, 346 .disable = tps6507x_pmic_disable, 347 .get_voltage_sel = tps6507x_pmic_get_voltage_sel, 348 .set_voltage_sel = tps6507x_pmic_set_voltage_sel, 349 .list_voltage = regulator_list_voltage_table, 350 .map_voltage = regulator_map_voltage_ascend, 351 }; 352 353 static int tps6507x_pmic_of_parse_cb(struct device_node *np, 354 const struct regulator_desc *desc, 355 struct regulator_config *config) 356 { 357 struct tps6507x_pmic *tps = config->driver_data; 358 struct tps_info *info = tps->info[desc->id]; 359 u32 prop; 360 int ret; 361 362 ret = of_property_read_u32(np, "ti,defdcdc_default", &prop); 363 if (!ret) 364 info->defdcdc_default = prop; 365 366 return 0; 367 } 368 369 static int tps6507x_pmic_probe(struct platform_device *pdev) 370 { 371 struct tps6507x_dev *tps6507x_dev = dev_get_drvdata(pdev->dev.parent); 372 struct tps_info *info = &tps6507x_pmic_regs[0]; 373 struct regulator_config config = { }; 374 struct regulator_init_data *init_data = NULL; 375 struct regulator_dev *rdev; 376 struct tps6507x_pmic *tps; 377 struct tps6507x_board *tps_board; 378 int i; 379 380 /** 381 * tps_board points to pmic related constants 382 * coming from the board-evm file. 383 */ 384 385 tps_board = dev_get_platdata(tps6507x_dev->dev); 386 if (tps_board) 387 init_data = tps_board->tps6507x_pmic_init_data; 388 389 tps = devm_kzalloc(&pdev->dev, sizeof(*tps), GFP_KERNEL); 390 if (!tps) 391 return -ENOMEM; 392 393 mutex_init(&tps->io_lock); 394 395 /* common for all regulators */ 396 tps->mfd = tps6507x_dev; 397 398 for (i = 0; i < TPS6507X_NUM_REGULATOR; i++, info++) { 399 /* Register the regulators */ 400 tps->info[i] = info; 401 if (init_data && init_data[i].driver_data) { 402 struct tps6507x_reg_platform_data *data = 403 init_data[i].driver_data; 404 info->defdcdc_default = data->defdcdc_default; 405 } 406 407 tps->desc[i].name = info->name; 408 tps->desc[i].of_match = of_match_ptr(info->name); 409 tps->desc[i].regulators_node = of_match_ptr("regulators"); 410 tps->desc[i].of_parse_cb = tps6507x_pmic_of_parse_cb; 411 tps->desc[i].id = i; 412 tps->desc[i].n_voltages = info->table_len; 413 tps->desc[i].volt_table = info->table; 414 tps->desc[i].ops = &tps6507x_pmic_ops; 415 tps->desc[i].type = REGULATOR_VOLTAGE; 416 tps->desc[i].owner = THIS_MODULE; 417 418 config.dev = tps6507x_dev->dev; 419 config.init_data = init_data; 420 config.driver_data = tps; 421 422 rdev = devm_regulator_register(&pdev->dev, &tps->desc[i], 423 &config); 424 if (IS_ERR(rdev)) { 425 dev_err(tps6507x_dev->dev, 426 "failed to register %s regulator\n", 427 pdev->name); 428 return PTR_ERR(rdev); 429 } 430 } 431 432 tps6507x_dev->pmic = tps; 433 platform_set_drvdata(pdev, tps6507x_dev); 434 435 return 0; 436 } 437 438 static struct platform_driver tps6507x_pmic_driver = { 439 .driver = { 440 .name = "tps6507x-pmic", 441 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 442 }, 443 .probe = tps6507x_pmic_probe, 444 }; 445 446 static int __init tps6507x_pmic_init(void) 447 { 448 return platform_driver_register(&tps6507x_pmic_driver); 449 } 450 subsys_initcall(tps6507x_pmic_init); 451 452 static void __exit tps6507x_pmic_cleanup(void) 453 { 454 platform_driver_unregister(&tps6507x_pmic_driver); 455 } 456 module_exit(tps6507x_pmic_cleanup); 457 458 MODULE_AUTHOR("Texas Instruments"); 459 MODULE_DESCRIPTION("TPS6507x voltage regulator driver"); 460 MODULE_LICENSE("GPL v2"); 461 MODULE_ALIAS("platform:tps6507x-pmic"); 462