1 // SPDX-License-Identifier: GPL-2.0-only 2 // Copyright (C) 2019 ROHM Semiconductors 3 // bd71828-regulator.c ROHM BD71828GW-DS1 regulator driver 4 // 5 6 #include <linux/delay.h> 7 #include <linux/err.h> 8 #include <linux/interrupt.h> 9 #include <linux/kernel.h> 10 #include <linux/mfd/rohm-bd71828.h> 11 #include <linux/module.h> 12 #include <linux/of.h> 13 #include <linux/platform_device.h> 14 #include <linux/regmap.h> 15 #include <linux/regulator/driver.h> 16 #include <linux/regulator/machine.h> 17 #include <linux/regulator/of_regulator.h> 18 19 struct reg_init { 20 unsigned int reg; 21 unsigned int mask; 22 unsigned int val; 23 }; 24 struct bd71828_regulator_data { 25 struct regulator_desc desc; 26 const struct rohm_dvs_config dvs; 27 const struct reg_init *reg_inits; 28 int reg_init_amnt; 29 }; 30 31 static const struct reg_init buck1_inits[] = { 32 /* 33 * DVS Buck voltages can be changed by register values or via GPIO. 34 * Use register accesses by default. 35 */ 36 { 37 .reg = BD71828_REG_PS_CTRL_1, 38 .mask = BD71828_MASK_DVS_BUCK1_CTRL, 39 .val = BD71828_DVS_BUCK1_CTRL_I2C, 40 }, 41 }; 42 43 static const struct reg_init buck2_inits[] = { 44 { 45 .reg = BD71828_REG_PS_CTRL_1, 46 .mask = BD71828_MASK_DVS_BUCK2_CTRL, 47 .val = BD71828_DVS_BUCK2_CTRL_I2C, 48 }, 49 }; 50 51 static const struct reg_init buck6_inits[] = { 52 { 53 .reg = BD71828_REG_PS_CTRL_1, 54 .mask = BD71828_MASK_DVS_BUCK6_CTRL, 55 .val = BD71828_DVS_BUCK6_CTRL_I2C, 56 }, 57 }; 58 59 static const struct reg_init buck7_inits[] = { 60 { 61 .reg = BD71828_REG_PS_CTRL_1, 62 .mask = BD71828_MASK_DVS_BUCK7_CTRL, 63 .val = BD71828_DVS_BUCK7_CTRL_I2C, 64 }, 65 }; 66 67 static const struct linear_range bd71828_buck1267_volts[] = { 68 REGULATOR_LINEAR_RANGE(500000, 0x00, 0xef, 6250), 69 REGULATOR_LINEAR_RANGE(2000000, 0xf0, 0xff, 0), 70 }; 71 72 static const struct linear_range bd71828_buck3_volts[] = { 73 REGULATOR_LINEAR_RANGE(1200000, 0x00, 0x0f, 50000), 74 REGULATOR_LINEAR_RANGE(2000000, 0x10, 0x1f, 0), 75 }; 76 77 static const struct linear_range bd71828_buck4_volts[] = { 78 REGULATOR_LINEAR_RANGE(1000000, 0x00, 0x1f, 25000), 79 REGULATOR_LINEAR_RANGE(1800000, 0x20, 0x3f, 0), 80 }; 81 82 static const struct linear_range bd71828_buck5_volts[] = { 83 REGULATOR_LINEAR_RANGE(2500000, 0x00, 0x0f, 50000), 84 REGULATOR_LINEAR_RANGE(3300000, 0x10, 0x1f, 0), 85 }; 86 87 static const struct linear_range bd71828_ldo_volts[] = { 88 REGULATOR_LINEAR_RANGE(800000, 0x00, 0x31, 50000), 89 REGULATOR_LINEAR_RANGE(3300000, 0x32, 0x3f, 0), 90 }; 91 92 static const unsigned int bd71828_ramp_delay[] = { 2500, 5000, 10000, 20000 }; 93 buck_set_hw_dvs_levels(struct device_node * np,const struct regulator_desc * desc,struct regulator_config * cfg)94 static int buck_set_hw_dvs_levels(struct device_node *np, 95 const struct regulator_desc *desc, 96 struct regulator_config *cfg) 97 { 98 struct bd71828_regulator_data *data; 99 100 data = container_of(desc, struct bd71828_regulator_data, desc); 101 102 return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap); 103 } 104 ldo6_parse_dt(struct device_node * np,const struct regulator_desc * desc,struct regulator_config * cfg)105 static int ldo6_parse_dt(struct device_node *np, 106 const struct regulator_desc *desc, 107 struct regulator_config *cfg) 108 { 109 int ret, i; 110 uint32_t uv = 0; 111 unsigned int en; 112 struct regmap *regmap = cfg->regmap; 113 static const char * const props[] = { "rohm,dvs-run-voltage", 114 "rohm,dvs-idle-voltage", 115 "rohm,dvs-suspend-voltage", 116 "rohm,dvs-lpsr-voltage" }; 117 unsigned int mask[] = { BD71828_MASK_RUN_EN, BD71828_MASK_IDLE_EN, 118 BD71828_MASK_SUSP_EN, BD71828_MASK_LPSR_EN }; 119 120 for (i = 0; i < ARRAY_SIZE(props); i++) { 121 ret = of_property_read_u32(np, props[i], &uv); 122 if (ret) { 123 if (ret != -EINVAL) 124 return ret; 125 continue; 126 } 127 if (uv) 128 en = 0xffffffff; 129 else 130 en = 0; 131 132 ret = regmap_update_bits(regmap, desc->enable_reg, mask[i], en); 133 if (ret) 134 return ret; 135 } 136 return 0; 137 } 138 139 static const struct regulator_ops bd71828_buck_ops = { 140 .enable = regulator_enable_regmap, 141 .disable = regulator_disable_regmap, 142 .is_enabled = regulator_is_enabled_regmap, 143 .list_voltage = regulator_list_voltage_linear_range, 144 .set_voltage_sel = regulator_set_voltage_sel_regmap, 145 .get_voltage_sel = regulator_get_voltage_sel_regmap, 146 }; 147 148 static const struct regulator_ops bd71828_dvs_buck_ops = { 149 .enable = regulator_enable_regmap, 150 .disable = regulator_disable_regmap, 151 .is_enabled = regulator_is_enabled_regmap, 152 .list_voltage = regulator_list_voltage_linear_range, 153 .set_voltage_sel = regulator_set_voltage_sel_regmap, 154 .get_voltage_sel = regulator_get_voltage_sel_regmap, 155 .set_voltage_time_sel = regulator_set_voltage_time_sel, 156 .set_ramp_delay = regulator_set_ramp_delay_regmap, 157 }; 158 159 static const struct regulator_ops bd71828_ldo_ops = { 160 .enable = regulator_enable_regmap, 161 .disable = regulator_disable_regmap, 162 .is_enabled = regulator_is_enabled_regmap, 163 .list_voltage = regulator_list_voltage_linear_range, 164 .set_voltage_sel = regulator_set_voltage_sel_regmap, 165 .get_voltage_sel = regulator_get_voltage_sel_regmap, 166 }; 167 168 static const struct regulator_ops bd71828_ldo6_ops = { 169 .enable = regulator_enable_regmap, 170 .disable = regulator_disable_regmap, 171 .is_enabled = regulator_is_enabled_regmap, 172 }; 173 174 static const struct bd71828_regulator_data bd71828_rdata[] = { 175 { 176 .desc = { 177 .name = "buck1", 178 .of_match = of_match_ptr("BUCK1"), 179 .regulators_node = of_match_ptr("regulators"), 180 .id = BD71828_BUCK1, 181 .ops = &bd71828_dvs_buck_ops, 182 .type = REGULATOR_VOLTAGE, 183 .linear_ranges = bd71828_buck1267_volts, 184 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts), 185 .n_voltages = BD71828_BUCK1267_VOLTS, 186 .enable_reg = BD71828_REG_BUCK1_EN, 187 .enable_mask = BD71828_MASK_RUN_EN, 188 .vsel_reg = BD71828_REG_BUCK1_VOLT, 189 .vsel_mask = BD71828_MASK_BUCK1267_VOLT, 190 .ramp_delay_table = bd71828_ramp_delay, 191 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay), 192 .ramp_reg = BD71828_REG_BUCK1_MODE, 193 .ramp_mask = BD71828_MASK_RAMP_DELAY, 194 .owner = THIS_MODULE, 195 .of_parse_cb = buck_set_hw_dvs_levels, 196 }, 197 .dvs = { 198 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 199 ROHM_DVS_LEVEL_SUSPEND | 200 ROHM_DVS_LEVEL_LPSR, 201 .run_reg = BD71828_REG_BUCK1_VOLT, 202 .run_mask = BD71828_MASK_BUCK1267_VOLT, 203 .idle_reg = BD71828_REG_BUCK1_IDLE_VOLT, 204 .idle_mask = BD71828_MASK_BUCK1267_VOLT, 205 .idle_on_mask = BD71828_MASK_IDLE_EN, 206 .suspend_reg = BD71828_REG_BUCK1_SUSP_VOLT, 207 .suspend_mask = BD71828_MASK_BUCK1267_VOLT, 208 .suspend_on_mask = BD71828_MASK_SUSP_EN, 209 /* 210 * LPSR voltage is same as SUSPEND voltage. Allow 211 * only enabling/disabling regulator for LPSR state 212 */ 213 .lpsr_on_mask = BD71828_MASK_LPSR_EN, 214 }, 215 .reg_inits = buck1_inits, 216 .reg_init_amnt = ARRAY_SIZE(buck1_inits), 217 }, 218 { 219 .desc = { 220 .name = "buck2", 221 .of_match = of_match_ptr("BUCK2"), 222 .regulators_node = of_match_ptr("regulators"), 223 .id = BD71828_BUCK2, 224 .ops = &bd71828_dvs_buck_ops, 225 .type = REGULATOR_VOLTAGE, 226 .linear_ranges = bd71828_buck1267_volts, 227 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts), 228 .n_voltages = BD71828_BUCK1267_VOLTS, 229 .enable_reg = BD71828_REG_BUCK2_EN, 230 .enable_mask = BD71828_MASK_RUN_EN, 231 .vsel_reg = BD71828_REG_BUCK2_VOLT, 232 .vsel_mask = BD71828_MASK_BUCK1267_VOLT, 233 .ramp_delay_table = bd71828_ramp_delay, 234 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay), 235 .ramp_reg = BD71828_REG_BUCK2_MODE, 236 .ramp_mask = BD71828_MASK_RAMP_DELAY, 237 .owner = THIS_MODULE, 238 .of_parse_cb = buck_set_hw_dvs_levels, 239 }, 240 .dvs = { 241 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 242 ROHM_DVS_LEVEL_SUSPEND | 243 ROHM_DVS_LEVEL_LPSR, 244 .run_reg = BD71828_REG_BUCK2_VOLT, 245 .run_mask = BD71828_MASK_BUCK1267_VOLT, 246 .idle_reg = BD71828_REG_BUCK2_IDLE_VOLT, 247 .idle_mask = BD71828_MASK_BUCK1267_VOLT, 248 .idle_on_mask = BD71828_MASK_IDLE_EN, 249 .suspend_reg = BD71828_REG_BUCK2_SUSP_VOLT, 250 .suspend_mask = BD71828_MASK_BUCK1267_VOLT, 251 .suspend_on_mask = BD71828_MASK_SUSP_EN, 252 .lpsr_on_mask = BD71828_MASK_LPSR_EN, 253 .lpsr_reg = BD71828_REG_BUCK2_SUSP_VOLT, 254 .lpsr_mask = BD71828_MASK_BUCK1267_VOLT, 255 }, 256 .reg_inits = buck2_inits, 257 .reg_init_amnt = ARRAY_SIZE(buck2_inits), 258 }, 259 { 260 .desc = { 261 .name = "buck3", 262 .of_match = of_match_ptr("BUCK3"), 263 .regulators_node = of_match_ptr("regulators"), 264 .id = BD71828_BUCK3, 265 .ops = &bd71828_buck_ops, 266 .type = REGULATOR_VOLTAGE, 267 .linear_ranges = bd71828_buck3_volts, 268 .n_linear_ranges = ARRAY_SIZE(bd71828_buck3_volts), 269 .n_voltages = BD71828_BUCK3_VOLTS, 270 .enable_reg = BD71828_REG_BUCK3_EN, 271 .enable_mask = BD71828_MASK_RUN_EN, 272 .vsel_reg = BD71828_REG_BUCK3_VOLT, 273 .vsel_mask = BD71828_MASK_BUCK3_VOLT, 274 .owner = THIS_MODULE, 275 .of_parse_cb = buck_set_hw_dvs_levels, 276 }, 277 .dvs = { 278 /* 279 * BUCK3 only supports single voltage for all states. 280 * voltage can be individually enabled for each state 281 * though => allow setting all states to support 282 * enabling power rail on different states. 283 */ 284 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 285 ROHM_DVS_LEVEL_SUSPEND | 286 ROHM_DVS_LEVEL_LPSR, 287 .run_reg = BD71828_REG_BUCK3_VOLT, 288 .run_mask = BD71828_MASK_BUCK3_VOLT, 289 .idle_on_mask = BD71828_MASK_IDLE_EN, 290 .suspend_on_mask = BD71828_MASK_SUSP_EN, 291 .lpsr_on_mask = BD71828_MASK_LPSR_EN, 292 }, 293 }, 294 { 295 .desc = { 296 .name = "buck4", 297 .of_match = of_match_ptr("BUCK4"), 298 .regulators_node = of_match_ptr("regulators"), 299 .id = BD71828_BUCK4, 300 .ops = &bd71828_buck_ops, 301 .type = REGULATOR_VOLTAGE, 302 .linear_ranges = bd71828_buck4_volts, 303 .n_linear_ranges = ARRAY_SIZE(bd71828_buck4_volts), 304 .n_voltages = BD71828_BUCK4_VOLTS, 305 .enable_reg = BD71828_REG_BUCK4_EN, 306 .enable_mask = BD71828_MASK_RUN_EN, 307 .vsel_reg = BD71828_REG_BUCK4_VOLT, 308 .vsel_mask = BD71828_MASK_BUCK4_VOLT, 309 .owner = THIS_MODULE, 310 .of_parse_cb = buck_set_hw_dvs_levels, 311 }, 312 .dvs = { 313 /* 314 * BUCK4 only supports single voltage for all states. 315 * voltage can be individually enabled for each state 316 * though => allow setting all states to support 317 * enabling power rail on different states. 318 */ 319 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 320 ROHM_DVS_LEVEL_SUSPEND | 321 ROHM_DVS_LEVEL_LPSR, 322 .run_reg = BD71828_REG_BUCK4_VOLT, 323 .run_mask = BD71828_MASK_BUCK4_VOLT, 324 .idle_on_mask = BD71828_MASK_IDLE_EN, 325 .suspend_on_mask = BD71828_MASK_SUSP_EN, 326 .lpsr_on_mask = BD71828_MASK_LPSR_EN, 327 }, 328 }, 329 { 330 .desc = { 331 .name = "buck5", 332 .of_match = of_match_ptr("BUCK5"), 333 .regulators_node = of_match_ptr("regulators"), 334 .id = BD71828_BUCK5, 335 .ops = &bd71828_buck_ops, 336 .type = REGULATOR_VOLTAGE, 337 .linear_ranges = bd71828_buck5_volts, 338 .n_linear_ranges = ARRAY_SIZE(bd71828_buck5_volts), 339 .n_voltages = BD71828_BUCK5_VOLTS, 340 .enable_reg = BD71828_REG_BUCK5_EN, 341 .enable_mask = BD71828_MASK_RUN_EN, 342 .vsel_reg = BD71828_REG_BUCK5_VOLT, 343 .vsel_mask = BD71828_MASK_BUCK5_VOLT, 344 .owner = THIS_MODULE, 345 .of_parse_cb = buck_set_hw_dvs_levels, 346 }, 347 .dvs = { 348 /* 349 * BUCK5 only supports single voltage for all states. 350 * voltage can be individually enabled for each state 351 * though => allow setting all states to support 352 * enabling power rail on different states. 353 */ 354 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 355 ROHM_DVS_LEVEL_SUSPEND | 356 ROHM_DVS_LEVEL_LPSR, 357 .run_reg = BD71828_REG_BUCK5_VOLT, 358 .run_mask = BD71828_MASK_BUCK5_VOLT, 359 .idle_on_mask = BD71828_MASK_IDLE_EN, 360 .suspend_on_mask = BD71828_MASK_SUSP_EN, 361 .lpsr_on_mask = BD71828_MASK_LPSR_EN, 362 }, 363 }, 364 { 365 .desc = { 366 .name = "buck6", 367 .of_match = of_match_ptr("BUCK6"), 368 .regulators_node = of_match_ptr("regulators"), 369 .id = BD71828_BUCK6, 370 .ops = &bd71828_dvs_buck_ops, 371 .type = REGULATOR_VOLTAGE, 372 .linear_ranges = bd71828_buck1267_volts, 373 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts), 374 .n_voltages = BD71828_BUCK1267_VOLTS, 375 .enable_reg = BD71828_REG_BUCK6_EN, 376 .enable_mask = BD71828_MASK_RUN_EN, 377 .vsel_reg = BD71828_REG_BUCK6_VOLT, 378 .vsel_mask = BD71828_MASK_BUCK1267_VOLT, 379 .ramp_delay_table = bd71828_ramp_delay, 380 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay), 381 .ramp_reg = BD71828_REG_BUCK6_MODE, 382 .ramp_mask = BD71828_MASK_RAMP_DELAY, 383 .owner = THIS_MODULE, 384 .of_parse_cb = buck_set_hw_dvs_levels, 385 }, 386 .dvs = { 387 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 388 ROHM_DVS_LEVEL_SUSPEND | 389 ROHM_DVS_LEVEL_LPSR, 390 .run_reg = BD71828_REG_BUCK6_VOLT, 391 .run_mask = BD71828_MASK_BUCK1267_VOLT, 392 .idle_reg = BD71828_REG_BUCK6_IDLE_VOLT, 393 .idle_mask = BD71828_MASK_BUCK1267_VOLT, 394 .idle_on_mask = BD71828_MASK_IDLE_EN, 395 .suspend_reg = BD71828_REG_BUCK6_SUSP_VOLT, 396 .suspend_mask = BD71828_MASK_BUCK1267_VOLT, 397 .suspend_on_mask = BD71828_MASK_SUSP_EN, 398 .lpsr_on_mask = BD71828_MASK_LPSR_EN, 399 .lpsr_reg = BD71828_REG_BUCK6_SUSP_VOLT, 400 .lpsr_mask = BD71828_MASK_BUCK1267_VOLT, 401 }, 402 .reg_inits = buck6_inits, 403 .reg_init_amnt = ARRAY_SIZE(buck6_inits), 404 }, 405 { 406 .desc = { 407 .name = "buck7", 408 .of_match = of_match_ptr("BUCK7"), 409 .regulators_node = of_match_ptr("regulators"), 410 .id = BD71828_BUCK7, 411 .ops = &bd71828_dvs_buck_ops, 412 .type = REGULATOR_VOLTAGE, 413 .linear_ranges = bd71828_buck1267_volts, 414 .n_linear_ranges = ARRAY_SIZE(bd71828_buck1267_volts), 415 .n_voltages = BD71828_BUCK1267_VOLTS, 416 .enable_reg = BD71828_REG_BUCK7_EN, 417 .enable_mask = BD71828_MASK_RUN_EN, 418 .vsel_reg = BD71828_REG_BUCK7_VOLT, 419 .vsel_mask = BD71828_MASK_BUCK1267_VOLT, 420 .ramp_delay_table = bd71828_ramp_delay, 421 .n_ramp_values = ARRAY_SIZE(bd71828_ramp_delay), 422 .ramp_reg = BD71828_REG_BUCK7_MODE, 423 .ramp_mask = BD71828_MASK_RAMP_DELAY, 424 .owner = THIS_MODULE, 425 .of_parse_cb = buck_set_hw_dvs_levels, 426 }, 427 .dvs = { 428 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 429 ROHM_DVS_LEVEL_SUSPEND | 430 ROHM_DVS_LEVEL_LPSR, 431 .run_reg = BD71828_REG_BUCK7_VOLT, 432 .run_mask = BD71828_MASK_BUCK1267_VOLT, 433 .idle_reg = BD71828_REG_BUCK7_IDLE_VOLT, 434 .idle_mask = BD71828_MASK_BUCK1267_VOLT, 435 .idle_on_mask = BD71828_MASK_IDLE_EN, 436 .suspend_reg = BD71828_REG_BUCK7_SUSP_VOLT, 437 .suspend_mask = BD71828_MASK_BUCK1267_VOLT, 438 .suspend_on_mask = BD71828_MASK_SUSP_EN, 439 .lpsr_on_mask = BD71828_MASK_LPSR_EN, 440 .lpsr_reg = BD71828_REG_BUCK7_SUSP_VOLT, 441 .lpsr_mask = BD71828_MASK_BUCK1267_VOLT, 442 }, 443 .reg_inits = buck7_inits, 444 .reg_init_amnt = ARRAY_SIZE(buck7_inits), 445 }, 446 { 447 .desc = { 448 .name = "ldo1", 449 .of_match = of_match_ptr("LDO1"), 450 .regulators_node = of_match_ptr("regulators"), 451 .id = BD71828_LDO1, 452 .ops = &bd71828_ldo_ops, 453 .type = REGULATOR_VOLTAGE, 454 .linear_ranges = bd71828_ldo_volts, 455 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts), 456 .n_voltages = BD71828_LDO_VOLTS, 457 .enable_reg = BD71828_REG_LDO1_EN, 458 .enable_mask = BD71828_MASK_RUN_EN, 459 .vsel_reg = BD71828_REG_LDO1_VOLT, 460 .vsel_mask = BD71828_MASK_LDO_VOLT, 461 .owner = THIS_MODULE, 462 .of_parse_cb = buck_set_hw_dvs_levels, 463 }, 464 .dvs = { 465 /* 466 * LDO1 only supports single voltage for all states. 467 * voltage can be individually enabled for each state 468 * though => allow setting all states to support 469 * enabling power rail on different states. 470 */ 471 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 472 ROHM_DVS_LEVEL_SUSPEND | 473 ROHM_DVS_LEVEL_LPSR, 474 .run_reg = BD71828_REG_LDO1_VOLT, 475 .run_mask = BD71828_MASK_LDO_VOLT, 476 .idle_on_mask = BD71828_MASK_IDLE_EN, 477 .suspend_on_mask = BD71828_MASK_SUSP_EN, 478 .lpsr_on_mask = BD71828_MASK_LPSR_EN, 479 }, 480 }, { 481 .desc = { 482 .name = "ldo2", 483 .of_match = of_match_ptr("LDO2"), 484 .regulators_node = of_match_ptr("regulators"), 485 .id = BD71828_LDO2, 486 .ops = &bd71828_ldo_ops, 487 .type = REGULATOR_VOLTAGE, 488 .linear_ranges = bd71828_ldo_volts, 489 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts), 490 .n_voltages = BD71828_LDO_VOLTS, 491 .enable_reg = BD71828_REG_LDO2_EN, 492 .enable_mask = BD71828_MASK_RUN_EN, 493 .vsel_reg = BD71828_REG_LDO2_VOLT, 494 .vsel_mask = BD71828_MASK_LDO_VOLT, 495 .owner = THIS_MODULE, 496 .of_parse_cb = buck_set_hw_dvs_levels, 497 }, 498 .dvs = { 499 /* 500 * LDO2 only supports single voltage for all states. 501 * voltage can be individually enabled for each state 502 * though => allow setting all states to support 503 * enabling power rail on different states. 504 */ 505 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 506 ROHM_DVS_LEVEL_SUSPEND | 507 ROHM_DVS_LEVEL_LPSR, 508 .run_reg = BD71828_REG_LDO2_VOLT, 509 .run_mask = BD71828_MASK_LDO_VOLT, 510 .idle_on_mask = BD71828_MASK_IDLE_EN, 511 .suspend_on_mask = BD71828_MASK_SUSP_EN, 512 .lpsr_on_mask = BD71828_MASK_LPSR_EN, 513 }, 514 }, { 515 .desc = { 516 .name = "ldo3", 517 .of_match = of_match_ptr("LDO3"), 518 .regulators_node = of_match_ptr("regulators"), 519 .id = BD71828_LDO3, 520 .ops = &bd71828_ldo_ops, 521 .type = REGULATOR_VOLTAGE, 522 .linear_ranges = bd71828_ldo_volts, 523 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts), 524 .n_voltages = BD71828_LDO_VOLTS, 525 .enable_reg = BD71828_REG_LDO3_EN, 526 .enable_mask = BD71828_MASK_RUN_EN, 527 .vsel_reg = BD71828_REG_LDO3_VOLT, 528 .vsel_mask = BD71828_MASK_LDO_VOLT, 529 .owner = THIS_MODULE, 530 .of_parse_cb = buck_set_hw_dvs_levels, 531 }, 532 .dvs = { 533 /* 534 * LDO3 only supports single voltage for all states. 535 * voltage can be individually enabled for each state 536 * though => allow setting all states to support 537 * enabling power rail on different states. 538 */ 539 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 540 ROHM_DVS_LEVEL_SUSPEND | 541 ROHM_DVS_LEVEL_LPSR, 542 .run_reg = BD71828_REG_LDO3_VOLT, 543 .run_mask = BD71828_MASK_LDO_VOLT, 544 .idle_on_mask = BD71828_MASK_IDLE_EN, 545 .suspend_on_mask = BD71828_MASK_SUSP_EN, 546 .lpsr_on_mask = BD71828_MASK_LPSR_EN, 547 }, 548 549 }, { 550 .desc = { 551 .name = "ldo4", 552 .of_match = of_match_ptr("LDO4"), 553 .regulators_node = of_match_ptr("regulators"), 554 .id = BD71828_LDO4, 555 .ops = &bd71828_ldo_ops, 556 .type = REGULATOR_VOLTAGE, 557 .linear_ranges = bd71828_ldo_volts, 558 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts), 559 .n_voltages = BD71828_LDO_VOLTS, 560 .enable_reg = BD71828_REG_LDO4_EN, 561 .enable_mask = BD71828_MASK_RUN_EN, 562 .vsel_reg = BD71828_REG_LDO4_VOLT, 563 .vsel_mask = BD71828_MASK_LDO_VOLT, 564 .owner = THIS_MODULE, 565 .of_parse_cb = buck_set_hw_dvs_levels, 566 }, 567 .dvs = { 568 /* 569 * LDO1 only supports single voltage for all states. 570 * voltage can be individually enabled for each state 571 * though => allow setting all states to support 572 * enabling power rail on different states. 573 */ 574 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 575 ROHM_DVS_LEVEL_SUSPEND | 576 ROHM_DVS_LEVEL_LPSR, 577 .run_reg = BD71828_REG_LDO4_VOLT, 578 .run_mask = BD71828_MASK_LDO_VOLT, 579 .idle_on_mask = BD71828_MASK_IDLE_EN, 580 .suspend_on_mask = BD71828_MASK_SUSP_EN, 581 .lpsr_on_mask = BD71828_MASK_LPSR_EN, 582 }, 583 }, { 584 .desc = { 585 .name = "ldo5", 586 .of_match = of_match_ptr("LDO5"), 587 .regulators_node = of_match_ptr("regulators"), 588 .id = BD71828_LDO5, 589 .ops = &bd71828_ldo_ops, 590 .type = REGULATOR_VOLTAGE, 591 .linear_ranges = bd71828_ldo_volts, 592 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts), 593 .n_voltages = BD71828_LDO_VOLTS, 594 .enable_reg = BD71828_REG_LDO5_EN, 595 .enable_mask = BD71828_MASK_RUN_EN, 596 .vsel_reg = BD71828_REG_LDO5_VOLT, 597 .vsel_mask = BD71828_MASK_LDO_VOLT, 598 .of_parse_cb = buck_set_hw_dvs_levels, 599 .owner = THIS_MODULE, 600 }, 601 /* 602 * LDO5 is special. It can choose vsel settings to be configured 603 * from 2 different registers (by GPIO). 604 * 605 * This driver supports only configuration where 606 * BD71828_REG_LDO5_VOLT_L is used. 607 */ 608 .dvs = { 609 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 610 ROHM_DVS_LEVEL_SUSPEND | 611 ROHM_DVS_LEVEL_LPSR, 612 .run_reg = BD71828_REG_LDO5_VOLT, 613 .run_mask = BD71828_MASK_LDO_VOLT, 614 .idle_on_mask = BD71828_MASK_IDLE_EN, 615 .suspend_on_mask = BD71828_MASK_SUSP_EN, 616 .lpsr_on_mask = BD71828_MASK_LPSR_EN, 617 }, 618 619 }, { 620 .desc = { 621 .name = "ldo6", 622 .of_match = of_match_ptr("LDO6"), 623 .regulators_node = of_match_ptr("regulators"), 624 .id = BD71828_LDO6, 625 .ops = &bd71828_ldo6_ops, 626 .type = REGULATOR_VOLTAGE, 627 .fixed_uV = BD71828_LDO_6_VOLTAGE, 628 .n_voltages = 1, 629 .enable_reg = BD71828_REG_LDO6_EN, 630 .enable_mask = BD71828_MASK_RUN_EN, 631 .owner = THIS_MODULE, 632 /* 633 * LDO6 only supports enable/disable for all states. 634 * Voltage for LDO6 is fixed. 635 */ 636 .of_parse_cb = ldo6_parse_dt, 637 }, 638 }, { 639 .desc = { 640 /* SNVS LDO in data-sheet */ 641 .name = "ldo7", 642 .of_match = of_match_ptr("LDO7"), 643 .regulators_node = of_match_ptr("regulators"), 644 .id = BD71828_LDO_SNVS, 645 .ops = &bd71828_ldo_ops, 646 .type = REGULATOR_VOLTAGE, 647 .linear_ranges = bd71828_ldo_volts, 648 .n_linear_ranges = ARRAY_SIZE(bd71828_ldo_volts), 649 .n_voltages = BD71828_LDO_VOLTS, 650 .enable_reg = BD71828_REG_LDO7_EN, 651 .enable_mask = BD71828_MASK_RUN_EN, 652 .vsel_reg = BD71828_REG_LDO7_VOLT, 653 .vsel_mask = BD71828_MASK_LDO_VOLT, 654 .owner = THIS_MODULE, 655 .of_parse_cb = buck_set_hw_dvs_levels, 656 }, 657 .dvs = { 658 /* 659 * LDO7 only supports single voltage for all states. 660 * voltage can be individually enabled for each state 661 * though => allow setting all states to support 662 * enabling power rail on different states. 663 */ 664 .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE | 665 ROHM_DVS_LEVEL_SUSPEND | 666 ROHM_DVS_LEVEL_LPSR, 667 .run_reg = BD71828_REG_LDO7_VOLT, 668 .idle_reg = BD71828_REG_LDO7_VOLT, 669 .suspend_reg = BD71828_REG_LDO7_VOLT, 670 .lpsr_reg = BD71828_REG_LDO7_VOLT, 671 .run_mask = BD71828_MASK_LDO_VOLT, 672 .idle_on_mask = BD71828_MASK_IDLE_EN, 673 .suspend_on_mask = BD71828_MASK_SUSP_EN, 674 .lpsr_on_mask = BD71828_MASK_LPSR_EN, 675 }, 676 677 }, 678 }; 679 bd71828_probe(struct platform_device * pdev)680 static int bd71828_probe(struct platform_device *pdev) 681 { 682 int i, j, ret; 683 struct regulator_config config = { 684 .dev = pdev->dev.parent, 685 }; 686 687 config.regmap = dev_get_regmap(pdev->dev.parent, NULL); 688 if (!config.regmap) 689 return -ENODEV; 690 691 for (i = 0; i < ARRAY_SIZE(bd71828_rdata); i++) { 692 struct regulator_dev *rdev; 693 const struct bd71828_regulator_data *rd; 694 695 rd = &bd71828_rdata[i]; 696 rdev = devm_regulator_register(&pdev->dev, 697 &rd->desc, &config); 698 if (IS_ERR(rdev)) 699 return dev_err_probe(&pdev->dev, PTR_ERR(rdev), 700 "failed to register %s regulator\n", 701 rd->desc.name); 702 703 for (j = 0; j < rd->reg_init_amnt; j++) { 704 ret = regmap_update_bits(config.regmap, 705 rd->reg_inits[j].reg, 706 rd->reg_inits[j].mask, 707 rd->reg_inits[j].val); 708 if (ret) 709 return dev_err_probe(&pdev->dev, ret, 710 "regulator %s init failed\n", 711 rd->desc.name); 712 } 713 } 714 return 0; 715 } 716 717 static struct platform_driver bd71828_regulator = { 718 .driver = { 719 .name = "bd71828-pmic", 720 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 721 }, 722 .probe = bd71828_probe, 723 }; 724 725 module_platform_driver(bd71828_regulator); 726 727 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>"); 728 MODULE_DESCRIPTION("BD71828 voltage regulator driver"); 729 MODULE_LICENSE("GPL"); 730 MODULE_ALIAS("platform:bd71828-pmic"); 731