1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (C) 2024 ROHM Semiconductors 3 // bd96801-regulator.c ROHM BD96801 regulator driver 4 5 /* 6 * This version of the "BD86801 scalable PMIC"'s driver supports only very 7 * basic set of the PMIC features. Most notably, there is no support for 8 * the ERRB interrupt and the configurations which should be done when the 9 * PMIC is in STBY mode. 10 * 11 * Supporting the ERRB interrupt would require dropping the regmap-IRQ 12 * usage or working around (or accepting a presense of) a naming conflict 13 * in debugFS IRQs. 14 * 15 * Being able to reliably do the configurations like changing the 16 * regulator safety limits (like limits for the over/under -voltages, over 17 * current, thermal protection) would require the configuring driver to be 18 * synchronized with entity causing the PMIC state transitions. Eg, one 19 * should be able to ensure the PMIC is in STBY state when the 20 * configurations are applied to the hardware. How and when the PMIC state 21 * transitions are to be done is likely to be very system specific, as will 22 * be the need to configure these safety limits. Hence it's not simple to 23 * come up with a generic solution. 24 * 25 * Users who require the ERRB handling and STBY state configurations can 26 * have a look at the original RFC: 27 * https://lore.kernel.org/all/cover.1712920132.git.mazziesaccount@gmail.com/ 28 * which implements a workaround to debugFS naming conflict and some of 29 * the safety limit configurations - but leaves the state change handling 30 * and synchronization to be implemented. 31 * 32 * It would be great to hear (and receive a patch!) if you implement the 33 * STBY configuration support or a proper fix to the debugFS naming 34 * conflict in your downstream driver ;) 35 */ 36 37 #include <linux/cleanup.h> 38 #include <linux/delay.h> 39 #include <linux/err.h> 40 #include <linux/interrupt.h> 41 #include <linux/kernel.h> 42 #include <linux/linear_range.h> 43 #include <linux/mfd/rohm-generic.h> 44 #include <linux/mfd/rohm-bd96801.h> 45 #include <linux/module.h> 46 #include <linux/of.h> 47 #include <linux/platform_device.h> 48 #include <linux/regmap.h> 49 #include <linux/regulator/coupler.h> 50 #include <linux/regulator/driver.h> 51 #include <linux/regulator/machine.h> 52 #include <linux/regulator/of_regulator.h> 53 #include <linux/slab.h> 54 #include <linux/timer.h> 55 56 enum { 57 BD96801_BUCK1, 58 BD96801_BUCK2, 59 BD96801_BUCK3, 60 BD96801_BUCK4, 61 BD96801_LDO5, 62 BD96801_LDO6, 63 BD96801_LDO7, 64 BD96801_REGULATOR_AMOUNT, 65 }; 66 67 enum { 68 BD96801_PROT_OVP, 69 BD96801_PROT_UVP, 70 BD96801_PROT_OCP, 71 BD96801_PROT_TEMP, 72 BD96801_NUM_PROT, 73 }; 74 75 #define BD96801_ALWAYS_ON_REG 0x3c 76 #define BD96801_REG_ENABLE 0x0b 77 #define BD96801_BUCK1_EN_MASK BIT(0) 78 #define BD96801_BUCK2_EN_MASK BIT(1) 79 #define BD96801_BUCK3_EN_MASK BIT(2) 80 #define BD96801_BUCK4_EN_MASK BIT(3) 81 #define BD96801_LDO5_EN_MASK BIT(4) 82 #define BD96801_LDO6_EN_MASK BIT(5) 83 #define BD96801_LDO7_EN_MASK BIT(6) 84 85 #define BD96801_BUCK1_VSEL_REG 0x28 86 #define BD96801_BUCK2_VSEL_REG 0x29 87 #define BD96801_BUCK3_VSEL_REG 0x2a 88 #define BD96801_BUCK4_VSEL_REG 0x2b 89 #define BD96801_LDO5_VSEL_REG 0x25 90 #define BD96801_LDO6_VSEL_REG 0x26 91 #define BD96801_LDO7_VSEL_REG 0x27 92 #define BD96801_BUCK_VSEL_MASK 0x1F 93 #define BD96801_LDO_VSEL_MASK 0xff 94 95 #define BD96801_MASK_RAMP_DELAY 0xc0 96 #define BD96801_INT_VOUT_BASE_REG 0x21 97 #define BD96801_BUCK_INT_VOUT_MASK 0xff 98 99 #define BD96801_BUCK_VOLTS 256 100 #define BD96801_LDO_VOLTS 256 101 102 #define BD96801_OVP_MASK 0x03 103 #define BD96801_MASK_BUCK1_OVP_SHIFT 0x00 104 #define BD96801_MASK_BUCK2_OVP_SHIFT 0x02 105 #define BD96801_MASK_BUCK3_OVP_SHIFT 0x04 106 #define BD96801_MASK_BUCK4_OVP_SHIFT 0x06 107 #define BD96801_MASK_LDO5_OVP_SHIFT 0x00 108 #define BD96801_MASK_LDO6_OVP_SHIFT 0x02 109 #define BD96801_MASK_LDO7_OVP_SHIFT 0x04 110 111 #define BD96801_PROT_LIMIT_OCP_MIN 0x00 112 #define BD96801_PROT_LIMIT_LOW 0x01 113 #define BD96801_PROT_LIMIT_MID 0x02 114 #define BD96801_PROT_LIMIT_HI 0x03 115 116 #define BD96801_REG_BUCK1_OCP 0x32 117 #define BD96801_REG_BUCK2_OCP 0x32 118 #define BD96801_REG_BUCK3_OCP 0x33 119 #define BD96801_REG_BUCK4_OCP 0x33 120 121 #define BD96801_MASK_BUCK1_OCP_SHIFT 0x00 122 #define BD96801_MASK_BUCK2_OCP_SHIFT 0x04 123 #define BD96801_MASK_BUCK3_OCP_SHIFT 0x00 124 #define BD96801_MASK_BUCK4_OCP_SHIFT 0x04 125 126 #define BD96801_REG_LDO5_OCP 0x34 127 #define BD96801_REG_LDO6_OCP 0x34 128 #define BD96801_REG_LDO7_OCP 0x34 129 130 #define BD96801_MASK_LDO5_OCP_SHIFT 0x00 131 #define BD96801_MASK_LDO6_OCP_SHIFT 0x02 132 #define BD96801_MASK_LDO7_OCP_SHIFT 0x04 133 134 #define BD96801_MASK_SHD_INTB BIT(7) 135 #define BD96801_INTB_FATAL BIT(7) 136 137 #define BD96801_NUM_REGULATORS 7 138 #define BD96801_NUM_LDOS 4 139 140 /* 141 * Ramp rates for bucks are controlled by bits [7:6] as follows: 142 * 00 => 1 mV/uS 143 * 01 => 5 mV/uS 144 * 10 => 10 mV/uS 145 * 11 => 20 mV/uS 146 */ 147 static const unsigned int buck_ramp_table[] = { 1000, 5000, 10000, 20000 }; 148 149 /* 150 * This is a voltage range that get's appended to selected 151 * bd96801_buck_init_volts value. The range from 0x0 to 0xF is actually 152 * bd96801_buck_init_volts + 0 ... bd96801_buck_init_volts + 150mV 153 * and the range from 0x10 to 0x1f is bd96801_buck_init_volts - 150mV ... 154 * bd96801_buck_init_volts - 0. But as the members of linear_range 155 * are all unsigned I will apply offset of -150 mV to value in 156 * linear_range - which should increase these ranges with 157 * 150 mV getting all the values to >= 0. 158 */ 159 static const struct linear_range bd96801_tune_volts[] = { 160 REGULATOR_LINEAR_RANGE(150000, 0x00, 0xF, 10000), 161 REGULATOR_LINEAR_RANGE(0, 0x10, 0x1F, 10000), 162 }; 163 164 static const struct linear_range bd96801_buck_init_volts[] = { 165 REGULATOR_LINEAR_RANGE(500000 - 150000, 0x00, 0xc8, 5000), 166 REGULATOR_LINEAR_RANGE(1550000 - 150000, 0xc9, 0xec, 50000), 167 REGULATOR_LINEAR_RANGE(3300000 - 150000, 0xed, 0xff, 0), 168 }; 169 170 static const struct linear_range bd96801_ldo_int_volts[] = { 171 REGULATOR_LINEAR_RANGE(300000, 0x00, 0x78, 25000), 172 REGULATOR_LINEAR_RANGE(3300000, 0x79, 0xff, 0), 173 }; 174 175 #define BD96801_LDO_SD_VOLT_MASK 0x1 176 #define BD96801_LDO_MODE_MASK 0x6 177 #define BD96801_LDO_MODE_INT 0x0 178 #define BD96801_LDO_MODE_SD 0x2 179 #define BD96801_LDO_MODE_DDR 0x4 180 181 static int ldo_ddr_volt_table[] = {500000, 300000}; 182 static int ldo_sd_volt_table[] = {3300000, 1800000}; 183 184 /* Constant IRQ initialization data (templates) */ 185 struct bd96801_irqinfo { 186 int type; 187 struct regulator_irq_desc irq_desc; 188 int err_cfg; 189 int wrn_cfg; 190 const char *irq_name; 191 }; 192 193 #define BD96801_IRQINFO(_type, _name, _irqoff_ms, _irqname) \ 194 { \ 195 .type = (_type), \ 196 .err_cfg = -1, \ 197 .wrn_cfg = -1, \ 198 .irq_name = (_irqname), \ 199 .irq_desc = { \ 200 .name = (_name), \ 201 .irq_off_ms = (_irqoff_ms), \ 202 .map_event = regulator_irq_map_event_simple, \ 203 }, \ 204 } 205 206 static const struct bd96801_irqinfo buck1_irqinfo[] = { 207 BD96801_IRQINFO(BD96801_PROT_OCP, "buck1-over-curr-h", 500, 208 "bd96801-buck1-overcurr-h"), 209 BD96801_IRQINFO(BD96801_PROT_OCP, "buck1-over-curr-l", 500, 210 "bd96801-buck1-overcurr-l"), 211 BD96801_IRQINFO(BD96801_PROT_OCP, "buck1-over-curr-n", 500, 212 "bd96801-buck1-overcurr-n"), 213 BD96801_IRQINFO(BD96801_PROT_OVP, "buck1-over-voltage", 500, 214 "bd96801-buck1-overvolt"), 215 BD96801_IRQINFO(BD96801_PROT_UVP, "buck1-under-voltage", 500, 216 "bd96801-buck1-undervolt"), 217 BD96801_IRQINFO(BD96801_PROT_TEMP, "buck1-over-temp", 500, 218 "bd96801-buck1-thermal") 219 }; 220 221 static const struct bd96801_irqinfo buck2_irqinfo[] = { 222 BD96801_IRQINFO(BD96801_PROT_OCP, "buck2-over-curr-h", 500, 223 "bd96801-buck2-overcurr-h"), 224 BD96801_IRQINFO(BD96801_PROT_OCP, "buck2-over-curr-l", 500, 225 "bd96801-buck2-overcurr-l"), 226 BD96801_IRQINFO(BD96801_PROT_OCP, "buck2-over-curr-n", 500, 227 "bd96801-buck2-overcurr-n"), 228 BD96801_IRQINFO(BD96801_PROT_OVP, "buck2-over-voltage", 500, 229 "bd96801-buck2-overvolt"), 230 BD96801_IRQINFO(BD96801_PROT_UVP, "buck2-under-voltage", 500, 231 "bd96801-buck2-undervolt"), 232 BD96801_IRQINFO(BD96801_PROT_TEMP, "buck2-over-temp", 500, 233 "bd96801-buck2-thermal") 234 }; 235 236 static const struct bd96801_irqinfo buck3_irqinfo[] = { 237 BD96801_IRQINFO(BD96801_PROT_OCP, "buck3-over-curr-h", 500, 238 "bd96801-buck3-overcurr-h"), 239 BD96801_IRQINFO(BD96801_PROT_OCP, "buck3-over-curr-l", 500, 240 "bd96801-buck3-overcurr-l"), 241 BD96801_IRQINFO(BD96801_PROT_OCP, "buck3-over-curr-n", 500, 242 "bd96801-buck3-overcurr-n"), 243 BD96801_IRQINFO(BD96801_PROT_OVP, "buck3-over-voltage", 500, 244 "bd96801-buck3-overvolt"), 245 BD96801_IRQINFO(BD96801_PROT_UVP, "buck3-under-voltage", 500, 246 "bd96801-buck3-undervolt"), 247 BD96801_IRQINFO(BD96801_PROT_TEMP, "buck3-over-temp", 500, 248 "bd96801-buck3-thermal") 249 }; 250 251 static const struct bd96801_irqinfo buck4_irqinfo[] = { 252 BD96801_IRQINFO(BD96801_PROT_OCP, "buck4-over-curr-h", 500, 253 "bd96801-buck4-overcurr-h"), 254 BD96801_IRQINFO(BD96801_PROT_OCP, "buck4-over-curr-l", 500, 255 "bd96801-buck4-overcurr-l"), 256 BD96801_IRQINFO(BD96801_PROT_OCP, "buck4-over-curr-n", 500, 257 "bd96801-buck4-overcurr-n"), 258 BD96801_IRQINFO(BD96801_PROT_OVP, "buck4-over-voltage", 500, 259 "bd96801-buck4-overvolt"), 260 BD96801_IRQINFO(BD96801_PROT_UVP, "buck4-under-voltage", 500, 261 "bd96801-buck4-undervolt"), 262 BD96801_IRQINFO(BD96801_PROT_TEMP, "buck4-over-temp", 500, 263 "bd96801-buck4-thermal") 264 }; 265 266 static const struct bd96801_irqinfo ldo5_irqinfo[] = { 267 BD96801_IRQINFO(BD96801_PROT_OCP, "ldo5-overcurr", 500, 268 "bd96801-ldo5-overcurr"), 269 BD96801_IRQINFO(BD96801_PROT_OVP, "ldo5-over-voltage", 500, 270 "bd96801-ldo5-overvolt"), 271 BD96801_IRQINFO(BD96801_PROT_UVP, "ldo5-under-voltage", 500, 272 "bd96801-ldo5-undervolt"), 273 }; 274 275 static const struct bd96801_irqinfo ldo6_irqinfo[] = { 276 BD96801_IRQINFO(BD96801_PROT_OCP, "ldo6-overcurr", 500, 277 "bd96801-ldo6-overcurr"), 278 BD96801_IRQINFO(BD96801_PROT_OVP, "ldo6-over-voltage", 500, 279 "bd96801-ldo6-overvolt"), 280 BD96801_IRQINFO(BD96801_PROT_UVP, "ldo6-under-voltage", 500, 281 "bd96801-ldo6-undervolt"), 282 }; 283 284 static const struct bd96801_irqinfo ldo7_irqinfo[] = { 285 BD96801_IRQINFO(BD96801_PROT_OCP, "ldo7-overcurr", 500, 286 "bd96801-ldo7-overcurr"), 287 BD96801_IRQINFO(BD96801_PROT_OVP, "ldo7-over-voltage", 500, 288 "bd96801-ldo7-overvolt"), 289 BD96801_IRQINFO(BD96801_PROT_UVP, "ldo7-under-voltage", 500, 290 "bd96801-ldo7-undervolt"), 291 }; 292 293 struct bd96801_irq_desc { 294 struct bd96801_irqinfo *irqinfo; 295 int num_irqs; 296 }; 297 298 struct bd96801_regulator_data { 299 struct regulator_desc desc; 300 const struct linear_range *init_ranges; 301 int num_ranges; 302 struct bd96801_irq_desc irq_desc; 303 int initial_voltage; 304 int ldo_vol_lvl; 305 int ldo_errs; 306 }; 307 308 struct bd96801_pmic_data { 309 struct bd96801_regulator_data regulator_data[BD96801_NUM_REGULATORS]; 310 struct regmap *regmap; 311 int fatal_ind; 312 }; 313 314 static int ldo_map_notif(int irq, struct regulator_irq_data *rid, 315 unsigned long *dev_mask) 316 { 317 int i; 318 319 for (i = 0; i < rid->num_states; i++) { 320 struct bd96801_regulator_data *rdata; 321 struct regulator_dev *rdev; 322 323 rdev = rid->states[i].rdev; 324 rdata = container_of(rdev->desc, struct bd96801_regulator_data, 325 desc); 326 rid->states[i].notifs = regulator_err2notif(rdata->ldo_errs); 327 rid->states[i].errors = rdata->ldo_errs; 328 *dev_mask |= BIT(i); 329 } 330 return 0; 331 } 332 333 static int bd96801_list_voltage_lr(struct regulator_dev *rdev, 334 unsigned int selector) 335 { 336 int voltage; 337 struct bd96801_regulator_data *data; 338 339 data = container_of(rdev->desc, struct bd96801_regulator_data, desc); 340 341 /* 342 * The BD096801 has voltage setting in two registers. One giving the 343 * "initial voltage" (can be changed only when regulator is disabled. 344 * This driver caches the value and sets it only at startup. The other 345 * register is voltage tuning value which applies -150 mV ... +150 mV 346 * offset to the voltage. 347 * 348 * Note that the cached initial voltage stored in regulator data is 349 * 'scaled down' by the 150 mV so that all of our tuning values are 350 * >= 0. This is done because the linear_ranges uses unsigned values. 351 * 352 * As a result, we increase the tuning voltage which we get based on 353 * the selector by the stored initial_voltage. 354 */ 355 voltage = regulator_list_voltage_linear_range(rdev, selector); 356 if (voltage < 0) 357 return voltage; 358 359 return voltage + data->initial_voltage; 360 } 361 362 363 static const struct regulator_ops bd96801_ldo_table_ops = { 364 .is_enabled = regulator_is_enabled_regmap, 365 .list_voltage = regulator_list_voltage_table, 366 .get_voltage_sel = regulator_get_voltage_sel_regmap, 367 }; 368 369 static const struct regulator_ops bd96801_buck_ops = { 370 .is_enabled = regulator_is_enabled_regmap, 371 .list_voltage = bd96801_list_voltage_lr, 372 .set_voltage_sel = regulator_set_voltage_sel_regmap, 373 .get_voltage_sel = regulator_get_voltage_sel_regmap, 374 .set_voltage_time_sel = regulator_set_voltage_time_sel, 375 .set_ramp_delay = regulator_set_ramp_delay_regmap, 376 }; 377 378 static const struct regulator_ops bd96801_ldo_ops = { 379 .is_enabled = regulator_is_enabled_regmap, 380 .list_voltage = regulator_list_voltage_linear_range, 381 .get_voltage_sel = regulator_get_voltage_sel_regmap, 382 }; 383 384 static int buck_get_initial_voltage(struct regmap *regmap, struct device *dev, 385 struct bd96801_regulator_data *data) 386 { 387 int ret = 0, sel, initial_uv; 388 int reg = BD96801_INT_VOUT_BASE_REG + data->desc.id; 389 390 if (data->num_ranges) { 391 ret = regmap_read(regmap, reg, &sel); 392 sel &= BD96801_BUCK_INT_VOUT_MASK; 393 394 ret = linear_range_get_value_array(data->init_ranges, 395 data->num_ranges, sel, 396 &initial_uv); 397 if (ret) 398 return ret; 399 400 data->initial_voltage = initial_uv; 401 dev_dbg(dev, "Tune-scaled initial voltage %u\n", 402 data->initial_voltage); 403 } 404 405 return 0; 406 } 407 408 static int get_ldo_initial_voltage(struct regmap *regmap, 409 struct device *dev, 410 struct bd96801_regulator_data *data) 411 { 412 int ret; 413 int cfgreg; 414 415 ret = regmap_read(regmap, data->ldo_vol_lvl, &cfgreg); 416 if (ret) 417 return ret; 418 419 switch (cfgreg & BD96801_LDO_MODE_MASK) { 420 case BD96801_LDO_MODE_DDR: 421 data->desc.volt_table = ldo_ddr_volt_table; 422 data->desc.n_voltages = ARRAY_SIZE(ldo_ddr_volt_table); 423 break; 424 case BD96801_LDO_MODE_SD: 425 data->desc.volt_table = ldo_sd_volt_table; 426 data->desc.n_voltages = ARRAY_SIZE(ldo_sd_volt_table); 427 break; 428 default: 429 dev_info(dev, "Leaving LDO to normal mode"); 430 return 0; 431 } 432 433 /* SD or DDR mode => override default ops */ 434 data->desc.ops = &bd96801_ldo_table_ops, 435 data->desc.vsel_mask = 1; 436 data->desc.vsel_reg = data->ldo_vol_lvl; 437 438 return 0; 439 } 440 441 static int get_initial_voltage(struct device *dev, struct regmap *regmap, 442 struct bd96801_regulator_data *data) 443 { 444 /* BUCK */ 445 if (data->desc.id <= BD96801_BUCK4) 446 return buck_get_initial_voltage(regmap, dev, data); 447 448 /* LDO */ 449 return get_ldo_initial_voltage(regmap, dev, data); 450 } 451 452 static int bd96801_walk_regulator_dt(struct device *dev, struct regmap *regmap, 453 struct bd96801_regulator_data *data, 454 int num) 455 { 456 int i, ret; 457 458 struct device_node *nproot __free(device_node) = 459 of_get_child_by_name(dev->parent->of_node, "regulators"); 460 if (!nproot) { 461 dev_err(dev, "failed to find regulators node\n"); 462 return -ENODEV; 463 } 464 for_each_child_of_node_scoped(nproot, np) { 465 for (i = 0; i < num; i++) { 466 if (!of_node_name_eq(np, data[i].desc.of_match)) 467 continue; 468 /* 469 * If STBY configs are supported, we must pass node 470 * here to extract the initial voltages from the DT. 471 * Thus we do the initial voltage getting in this 472 * loop. 473 */ 474 ret = get_initial_voltage(dev, regmap, &data[i]); 475 if (ret) { 476 dev_err(dev, 477 "Initializing voltages for %s failed\n", 478 data[i].desc.name); 479 return ret; 480 } 481 482 if (of_property_read_bool(np, "rohm,keep-on-stby")) { 483 ret = regmap_set_bits(regmap, 484 BD96801_ALWAYS_ON_REG, 485 1 << data[i].desc.id); 486 if (ret) { 487 dev_err(dev, 488 "failed to set %s on-at-stby\n", 489 data[i].desc.name); 490 return ret; 491 } 492 } 493 } 494 } 495 496 return 0; 497 } 498 499 /* 500 * Template for regulator data. Probe will allocate dynamic / driver instance 501 * struct so we should be on a safe side even if there were multiple PMICs to 502 * control. Note that there is a plan to allow multiple PMICs to be used so 503 * systems can scale better. I am however still slightly unsure how the 504 * multi-PMIC case will be handled. I don't know if the processor will have I2C 505 * acces to all of the PMICs or only the first one. I'd guess there will be 506 * access provided to all PMICs for voltage scaling - but the errors will only 507 * be informed via the master PMIC. Eg, we should prepare to support multiple 508 * driver instances - either with or without the IRQs... Well, let's first 509 * just support the simple and clear single-PMIC setup and ponder the multi PMIC 510 * case later. What we can easly do for preparing is to not use static global 511 * data for regulators though. 512 */ 513 static const struct bd96801_pmic_data bd96801_data = { 514 .regulator_data = { 515 { 516 .desc = { 517 .name = "buck1", 518 .of_match = of_match_ptr("buck1"), 519 .regulators_node = of_match_ptr("regulators"), 520 .id = BD96801_BUCK1, 521 .ops = &bd96801_buck_ops, 522 .type = REGULATOR_VOLTAGE, 523 .linear_ranges = bd96801_tune_volts, 524 .n_linear_ranges = ARRAY_SIZE(bd96801_tune_volts), 525 .n_voltages = BD96801_BUCK_VOLTS, 526 .enable_reg = BD96801_REG_ENABLE, 527 .enable_mask = BD96801_BUCK1_EN_MASK, 528 .enable_is_inverted = true, 529 .vsel_reg = BD96801_BUCK1_VSEL_REG, 530 .vsel_mask = BD96801_BUCK_VSEL_MASK, 531 .ramp_reg = BD96801_BUCK1_VSEL_REG, 532 .ramp_mask = BD96801_MASK_RAMP_DELAY, 533 .ramp_delay_table = &buck_ramp_table[0], 534 .n_ramp_values = ARRAY_SIZE(buck_ramp_table), 535 .owner = THIS_MODULE, 536 }, 537 .init_ranges = bd96801_buck_init_volts, 538 .num_ranges = ARRAY_SIZE(bd96801_buck_init_volts), 539 .irq_desc = { 540 .irqinfo = (struct bd96801_irqinfo *)&buck1_irqinfo[0], 541 .num_irqs = ARRAY_SIZE(buck1_irqinfo), 542 }, 543 }, { 544 .desc = { 545 .name = "buck2", 546 .of_match = of_match_ptr("buck2"), 547 .regulators_node = of_match_ptr("regulators"), 548 .id = BD96801_BUCK2, 549 .ops = &bd96801_buck_ops, 550 .type = REGULATOR_VOLTAGE, 551 .linear_ranges = bd96801_tune_volts, 552 .n_linear_ranges = ARRAY_SIZE(bd96801_tune_volts), 553 .n_voltages = BD96801_BUCK_VOLTS, 554 .enable_reg = BD96801_REG_ENABLE, 555 .enable_mask = BD96801_BUCK2_EN_MASK, 556 .enable_is_inverted = true, 557 .vsel_reg = BD96801_BUCK2_VSEL_REG, 558 .vsel_mask = BD96801_BUCK_VSEL_MASK, 559 .ramp_reg = BD96801_BUCK2_VSEL_REG, 560 .ramp_mask = BD96801_MASK_RAMP_DELAY, 561 .ramp_delay_table = &buck_ramp_table[0], 562 .n_ramp_values = ARRAY_SIZE(buck_ramp_table), 563 .owner = THIS_MODULE, 564 }, 565 .irq_desc = { 566 .irqinfo = (struct bd96801_irqinfo *)&buck2_irqinfo[0], 567 .num_irqs = ARRAY_SIZE(buck2_irqinfo), 568 }, 569 .init_ranges = bd96801_buck_init_volts, 570 .num_ranges = ARRAY_SIZE(bd96801_buck_init_volts), 571 }, { 572 .desc = { 573 .name = "buck3", 574 .of_match = of_match_ptr("buck3"), 575 .regulators_node = of_match_ptr("regulators"), 576 .id = BD96801_BUCK3, 577 .ops = &bd96801_buck_ops, 578 .type = REGULATOR_VOLTAGE, 579 .linear_ranges = bd96801_tune_volts, 580 .n_linear_ranges = ARRAY_SIZE(bd96801_tune_volts), 581 .n_voltages = BD96801_BUCK_VOLTS, 582 .enable_reg = BD96801_REG_ENABLE, 583 .enable_mask = BD96801_BUCK3_EN_MASK, 584 .enable_is_inverted = true, 585 .vsel_reg = BD96801_BUCK3_VSEL_REG, 586 .vsel_mask = BD96801_BUCK_VSEL_MASK, 587 .ramp_reg = BD96801_BUCK3_VSEL_REG, 588 .ramp_mask = BD96801_MASK_RAMP_DELAY, 589 .ramp_delay_table = &buck_ramp_table[0], 590 .n_ramp_values = ARRAY_SIZE(buck_ramp_table), 591 .owner = THIS_MODULE, 592 }, 593 .irq_desc = { 594 .irqinfo = (struct bd96801_irqinfo *)&buck3_irqinfo[0], 595 .num_irqs = ARRAY_SIZE(buck3_irqinfo), 596 }, 597 .init_ranges = bd96801_buck_init_volts, 598 .num_ranges = ARRAY_SIZE(bd96801_buck_init_volts), 599 }, { 600 .desc = { 601 .name = "buck4", 602 .of_match = of_match_ptr("buck4"), 603 .regulators_node = of_match_ptr("regulators"), 604 .id = BD96801_BUCK4, 605 .ops = &bd96801_buck_ops, 606 .type = REGULATOR_VOLTAGE, 607 .linear_ranges = bd96801_tune_volts, 608 .n_linear_ranges = ARRAY_SIZE(bd96801_tune_volts), 609 .n_voltages = BD96801_BUCK_VOLTS, 610 .enable_reg = BD96801_REG_ENABLE, 611 .enable_mask = BD96801_BUCK4_EN_MASK, 612 .enable_is_inverted = true, 613 .vsel_reg = BD96801_BUCK4_VSEL_REG, 614 .vsel_mask = BD96801_BUCK_VSEL_MASK, 615 .ramp_reg = BD96801_BUCK4_VSEL_REG, 616 .ramp_mask = BD96801_MASK_RAMP_DELAY, 617 .ramp_delay_table = &buck_ramp_table[0], 618 .n_ramp_values = ARRAY_SIZE(buck_ramp_table), 619 .owner = THIS_MODULE, 620 }, 621 .irq_desc = { 622 .irqinfo = (struct bd96801_irqinfo *)&buck4_irqinfo[0], 623 .num_irqs = ARRAY_SIZE(buck4_irqinfo), 624 }, 625 .init_ranges = bd96801_buck_init_volts, 626 .num_ranges = ARRAY_SIZE(bd96801_buck_init_volts), 627 }, { 628 .desc = { 629 .name = "ldo5", 630 .of_match = of_match_ptr("ldo5"), 631 .regulators_node = of_match_ptr("regulators"), 632 .id = BD96801_LDO5, 633 .ops = &bd96801_ldo_ops, 634 .type = REGULATOR_VOLTAGE, 635 .linear_ranges = bd96801_ldo_int_volts, 636 .n_linear_ranges = ARRAY_SIZE(bd96801_ldo_int_volts), 637 .n_voltages = BD96801_LDO_VOLTS, 638 .enable_reg = BD96801_REG_ENABLE, 639 .enable_mask = BD96801_LDO5_EN_MASK, 640 .enable_is_inverted = true, 641 .vsel_reg = BD96801_LDO5_VSEL_REG, 642 .vsel_mask = BD96801_LDO_VSEL_MASK, 643 .owner = THIS_MODULE, 644 }, 645 .irq_desc = { 646 .irqinfo = (struct bd96801_irqinfo *)&ldo5_irqinfo[0], 647 .num_irqs = ARRAY_SIZE(ldo5_irqinfo), 648 }, 649 .ldo_vol_lvl = BD96801_LDO5_VOL_LVL_REG, 650 }, { 651 .desc = { 652 .name = "ldo6", 653 .of_match = of_match_ptr("ldo6"), 654 .regulators_node = of_match_ptr("regulators"), 655 .id = BD96801_LDO6, 656 .ops = &bd96801_ldo_ops, 657 .type = REGULATOR_VOLTAGE, 658 .linear_ranges = bd96801_ldo_int_volts, 659 .n_linear_ranges = ARRAY_SIZE(bd96801_ldo_int_volts), 660 .n_voltages = BD96801_LDO_VOLTS, 661 .enable_reg = BD96801_REG_ENABLE, 662 .enable_mask = BD96801_LDO6_EN_MASK, 663 .enable_is_inverted = true, 664 .vsel_reg = BD96801_LDO6_VSEL_REG, 665 .vsel_mask = BD96801_LDO_VSEL_MASK, 666 .owner = THIS_MODULE, 667 }, 668 .irq_desc = { 669 .irqinfo = (struct bd96801_irqinfo *)&ldo6_irqinfo[0], 670 .num_irqs = ARRAY_SIZE(ldo6_irqinfo), 671 }, 672 .ldo_vol_lvl = BD96801_LDO6_VOL_LVL_REG, 673 }, { 674 .desc = { 675 .name = "ldo7", 676 .of_match = of_match_ptr("ldo7"), 677 .regulators_node = of_match_ptr("regulators"), 678 .id = BD96801_LDO7, 679 .ops = &bd96801_ldo_ops, 680 .type = REGULATOR_VOLTAGE, 681 .linear_ranges = bd96801_ldo_int_volts, 682 .n_linear_ranges = ARRAY_SIZE(bd96801_ldo_int_volts), 683 .n_voltages = BD96801_LDO_VOLTS, 684 .enable_reg = BD96801_REG_ENABLE, 685 .enable_mask = BD96801_LDO7_EN_MASK, 686 .enable_is_inverted = true, 687 .vsel_reg = BD96801_LDO7_VSEL_REG, 688 .vsel_mask = BD96801_LDO_VSEL_MASK, 689 .owner = THIS_MODULE, 690 }, 691 .irq_desc = { 692 .irqinfo = (struct bd96801_irqinfo *)&ldo7_irqinfo[0], 693 .num_irqs = ARRAY_SIZE(ldo7_irqinfo), 694 }, 695 .ldo_vol_lvl = BD96801_LDO7_VOL_LVL_REG, 696 }, 697 }, 698 }; 699 700 static int initialize_pmic_data(struct device *dev, 701 struct bd96801_pmic_data *pdata) 702 { 703 int r, i; 704 705 /* 706 * Allocate and initialize IRQ data for all of the regulators. We 707 * wish to modify IRQ information independently for each driver 708 * instance. 709 */ 710 for (r = 0; r < BD96801_NUM_REGULATORS; r++) { 711 const struct bd96801_irqinfo *template; 712 struct bd96801_irqinfo *new; 713 int num_infos; 714 715 template = pdata->regulator_data[r].irq_desc.irqinfo; 716 num_infos = pdata->regulator_data[r].irq_desc.num_irqs; 717 718 new = devm_kcalloc(dev, num_infos, sizeof(*new), GFP_KERNEL); 719 if (!new) 720 return -ENOMEM; 721 722 pdata->regulator_data[r].irq_desc.irqinfo = new; 723 724 for (i = 0; i < num_infos; i++) 725 new[i] = template[i]; 726 } 727 728 return 0; 729 } 730 731 static int bd96801_rdev_intb_irqs(struct platform_device *pdev, 732 struct bd96801_pmic_data *pdata, 733 struct bd96801_irqinfo *iinfo, 734 struct regulator_dev *rdev) 735 { 736 struct regulator_dev *rdev_arr[1]; 737 void *retp; 738 int err = 0; 739 int irq; 740 int err_flags[] = { 741 [BD96801_PROT_OVP] = REGULATOR_ERROR_REGULATION_OUT, 742 [BD96801_PROT_UVP] = REGULATOR_ERROR_UNDER_VOLTAGE, 743 [BD96801_PROT_OCP] = REGULATOR_ERROR_OVER_CURRENT, 744 [BD96801_PROT_TEMP] = REGULATOR_ERROR_OVER_TEMP, 745 746 }; 747 int wrn_flags[] = { 748 [BD96801_PROT_OVP] = REGULATOR_ERROR_OVER_VOLTAGE_WARN, 749 [BD96801_PROT_UVP] = REGULATOR_ERROR_UNDER_VOLTAGE_WARN, 750 [BD96801_PROT_OCP] = REGULATOR_ERROR_OVER_CURRENT_WARN, 751 [BD96801_PROT_TEMP] = REGULATOR_ERROR_OVER_TEMP_WARN, 752 }; 753 754 /* 755 * Don't install IRQ handler if both error and warning 756 * notifications are explicitly disabled 757 */ 758 if (!iinfo->err_cfg && !iinfo->wrn_cfg) 759 return 0; 760 761 if (WARN_ON(iinfo->type >= BD96801_NUM_PROT)) 762 return -EINVAL; 763 764 if (iinfo->err_cfg) 765 err = err_flags[iinfo->type]; 766 else if (iinfo->wrn_cfg) 767 err = wrn_flags[iinfo->type]; 768 769 iinfo->irq_desc.data = pdata; 770 irq = platform_get_irq_byname(pdev, iinfo->irq_name); 771 if (irq < 0) 772 return irq; 773 /* Find notifications for this IRQ (WARN/ERR) */ 774 775 rdev_arr[0] = rdev; 776 retp = devm_regulator_irq_helper(&pdev->dev, 777 &iinfo->irq_desc, irq, 778 0, err, NULL, rdev_arr, 779 1); 780 if (IS_ERR(retp)) 781 return PTR_ERR(retp); 782 783 return 0; 784 } 785 786 787 788 static int bd96801_probe(struct platform_device *pdev) 789 { 790 struct regulator_dev *ldo_errs_rdev_arr[BD96801_NUM_LDOS]; 791 struct bd96801_regulator_data *rdesc; 792 struct regulator_config config = {}; 793 int ldo_errs_arr[BD96801_NUM_LDOS]; 794 struct bd96801_pmic_data *pdata; 795 int temp_notif_ldos = 0; 796 struct device *parent; 797 int i, ret; 798 void *retp; 799 800 parent = pdev->dev.parent; 801 802 pdata = devm_kmemdup(&pdev->dev, &bd96801_data, sizeof(bd96801_data), 803 GFP_KERNEL); 804 if (!pdata) 805 return -ENOMEM; 806 807 if (initialize_pmic_data(&pdev->dev, pdata)) 808 return -ENOMEM; 809 810 pdata->regmap = dev_get_regmap(parent, NULL); 811 if (!pdata->regmap) { 812 dev_err(&pdev->dev, "No register map found\n"); 813 return -ENODEV; 814 } 815 816 rdesc = &pdata->regulator_data[0]; 817 818 config.driver_data = pdata; 819 config.regmap = pdata->regmap; 820 config.dev = parent; 821 822 ret = bd96801_walk_regulator_dt(&pdev->dev, pdata->regmap, rdesc, 823 BD96801_NUM_REGULATORS); 824 if (ret) 825 return ret; 826 827 for (i = 0; i < ARRAY_SIZE(pdata->regulator_data); i++) { 828 struct regulator_dev *rdev; 829 struct bd96801_irq_desc *idesc = &rdesc[i].irq_desc; 830 int j; 831 832 rdev = devm_regulator_register(&pdev->dev, 833 &rdesc[i].desc, &config); 834 if (IS_ERR(rdev)) { 835 dev_err(&pdev->dev, 836 "failed to register %s regulator\n", 837 rdesc[i].desc.name); 838 return PTR_ERR(rdev); 839 } 840 /* 841 * LDOs don't have own temperature monitoring. If temperature 842 * notification was requested for this LDO from DT then we will 843 * add the regulator to be notified if central IC temperature 844 * exceeds threshold. 845 */ 846 if (rdesc[i].ldo_errs) { 847 ldo_errs_rdev_arr[temp_notif_ldos] = rdev; 848 ldo_errs_arr[temp_notif_ldos] = rdesc[i].ldo_errs; 849 temp_notif_ldos++; 850 } 851 852 /* Register INTB handlers for configured protections */ 853 for (j = 0; j < idesc->num_irqs; j++) { 854 ret = bd96801_rdev_intb_irqs(pdev, pdata, 855 &idesc->irqinfo[j], rdev); 856 if (ret) 857 return ret; 858 } 859 } 860 if (temp_notif_ldos) { 861 int irq; 862 struct regulator_irq_desc tw_desc = { 863 .name = "bd96801-core-thermal", 864 .irq_off_ms = 500, 865 .map_event = ldo_map_notif, 866 }; 867 868 irq = platform_get_irq_byname(pdev, "bd96801-core-thermal"); 869 if (irq < 0) 870 return irq; 871 872 retp = devm_regulator_irq_helper(&pdev->dev, &tw_desc, irq, 0, 873 0, &ldo_errs_arr[0], 874 &ldo_errs_rdev_arr[0], 875 temp_notif_ldos); 876 if (IS_ERR(retp)) 877 return PTR_ERR(retp); 878 } 879 880 return 0; 881 } 882 883 static const struct platform_device_id bd96801_pmic_id[] = { 884 { "bd96801-regulator", }, 885 { } 886 }; 887 MODULE_DEVICE_TABLE(platform, bd96801_pmic_id); 888 889 static struct platform_driver bd96801_regulator = { 890 .driver = { 891 .name = "bd96801-pmic" 892 }, 893 .probe = bd96801_probe, 894 .id_table = bd96801_pmic_id, 895 }; 896 897 module_platform_driver(bd96801_regulator); 898 899 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>"); 900 MODULE_DESCRIPTION("BD96801 voltage regulator driver"); 901 MODULE_LICENSE("GPL"); 902