1 // SPDX-License-Identifier: GPL-2.0 2 // Copyright (C) 2020 ROHM Semiconductors 3 // ROHM BD9576MUF/BD9573MUF regulator driver 4 5 #include <linux/err.h> 6 #include <linux/gpio/consumer.h> 7 #include <linux/interrupt.h> 8 #include <linux/jiffies.h> 9 #include <linux/kernel.h> 10 #include <linux/mfd/rohm-bd957x.h> 11 #include <linux/mfd/rohm-generic.h> 12 #include <linux/module.h> 13 #include <linux/of.h> 14 #include <linux/platform_device.h> 15 #include <linux/regulator/driver.h> 16 #include <linux/regulator/machine.h> 17 #include <linux/regulator/of_regulator.h> 18 #include <linux/slab.h> 19 #include <linux/spinlock.h> 20 #include <linux/workqueue.h> 21 22 #define BD957X_VOUTS1_VOLT 3300000 23 #define BD957X_VOUTS4_BASE_VOLT 1030000 24 #define BD957X_VOUTS34_NUM_VOLT 32 25 26 #define BD9576_THERM_IRQ_MASK_TW BIT(5) 27 #define BD9576_xVD_IRQ_MASK_VOUTL1 BIT(5) 28 #define BD9576_UVD_IRQ_MASK_VOUTS1_OCW BIT(6) 29 #define BD9576_xVD_IRQ_MASK_VOUT1TO4 0x0F 30 31 static const unsigned int vout1_volt_table[] = { 32 5000000, 4900000, 4800000, 4700000, 4600000, 33 4500000, 4500000, 4500000, 5000000, 5100000, 34 5200000, 5300000, 5400000, 5500000, 5500000, 35 5500000 36 }; 37 38 static const unsigned int vout2_volt_table[] = { 39 1800000, 1780000, 1760000, 1740000, 1720000, 40 1700000, 1680000, 1660000, 1800000, 1820000, 41 1840000, 1860000, 1880000, 1900000, 1920000, 42 1940000 43 }; 44 45 static const unsigned int voutl1_volt_table[] = { 46 2500000, 2540000, 2580000, 2620000, 2660000, 47 2700000, 2740000, 2780000, 2500000, 2460000, 48 2420000, 2380000, 2340000, 2300000, 2260000, 49 2220000 50 }; 51 52 static const struct linear_range vout1_xvd_ranges[] = { 53 REGULATOR_LINEAR_RANGE(225000, 0x01, 0x2b, 0), 54 REGULATOR_LINEAR_RANGE(225000, 0x2c, 0x54, 5000), 55 REGULATOR_LINEAR_RANGE(425000, 0x55, 0x7f, 0), 56 }; 57 58 static const struct linear_range vout234_xvd_ranges[] = { 59 REGULATOR_LINEAR_RANGE(17000, 0x01, 0x0f, 0), 60 REGULATOR_LINEAR_RANGE(17000, 0x10, 0x6d, 1000), 61 REGULATOR_LINEAR_RANGE(110000, 0x6e, 0x7f, 0), 62 }; 63 64 static const struct linear_range voutL1_xvd_ranges[] = { 65 REGULATOR_LINEAR_RANGE(34000, 0x01, 0x0f, 0), 66 REGULATOR_LINEAR_RANGE(34000, 0x10, 0x6d, 2000), 67 REGULATOR_LINEAR_RANGE(220000, 0x6e, 0x7f, 0), 68 }; 69 70 static struct linear_range voutS1_ocw_ranges_internal[] = { 71 REGULATOR_LINEAR_RANGE(200000, 0x01, 0x04, 0), 72 REGULATOR_LINEAR_RANGE(250000, 0x05, 0x18, 50000), 73 REGULATOR_LINEAR_RANGE(1200000, 0x19, 0x3f, 0), 74 }; 75 76 static struct linear_range voutS1_ocw_ranges[] = { 77 REGULATOR_LINEAR_RANGE(50000, 0x01, 0x04, 0), 78 REGULATOR_LINEAR_RANGE(60000, 0x05, 0x18, 10000), 79 REGULATOR_LINEAR_RANGE(250000, 0x19, 0x3f, 0), 80 }; 81 82 static struct linear_range voutS1_ocp_ranges_internal[] = { 83 REGULATOR_LINEAR_RANGE(300000, 0x01, 0x06, 0), 84 REGULATOR_LINEAR_RANGE(350000, 0x7, 0x1b, 50000), 85 REGULATOR_LINEAR_RANGE(1350000, 0x1c, 0x3f, 0), 86 }; 87 88 static struct linear_range voutS1_ocp_ranges[] = { 89 REGULATOR_LINEAR_RANGE(70000, 0x01, 0x06, 0), 90 REGULATOR_LINEAR_RANGE(80000, 0x7, 0x1b, 10000), 91 REGULATOR_LINEAR_RANGE(280000, 0x1c, 0x3f, 0), 92 }; 93 94 struct bd957x_regulator_data { 95 struct regulator_desc desc; 96 int base_voltage; 97 struct regulator_dev *rdev; 98 int ovd_notif; 99 int uvd_notif; 100 int temp_notif; 101 int ovd_err; 102 int uvd_err; 103 int temp_err; 104 const struct linear_range *xvd_ranges; 105 int num_xvd_ranges; 106 bool oc_supported; 107 unsigned int ovd_reg; 108 unsigned int uvd_reg; 109 unsigned int xvd_mask; 110 unsigned int ocp_reg; 111 unsigned int ocp_mask; 112 unsigned int ocw_reg; 113 unsigned int ocw_mask; 114 unsigned int ocw_rfet; 115 }; 116 117 #define BD9576_NUM_REGULATORS 6 118 #define BD9576_NUM_OVD_REGULATORS 5 119 120 struct bd957x_data { 121 struct bd957x_regulator_data regulator_data[BD9576_NUM_REGULATORS]; 122 struct regmap *regmap; 123 struct delayed_work therm_irq_suppress; 124 struct delayed_work ovd_irq_suppress; 125 struct delayed_work uvd_irq_suppress; 126 unsigned int therm_irq; 127 unsigned int ovd_irq; 128 unsigned int uvd_irq; 129 spinlock_t err_lock; 130 int regulator_global_err; 131 }; 132 133 static int bd957x_vout34_list_voltage(struct regulator_dev *rdev, 134 unsigned int selector) 135 { 136 const struct regulator_desc *desc = rdev->desc; 137 int multiplier = selector & desc->vsel_mask & 0x7f; 138 int tune; 139 140 /* VOUT3 and 4 has 10mV step */ 141 tune = multiplier * 10000; 142 143 if (!(selector & 0x80)) 144 return desc->fixed_uV - tune; 145 146 return desc->fixed_uV + tune; 147 } 148 149 static int bd957x_list_voltage(struct regulator_dev *rdev, 150 unsigned int selector) 151 { 152 const struct regulator_desc *desc = rdev->desc; 153 int index = selector & desc->vsel_mask & 0x7f; 154 155 if (!(selector & 0x80)) 156 index += desc->n_voltages/2; 157 158 if (index >= desc->n_voltages) 159 return -EINVAL; 160 161 return desc->volt_table[index]; 162 } 163 164 static void bd9576_fill_ovd_flags(struct bd957x_regulator_data *data, 165 bool warn) 166 { 167 if (warn) { 168 data->ovd_notif = REGULATOR_EVENT_OVER_VOLTAGE_WARN; 169 data->ovd_err = REGULATOR_ERROR_OVER_VOLTAGE_WARN; 170 } else { 171 data->ovd_notif = REGULATOR_EVENT_REGULATION_OUT; 172 data->ovd_err = REGULATOR_ERROR_REGULATION_OUT; 173 } 174 } 175 176 static void bd9576_fill_ocp_flags(struct bd957x_regulator_data *data, 177 bool warn) 178 { 179 if (warn) { 180 data->uvd_notif = REGULATOR_EVENT_OVER_CURRENT_WARN; 181 data->uvd_err = REGULATOR_ERROR_OVER_CURRENT_WARN; 182 } else { 183 data->uvd_notif = REGULATOR_EVENT_OVER_CURRENT; 184 data->uvd_err = REGULATOR_ERROR_OVER_CURRENT; 185 } 186 } 187 188 static void bd9576_fill_uvd_flags(struct bd957x_regulator_data *data, 189 bool warn) 190 { 191 if (warn) { 192 data->uvd_notif = REGULATOR_EVENT_UNDER_VOLTAGE_WARN; 193 data->uvd_err = REGULATOR_ERROR_UNDER_VOLTAGE_WARN; 194 } else { 195 data->uvd_notif = REGULATOR_EVENT_UNDER_VOLTAGE; 196 data->uvd_err = REGULATOR_ERROR_UNDER_VOLTAGE; 197 } 198 } 199 200 static void bd9576_fill_temp_flags(struct bd957x_regulator_data *data, 201 bool enable, bool warn) 202 { 203 if (!enable) { 204 data->temp_notif = 0; 205 data->temp_err = 0; 206 } else if (warn) { 207 data->temp_notif = REGULATOR_EVENT_OVER_TEMP_WARN; 208 data->temp_err = REGULATOR_ERROR_OVER_TEMP_WARN; 209 } else { 210 data->temp_notif = REGULATOR_EVENT_OVER_TEMP; 211 data->temp_err = REGULATOR_ERROR_OVER_TEMP; 212 } 213 } 214 215 static int bd9576_set_limit(const struct linear_range *r, int num_ranges, 216 struct regmap *regmap, int reg, int mask, int lim) 217 { 218 int ret; 219 bool found; 220 int sel = 0; 221 222 if (lim) { 223 224 ret = linear_range_get_selector_low_array(r, num_ranges, 225 lim, &sel, &found); 226 if (ret) 227 return ret; 228 229 if (!found) 230 dev_warn(regmap_get_device(regmap), 231 "limit %d out of range. Setting lower\n", 232 lim); 233 } 234 235 return regmap_update_bits(regmap, reg, mask, sel); 236 } 237 238 static bool check_ocp_flag_mismatch(struct regulator_dev *rdev, int severity, 239 struct bd957x_regulator_data *r) 240 { 241 if ((severity == REGULATOR_SEVERITY_ERR && 242 r->uvd_notif != REGULATOR_EVENT_OVER_CURRENT) || 243 (severity == REGULATOR_SEVERITY_WARN && 244 r->uvd_notif != REGULATOR_EVENT_OVER_CURRENT_WARN)) { 245 dev_warn(rdev_get_dev(rdev), 246 "Can't support both OCP WARN and ERR\n"); 247 /* Do not overwrite ERR config with WARN */ 248 if (severity == REGULATOR_SEVERITY_WARN) 249 return true; 250 251 bd9576_fill_ocp_flags(r, 0); 252 } 253 254 return false; 255 } 256 257 static bool check_uvd_flag_mismatch(struct regulator_dev *rdev, int severity, 258 struct bd957x_regulator_data *r) 259 { 260 if ((severity == REGULATOR_SEVERITY_ERR && 261 r->uvd_notif != REGULATOR_EVENT_UNDER_VOLTAGE) || 262 (severity == REGULATOR_SEVERITY_WARN && 263 r->uvd_notif != REGULATOR_EVENT_UNDER_VOLTAGE_WARN)) { 264 dev_warn(rdev_get_dev(rdev), 265 "Can't support both UVD WARN and ERR\n"); 266 if (severity == REGULATOR_SEVERITY_WARN) 267 return true; 268 269 bd9576_fill_uvd_flags(r, 0); 270 } 271 272 return false; 273 } 274 275 static bool check_ovd_flag_mismatch(struct regulator_dev *rdev, int severity, 276 struct bd957x_regulator_data *r) 277 { 278 if ((severity == REGULATOR_SEVERITY_ERR && 279 r->ovd_notif != REGULATOR_EVENT_REGULATION_OUT) || 280 (severity == REGULATOR_SEVERITY_WARN && 281 r->ovd_notif != REGULATOR_EVENT_OVER_VOLTAGE_WARN)) { 282 dev_warn(rdev_get_dev(rdev), 283 "Can't support both OVD WARN and ERR\n"); 284 if (severity == REGULATOR_SEVERITY_WARN) 285 return true; 286 287 bd9576_fill_ovd_flags(r, 0); 288 } 289 290 return false; 291 } 292 293 static bool check_temp_flag_mismatch(struct regulator_dev *rdev, int severity, 294 struct bd957x_regulator_data *r) 295 { 296 if ((severity == REGULATOR_SEVERITY_ERR && 297 r->ovd_notif != REGULATOR_EVENT_OVER_TEMP) || 298 (severity == REGULATOR_SEVERITY_WARN && 299 r->ovd_notif != REGULATOR_EVENT_OVER_TEMP_WARN)) { 300 dev_warn(rdev_get_dev(rdev), 301 "Can't support both thermal WARN and ERR\n"); 302 if (severity == REGULATOR_SEVERITY_WARN) 303 return true; 304 } 305 306 return false; 307 } 308 309 static int bd9576_set_ocp(struct regulator_dev *rdev, int lim_uA, int severity, 310 bool enable) 311 { 312 struct bd957x_data *d; 313 struct bd957x_regulator_data *r; 314 int reg, mask; 315 int Vfet, rfet; 316 const struct linear_range *range; 317 int num_ranges; 318 319 if ((lim_uA && !enable) || (!lim_uA && enable)) 320 return -EINVAL; 321 322 r = container_of(rdev->desc, struct bd957x_regulator_data, desc); 323 if (!r->oc_supported) 324 return -EINVAL; 325 326 d = rdev_get_drvdata(rdev); 327 328 if (severity == REGULATOR_SEVERITY_PROT) { 329 reg = r->ocp_reg; 330 mask = r->ocp_mask; 331 if (r->ocw_rfet) { 332 range = voutS1_ocp_ranges; 333 num_ranges = ARRAY_SIZE(voutS1_ocp_ranges); 334 rfet = r->ocw_rfet / 1000; 335 } else { 336 range = voutS1_ocp_ranges_internal; 337 num_ranges = ARRAY_SIZE(voutS1_ocp_ranges_internal); 338 /* Internal values are already micro-amperes */ 339 rfet = 1000; 340 } 341 } else { 342 reg = r->ocw_reg; 343 mask = r->ocw_mask; 344 345 if (r->ocw_rfet) { 346 range = voutS1_ocw_ranges; 347 num_ranges = ARRAY_SIZE(voutS1_ocw_ranges); 348 rfet = r->ocw_rfet / 1000; 349 } else { 350 range = voutS1_ocw_ranges_internal; 351 num_ranges = ARRAY_SIZE(voutS1_ocw_ranges_internal); 352 /* Internal values are already micro-amperes */ 353 rfet = 1000; 354 } 355 356 /* We abuse uvd fields for OCW on VoutS1 */ 357 if (r->uvd_notif) { 358 /* 359 * If both warning and error are requested, prioritize 360 * ERROR configuration 361 */ 362 if (check_ocp_flag_mismatch(rdev, severity, r)) 363 return 0; 364 } else { 365 bool warn = severity == REGULATOR_SEVERITY_WARN; 366 367 bd9576_fill_ocp_flags(r, warn); 368 } 369 } 370 371 /* 372 * limits are given in uA, rfet is mOhm 373 * Divide lim_uA by 1000 to get Vfet in uV. 374 * (We expect both Rfet and limit uA to be magnitude of hundreds of 375 * milli Amperes & milli Ohms => we should still have decent accuracy) 376 */ 377 Vfet = lim_uA/1000 * rfet; 378 379 return bd9576_set_limit(range, num_ranges, d->regmap, 380 reg, mask, Vfet); 381 } 382 383 static int bd9576_set_uvp(struct regulator_dev *rdev, int lim_uV, int severity, 384 bool enable) 385 { 386 struct bd957x_data *d; 387 struct bd957x_regulator_data *r; 388 int mask, reg; 389 390 if (severity == REGULATOR_SEVERITY_PROT) { 391 if (!enable || lim_uV) 392 return -EINVAL; 393 return 0; 394 } 395 396 /* 397 * BD9576 has enable control as a special value in limit reg. Can't 398 * set limit but keep feature disabled or enable W/O given limit. 399 */ 400 if ((lim_uV && !enable) || (!lim_uV && enable)) 401 return -EINVAL; 402 403 r = container_of(rdev->desc, struct bd957x_regulator_data, desc); 404 d = rdev_get_drvdata(rdev); 405 406 mask = r->xvd_mask; 407 reg = r->uvd_reg; 408 /* 409 * Check that there is no mismatch for what the detection IRQs are to 410 * be used. 411 */ 412 if (r->uvd_notif) { 413 if (check_uvd_flag_mismatch(rdev, severity, r)) 414 return 0; 415 } else { 416 bd9576_fill_uvd_flags(r, severity == REGULATOR_SEVERITY_WARN); 417 } 418 419 return bd9576_set_limit(r->xvd_ranges, r->num_xvd_ranges, d->regmap, 420 reg, mask, lim_uV); 421 } 422 423 static int bd9576_set_ovp(struct regulator_dev *rdev, int lim_uV, int severity, 424 bool enable) 425 { 426 struct bd957x_data *d; 427 struct bd957x_regulator_data *r; 428 int mask, reg; 429 430 if (severity == REGULATOR_SEVERITY_PROT) { 431 if (!enable || lim_uV) 432 return -EINVAL; 433 return 0; 434 } 435 436 /* 437 * BD9576 has enable control as a special value in limit reg. Can't 438 * set limit but keep feature disabled or enable W/O given limit. 439 */ 440 if ((lim_uV && !enable) || (!lim_uV && enable)) 441 return -EINVAL; 442 443 r = container_of(rdev->desc, struct bd957x_regulator_data, desc); 444 d = rdev_get_drvdata(rdev); 445 446 mask = r->xvd_mask; 447 reg = r->ovd_reg; 448 /* 449 * Check that there is no mismatch for what the detection IRQs are to 450 * be used. 451 */ 452 if (r->ovd_notif) { 453 if (check_ovd_flag_mismatch(rdev, severity, r)) 454 return 0; 455 } else { 456 bd9576_fill_ovd_flags(r, severity == REGULATOR_SEVERITY_WARN); 457 } 458 459 return bd9576_set_limit(r->xvd_ranges, r->num_xvd_ranges, d->regmap, 460 reg, mask, lim_uV); 461 } 462 463 464 static int bd9576_set_tw(struct regulator_dev *rdev, int lim, int severity, 465 bool enable) 466 { 467 struct bd957x_data *d; 468 struct bd957x_regulator_data *r; 469 int i; 470 471 /* 472 * BD9576MUF has fixed temperature limits 473 * The detection can only be enabled/disabled 474 */ 475 if (lim) 476 return -EINVAL; 477 478 /* Protection can't be disabled */ 479 if (severity == REGULATOR_SEVERITY_PROT) { 480 if (!enable) 481 return -EINVAL; 482 else 483 return 0; 484 } 485 486 r = container_of(rdev->desc, struct bd957x_regulator_data, desc); 487 d = rdev_get_drvdata(rdev); 488 489 /* 490 * Check that there is no mismatch for what the detection IRQs are to 491 * be used. 492 */ 493 if (r->temp_notif) 494 if (check_temp_flag_mismatch(rdev, severity, r)) 495 return 0; 496 497 bd9576_fill_temp_flags(r, enable, severity == REGULATOR_SEVERITY_WARN); 498 499 if (enable) 500 return regmap_update_bits(d->regmap, BD957X_REG_INT_THERM_MASK, 501 BD9576_THERM_IRQ_MASK_TW, 0); 502 503 /* 504 * If any of the regulators is interested in thermal warning we keep IRQ 505 * enabled. 506 */ 507 for (i = 0; i < BD9576_NUM_REGULATORS; i++) 508 if (d->regulator_data[i].temp_notif) 509 return 0; 510 511 return regmap_update_bits(d->regmap, BD957X_REG_INT_THERM_MASK, 512 BD9576_THERM_IRQ_MASK_TW, 513 BD9576_THERM_IRQ_MASK_TW); 514 } 515 516 static const struct regulator_ops bd9573_vout34_ops = { 517 .is_enabled = regulator_is_enabled_regmap, 518 .list_voltage = bd957x_vout34_list_voltage, 519 .get_voltage_sel = regulator_get_voltage_sel_regmap, 520 }; 521 522 static const struct regulator_ops bd9576_vout34_ops = { 523 .is_enabled = regulator_is_enabled_regmap, 524 .list_voltage = bd957x_vout34_list_voltage, 525 .get_voltage_sel = regulator_get_voltage_sel_regmap, 526 .set_over_voltage_protection = bd9576_set_ovp, 527 .set_under_voltage_protection = bd9576_set_uvp, 528 .set_thermal_protection = bd9576_set_tw, 529 }; 530 531 static const struct regulator_ops bd9573_vouts1_regulator_ops = { 532 .is_enabled = regulator_is_enabled_regmap, 533 }; 534 535 static const struct regulator_ops bd9576_vouts1_regulator_ops = { 536 .is_enabled = regulator_is_enabled_regmap, 537 .set_over_current_protection = bd9576_set_ocp, 538 }; 539 540 static const struct regulator_ops bd9573_ops = { 541 .is_enabled = regulator_is_enabled_regmap, 542 .list_voltage = bd957x_list_voltage, 543 .get_voltage_sel = regulator_get_voltage_sel_regmap, 544 }; 545 546 static const struct regulator_ops bd9576_ops = { 547 .is_enabled = regulator_is_enabled_regmap, 548 .list_voltage = bd957x_list_voltage, 549 .get_voltage_sel = regulator_get_voltage_sel_regmap, 550 .set_over_voltage_protection = bd9576_set_ovp, 551 .set_under_voltage_protection = bd9576_set_uvp, 552 .set_thermal_protection = bd9576_set_tw, 553 }; 554 555 static const struct regulator_ops *bd9573_ops_arr[] = { 556 [BD957X_VD50] = &bd9573_ops, 557 [BD957X_VD18] = &bd9573_ops, 558 [BD957X_VDDDR] = &bd9573_vout34_ops, 559 [BD957X_VD10] = &bd9573_vout34_ops, 560 [BD957X_VOUTL1] = &bd9573_ops, 561 [BD957X_VOUTS1] = &bd9573_vouts1_regulator_ops, 562 }; 563 564 static const struct regulator_ops *bd9576_ops_arr[] = { 565 [BD957X_VD50] = &bd9576_ops, 566 [BD957X_VD18] = &bd9576_ops, 567 [BD957X_VDDDR] = &bd9576_vout34_ops, 568 [BD957X_VD10] = &bd9576_vout34_ops, 569 [BD957X_VOUTL1] = &bd9576_ops, 570 [BD957X_VOUTS1] = &bd9576_vouts1_regulator_ops, 571 }; 572 573 static int vouts1_get_fet_res(struct device_node *np, 574 const struct regulator_desc *desc, 575 struct regulator_config *cfg) 576 { 577 struct bd957x_regulator_data *data; 578 int ret; 579 u32 uohms; 580 581 data = container_of(desc, struct bd957x_regulator_data, desc); 582 583 ret = of_property_read_u32(np, "rohm,ocw-fet-ron-micro-ohms", &uohms); 584 if (ret) { 585 if (ret != -EINVAL) 586 return ret; 587 588 return 0; 589 } 590 data->ocw_rfet = uohms; 591 return 0; 592 } 593 594 static struct bd957x_data bd957x_regulators = { 595 .regulator_data = { 596 { 597 .desc = { 598 .name = "VD50", 599 .of_match = of_match_ptr("regulator-vd50"), 600 .regulators_node = of_match_ptr("regulators"), 601 .id = BD957X_VD50, 602 .type = REGULATOR_VOLTAGE, 603 .volt_table = &vout1_volt_table[0], 604 .n_voltages = ARRAY_SIZE(vout1_volt_table), 605 .vsel_reg = BD957X_REG_VOUT1_TUNE, 606 .vsel_mask = BD957X_MASK_VOUT1_TUNE, 607 .enable_reg = BD957X_REG_POW_TRIGGER1, 608 .enable_mask = BD957X_REGULATOR_EN_MASK, 609 .enable_val = BD957X_REGULATOR_DIS_VAL, 610 .enable_is_inverted = true, 611 .owner = THIS_MODULE, 612 }, 613 .xvd_ranges = vout1_xvd_ranges, 614 .num_xvd_ranges = ARRAY_SIZE(vout1_xvd_ranges), 615 .ovd_reg = BD9576_REG_VOUT1_OVD, 616 .uvd_reg = BD9576_REG_VOUT1_UVD, 617 .xvd_mask = BD9576_MASK_XVD, 618 }, 619 { 620 .desc = { 621 .name = "VD18", 622 .of_match = of_match_ptr("regulator-vd18"), 623 .regulators_node = of_match_ptr("regulators"), 624 .id = BD957X_VD18, 625 .type = REGULATOR_VOLTAGE, 626 .volt_table = &vout2_volt_table[0], 627 .n_voltages = ARRAY_SIZE(vout2_volt_table), 628 .vsel_reg = BD957X_REG_VOUT2_TUNE, 629 .vsel_mask = BD957X_MASK_VOUT2_TUNE, 630 .enable_reg = BD957X_REG_POW_TRIGGER2, 631 .enable_mask = BD957X_REGULATOR_EN_MASK, 632 .enable_val = BD957X_REGULATOR_DIS_VAL, 633 .enable_is_inverted = true, 634 .owner = THIS_MODULE, 635 }, 636 .xvd_ranges = vout234_xvd_ranges, 637 .num_xvd_ranges = ARRAY_SIZE(vout234_xvd_ranges), 638 .ovd_reg = BD9576_REG_VOUT2_OVD, 639 .uvd_reg = BD9576_REG_VOUT2_UVD, 640 .xvd_mask = BD9576_MASK_XVD, 641 }, 642 { 643 .desc = { 644 .name = "VDDDR", 645 .of_match = of_match_ptr("regulator-vdddr"), 646 .regulators_node = of_match_ptr("regulators"), 647 .id = BD957X_VDDDR, 648 .type = REGULATOR_VOLTAGE, 649 .n_voltages = BD957X_VOUTS34_NUM_VOLT, 650 .vsel_reg = BD957X_REG_VOUT3_TUNE, 651 .vsel_mask = BD957X_MASK_VOUT3_TUNE, 652 .enable_reg = BD957X_REG_POW_TRIGGER3, 653 .enable_mask = BD957X_REGULATOR_EN_MASK, 654 .enable_val = BD957X_REGULATOR_DIS_VAL, 655 .enable_is_inverted = true, 656 .owner = THIS_MODULE, 657 }, 658 .ovd_reg = BD9576_REG_VOUT3_OVD, 659 .uvd_reg = BD9576_REG_VOUT3_UVD, 660 .xvd_mask = BD9576_MASK_XVD, 661 .xvd_ranges = vout234_xvd_ranges, 662 .num_xvd_ranges = ARRAY_SIZE(vout234_xvd_ranges), 663 }, 664 { 665 .desc = { 666 .name = "VD10", 667 .of_match = of_match_ptr("regulator-vd10"), 668 .regulators_node = of_match_ptr("regulators"), 669 .id = BD957X_VD10, 670 .type = REGULATOR_VOLTAGE, 671 .fixed_uV = BD957X_VOUTS4_BASE_VOLT, 672 .n_voltages = BD957X_VOUTS34_NUM_VOLT, 673 .vsel_reg = BD957X_REG_VOUT4_TUNE, 674 .vsel_mask = BD957X_MASK_VOUT4_TUNE, 675 .enable_reg = BD957X_REG_POW_TRIGGER4, 676 .enable_mask = BD957X_REGULATOR_EN_MASK, 677 .enable_val = BD957X_REGULATOR_DIS_VAL, 678 .enable_is_inverted = true, 679 .owner = THIS_MODULE, 680 }, 681 .xvd_ranges = vout234_xvd_ranges, 682 .num_xvd_ranges = ARRAY_SIZE(vout234_xvd_ranges), 683 .ovd_reg = BD9576_REG_VOUT4_OVD, 684 .uvd_reg = BD9576_REG_VOUT4_UVD, 685 .xvd_mask = BD9576_MASK_XVD, 686 }, 687 { 688 .desc = { 689 .name = "VOUTL1", 690 .of_match = of_match_ptr("regulator-voutl1"), 691 .regulators_node = of_match_ptr("regulators"), 692 .id = BD957X_VOUTL1, 693 .type = REGULATOR_VOLTAGE, 694 .volt_table = &voutl1_volt_table[0], 695 .n_voltages = ARRAY_SIZE(voutl1_volt_table), 696 .vsel_reg = BD957X_REG_VOUTL1_TUNE, 697 .vsel_mask = BD957X_MASK_VOUTL1_TUNE, 698 .enable_reg = BD957X_REG_POW_TRIGGERL1, 699 .enable_mask = BD957X_REGULATOR_EN_MASK, 700 .enable_val = BD957X_REGULATOR_DIS_VAL, 701 .enable_is_inverted = true, 702 .owner = THIS_MODULE, 703 }, 704 .xvd_ranges = voutL1_xvd_ranges, 705 .num_xvd_ranges = ARRAY_SIZE(voutL1_xvd_ranges), 706 .ovd_reg = BD9576_REG_VOUTL1_OVD, 707 .uvd_reg = BD9576_REG_VOUTL1_UVD, 708 .xvd_mask = BD9576_MASK_XVD, 709 }, 710 { 711 .desc = { 712 .name = "VOUTS1", 713 .of_match = of_match_ptr("regulator-vouts1"), 714 .regulators_node = of_match_ptr("regulators"), 715 .id = BD957X_VOUTS1, 716 .type = REGULATOR_VOLTAGE, 717 .n_voltages = 1, 718 .fixed_uV = BD957X_VOUTS1_VOLT, 719 .enable_reg = BD957X_REG_POW_TRIGGERS1, 720 .enable_mask = BD957X_REGULATOR_EN_MASK, 721 .enable_val = BD957X_REGULATOR_DIS_VAL, 722 .enable_is_inverted = true, 723 .owner = THIS_MODULE, 724 .of_parse_cb = vouts1_get_fet_res, 725 }, 726 .oc_supported = true, 727 .ocw_reg = BD9576_REG_VOUT1S_OCW, 728 .ocw_mask = BD9576_MASK_VOUT1S_OCW, 729 .ocp_reg = BD9576_REG_VOUT1S_OCP, 730 .ocp_mask = BD9576_MASK_VOUT1S_OCP, 731 }, 732 }, 733 }; 734 735 static int bd9576_renable(struct regulator_irq_data *rid, int reg, int mask) 736 { 737 int val, ret; 738 struct bd957x_data *d = (struct bd957x_data *)rid->data; 739 740 ret = regmap_read(d->regmap, reg, &val); 741 if (ret) 742 return REGULATOR_FAILED_RETRY; 743 744 if (rid->opaque && rid->opaque == (val & mask)) { 745 /* 746 * It seems we stil have same status. Ack and return 747 * information that we are still out of limits and core 748 * should not enable IRQ 749 */ 750 regmap_write(d->regmap, reg, mask & val); 751 return REGULATOR_ERROR_ON; 752 } 753 rid->opaque = 0; 754 /* 755 * Status was changed. Either prolem was solved or we have new issues. 756 * Let's re-enable IRQs and be prepared to report problems again 757 */ 758 return REGULATOR_ERROR_CLEARED; 759 } 760 761 static int bd9576_uvd_renable(struct regulator_irq_data *rid) 762 { 763 return bd9576_renable(rid, BD957X_REG_INT_UVD_STAT, UVD_IRQ_VALID_MASK); 764 } 765 766 static int bd9576_ovd_renable(struct regulator_irq_data *rid) 767 { 768 return bd9576_renable(rid, BD957X_REG_INT_OVD_STAT, OVD_IRQ_VALID_MASK); 769 } 770 771 static int bd9576_temp_renable(struct regulator_irq_data *rid) 772 { 773 return bd9576_renable(rid, BD957X_REG_INT_THERM_STAT, 774 BD9576_THERM_IRQ_MASK_TW); 775 } 776 777 static int bd9576_uvd_handler(int irq, struct regulator_irq_data *rid, 778 unsigned long *dev_mask) 779 { 780 int val, ret, i; 781 struct bd957x_data *d = (struct bd957x_data *)rid->data; 782 783 ret = regmap_read(d->regmap, BD957X_REG_INT_UVD_STAT, &val); 784 if (ret) 785 return REGULATOR_FAILED_RETRY; 786 787 *dev_mask = 0; 788 789 rid->opaque = val & UVD_IRQ_VALID_MASK; 790 791 /* 792 * Go through the set status bits and report either error or warning 793 * to the notifier depending on what was flagged in DT 794 */ 795 *dev_mask = val & BD9576_xVD_IRQ_MASK_VOUT1TO4; 796 /* There is 1 bit gap in register after Vout1 .. Vout4 statuses */ 797 *dev_mask |= ((val & BD9576_xVD_IRQ_MASK_VOUTL1) >> 1); 798 /* 799 * We (ab)use the uvd for OCW notification. DT parsing should 800 * have added correct OCW flag to uvd_notif and uvd_err for S1 801 */ 802 *dev_mask |= ((val & BD9576_UVD_IRQ_MASK_VOUTS1_OCW) >> 1); 803 804 for_each_set_bit(i, dev_mask, 6) { 805 struct bd957x_regulator_data *rdata; 806 struct regulator_err_state *stat; 807 808 rdata = &d->regulator_data[i]; 809 stat = &rid->states[i]; 810 811 stat->notifs = rdata->uvd_notif; 812 stat->errors = rdata->uvd_err; 813 } 814 815 ret = regmap_write(d->regmap, BD957X_REG_INT_UVD_STAT, 816 UVD_IRQ_VALID_MASK & val); 817 818 return 0; 819 } 820 821 static int bd9576_ovd_handler(int irq, struct regulator_irq_data *rid, 822 unsigned long *dev_mask) 823 { 824 int val, ret, i; 825 struct bd957x_data *d = (struct bd957x_data *)rid->data; 826 827 ret = regmap_read(d->regmap, BD957X_REG_INT_OVD_STAT, &val); 828 if (ret) 829 return REGULATOR_FAILED_RETRY; 830 831 rid->opaque = val & OVD_IRQ_VALID_MASK; 832 *dev_mask = 0; 833 834 if (!(val & OVD_IRQ_VALID_MASK)) 835 return 0; 836 837 *dev_mask = val & BD9576_xVD_IRQ_MASK_VOUT1TO4; 838 /* There is 1 bit gap in register after Vout1 .. Vout4 statuses */ 839 *dev_mask |= ((val & BD9576_xVD_IRQ_MASK_VOUTL1) >> 1); 840 841 for_each_set_bit(i, dev_mask, 5) { 842 struct bd957x_regulator_data *rdata; 843 struct regulator_err_state *stat; 844 845 rdata = &d->regulator_data[i]; 846 stat = &rid->states[i]; 847 848 stat->notifs = rdata->ovd_notif; 849 stat->errors = rdata->ovd_err; 850 } 851 852 /* Clear the sub-IRQ status */ 853 regmap_write(d->regmap, BD957X_REG_INT_OVD_STAT, 854 OVD_IRQ_VALID_MASK & val); 855 856 return 0; 857 } 858 859 #define BD9576_DEV_MASK_ALL_REGULATORS 0x3F 860 861 static int bd9576_thermal_handler(int irq, struct regulator_irq_data *rid, 862 unsigned long *dev_mask) 863 { 864 int val, ret, i; 865 struct bd957x_data *d = (struct bd957x_data *)rid->data; 866 867 ret = regmap_read(d->regmap, BD957X_REG_INT_THERM_STAT, &val); 868 if (ret) 869 return REGULATOR_FAILED_RETRY; 870 871 if (!(val & BD9576_THERM_IRQ_MASK_TW)) { 872 *dev_mask = 0; 873 return 0; 874 } 875 876 *dev_mask = BD9576_DEV_MASK_ALL_REGULATORS; 877 878 for (i = 0; i < BD9576_NUM_REGULATORS; i++) { 879 struct bd957x_regulator_data *rdata; 880 struct regulator_err_state *stat; 881 882 rdata = &d->regulator_data[i]; 883 stat = &rid->states[i]; 884 885 stat->notifs = rdata->temp_notif; 886 stat->errors = rdata->temp_err; 887 } 888 889 /* Clear the sub-IRQ status */ 890 regmap_write(d->regmap, BD957X_REG_INT_THERM_STAT, 891 BD9576_THERM_IRQ_MASK_TW); 892 893 return 0; 894 } 895 896 static int bd957x_probe(struct platform_device *pdev) 897 { 898 int i; 899 unsigned int num_reg_data; 900 bool vout_mode, ddr_sel, may_have_irqs = false; 901 struct regmap *regmap; 902 struct bd957x_data *ic_data; 903 struct regulator_config config = { 0 }; 904 /* All regulators are related to UVD and thermal IRQs... */ 905 struct regulator_dev *rdevs[BD9576_NUM_REGULATORS]; 906 /* ...But VoutS1 is not flagged by OVD IRQ */ 907 struct regulator_dev *ovd_devs[BD9576_NUM_OVD_REGULATORS]; 908 static const struct regulator_irq_desc bd9576_notif_uvd = { 909 .name = "bd9576-uvd", 910 .irq_off_ms = 1000, 911 .map_event = bd9576_uvd_handler, 912 .renable = bd9576_uvd_renable, 913 .data = &bd957x_regulators, 914 }; 915 static const struct regulator_irq_desc bd9576_notif_ovd = { 916 .name = "bd9576-ovd", 917 .irq_off_ms = 1000, 918 .map_event = bd9576_ovd_handler, 919 .renable = bd9576_ovd_renable, 920 .data = &bd957x_regulators, 921 }; 922 static const struct regulator_irq_desc bd9576_notif_temp = { 923 .name = "bd9576-temp", 924 .irq_off_ms = 1000, 925 .map_event = bd9576_thermal_handler, 926 .renable = bd9576_temp_renable, 927 .data = &bd957x_regulators, 928 }; 929 enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data; 930 931 num_reg_data = ARRAY_SIZE(bd957x_regulators.regulator_data); 932 933 ic_data = &bd957x_regulators; 934 935 regmap = dev_get_regmap(pdev->dev.parent, NULL); 936 if (!regmap) { 937 dev_err(&pdev->dev, "No regmap\n"); 938 return -EINVAL; 939 } 940 941 ic_data->regmap = regmap; 942 vout_mode = of_property_read_bool(pdev->dev.parent->of_node, 943 "rohm,vout1-en-low"); 944 if (vout_mode) { 945 struct gpio_desc *en; 946 947 dev_dbg(&pdev->dev, "GPIO controlled mode\n"); 948 949 /* VOUT1 enable state judged by VOUT1_EN pin */ 950 /* See if we have GPIO defined */ 951 en = devm_gpiod_get_from_of_node(&pdev->dev, 952 pdev->dev.parent->of_node, 953 "rohm,vout1-en-gpios", 0, 954 GPIOD_OUT_LOW, "vout1-en"); 955 if (!IS_ERR(en)) { 956 /* VOUT1_OPS gpio ctrl */ 957 /* 958 * Regulator core prioritizes the ena_gpio over 959 * enable/disable/is_enabled callbacks so no need to 960 * clear them. We can still use same ops 961 */ 962 config.ena_gpiod = en; 963 } else { 964 /* 965 * In theory it is possible someone wants to set 966 * vout1-en LOW during OTP loading and set VOUT1 to be 967 * controlled by GPIO - but control the GPIO from some 968 * where else than this driver. For that to work we 969 * should unset the is_enabled callback here. 970 * 971 * I believe such case where rohm,vout1-en-low is set 972 * and vout1-en-gpios is not is likely to be a 973 * misconfiguration. So let's just err out for now. 974 */ 975 dev_err(&pdev->dev, 976 "Failed to get VOUT1 control GPIO\n"); 977 return PTR_ERR(en); 978 } 979 } 980 981 /* 982 * If more than one PMIC needs to be controlled by same processor then 983 * allocate the regulator data array here and use bd9576_regulators as 984 * template. At the moment I see no such use-case so I spare some 985 * bytes and use bd9576_regulators directly for non-constant configs 986 * like DDR voltage selection. 987 */ 988 platform_set_drvdata(pdev, ic_data); 989 ddr_sel = of_property_read_bool(pdev->dev.parent->of_node, 990 "rohm,ddr-sel-low"); 991 if (ddr_sel) 992 ic_data->regulator_data[2].desc.fixed_uV = 1350000; 993 else 994 ic_data->regulator_data[2].desc.fixed_uV = 1500000; 995 996 switch (chip) { 997 case ROHM_CHIP_TYPE_BD9576: 998 may_have_irqs = true; 999 dev_dbg(&pdev->dev, "Found BD9576MUF\n"); 1000 break; 1001 case ROHM_CHIP_TYPE_BD9573: 1002 dev_dbg(&pdev->dev, "Found BD9573MUF\n"); 1003 break; 1004 default: 1005 dev_err(&pdev->dev, "Unsupported chip type\n"); 1006 return -EINVAL; 1007 } 1008 1009 for (i = 0; i < num_reg_data; i++) { 1010 struct regulator_desc *d; 1011 1012 d = &ic_data->regulator_data[i].desc; 1013 1014 1015 if (may_have_irqs) { 1016 if (d->id >= ARRAY_SIZE(bd9576_ops_arr)) 1017 return -EINVAL; 1018 1019 d->ops = bd9576_ops_arr[d->id]; 1020 } else { 1021 if (d->id >= ARRAY_SIZE(bd9573_ops_arr)) 1022 return -EINVAL; 1023 1024 d->ops = bd9573_ops_arr[d->id]; 1025 } 1026 } 1027 1028 config.dev = pdev->dev.parent; 1029 config.regmap = regmap; 1030 config.driver_data = ic_data; 1031 1032 for (i = 0; i < num_reg_data; i++) { 1033 1034 struct bd957x_regulator_data *r = &ic_data->regulator_data[i]; 1035 const struct regulator_desc *desc = &r->desc; 1036 1037 r->rdev = devm_regulator_register(&pdev->dev, desc, 1038 &config); 1039 if (IS_ERR(r->rdev)) { 1040 dev_err(&pdev->dev, 1041 "failed to register %s regulator\n", 1042 desc->name); 1043 return PTR_ERR(r->rdev); 1044 } 1045 /* 1046 * Clear the VOUT1 GPIO setting - rest of the regulators do not 1047 * support GPIO control 1048 */ 1049 config.ena_gpiod = NULL; 1050 1051 if (!may_have_irqs) 1052 continue; 1053 1054 rdevs[i] = r->rdev; 1055 if (i < BD957X_VOUTS1) 1056 ovd_devs[i] = r->rdev; 1057 } 1058 if (may_have_irqs) { 1059 void *ret; 1060 /* 1061 * We can add both the possible error and warning flags here 1062 * because the core uses these only for status clearing and 1063 * if we use warnings - errors are always clear and the other 1064 * way around. We can also add CURRENT flag for all regulators 1065 * because it is never set if it is not supported. Same applies 1066 * to setting UVD for VoutS1 - it is not accidentally cleared 1067 * as it is never set. 1068 */ 1069 int uvd_errs = REGULATOR_ERROR_UNDER_VOLTAGE | 1070 REGULATOR_ERROR_UNDER_VOLTAGE_WARN | 1071 REGULATOR_ERROR_OVER_CURRENT | 1072 REGULATOR_ERROR_OVER_CURRENT_WARN; 1073 int ovd_errs = REGULATOR_ERROR_OVER_VOLTAGE_WARN | 1074 REGULATOR_ERROR_REGULATION_OUT; 1075 int temp_errs = REGULATOR_ERROR_OVER_TEMP | 1076 REGULATOR_ERROR_OVER_TEMP_WARN; 1077 int irq; 1078 1079 irq = platform_get_irq_byname(pdev, "bd9576-uvd"); 1080 1081 /* Register notifiers - can fail if IRQ is not given */ 1082 ret = devm_regulator_irq_helper(&pdev->dev, &bd9576_notif_uvd, 1083 irq, 0, uvd_errs, NULL, 1084 &rdevs[0], 1085 BD9576_NUM_REGULATORS); 1086 if (IS_ERR(ret)) { 1087 if (PTR_ERR(ret) == -EPROBE_DEFER) 1088 return -EPROBE_DEFER; 1089 1090 dev_warn(&pdev->dev, "UVD disabled %pe\n", ret); 1091 } 1092 1093 irq = platform_get_irq_byname(pdev, "bd9576-ovd"); 1094 1095 ret = devm_regulator_irq_helper(&pdev->dev, &bd9576_notif_ovd, 1096 irq, 0, ovd_errs, NULL, 1097 &ovd_devs[0], 1098 BD9576_NUM_OVD_REGULATORS); 1099 if (IS_ERR(ret)) { 1100 if (PTR_ERR(ret) == -EPROBE_DEFER) 1101 return -EPROBE_DEFER; 1102 1103 dev_warn(&pdev->dev, "OVD disabled %pe\n", ret); 1104 } 1105 irq = platform_get_irq_byname(pdev, "bd9576-temp"); 1106 1107 ret = devm_regulator_irq_helper(&pdev->dev, &bd9576_notif_temp, 1108 irq, 0, temp_errs, NULL, 1109 &rdevs[0], 1110 BD9576_NUM_REGULATORS); 1111 if (IS_ERR(ret)) { 1112 if (PTR_ERR(ret) == -EPROBE_DEFER) 1113 return -EPROBE_DEFER; 1114 1115 dev_warn(&pdev->dev, "Thermal warning disabled %pe\n", 1116 ret); 1117 } 1118 } 1119 return 0; 1120 } 1121 1122 static const struct platform_device_id bd957x_pmic_id[] = { 1123 { "bd9573-regulator", ROHM_CHIP_TYPE_BD9573 }, 1124 { "bd9576-regulator", ROHM_CHIP_TYPE_BD9576 }, 1125 { }, 1126 }; 1127 MODULE_DEVICE_TABLE(platform, bd957x_pmic_id); 1128 1129 static struct platform_driver bd957x_regulator = { 1130 .driver = { 1131 .name = "bd957x-pmic", 1132 }, 1133 .probe = bd957x_probe, 1134 .id_table = bd957x_pmic_id, 1135 }; 1136 1137 module_platform_driver(bd957x_regulator); 1138 1139 MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>"); 1140 MODULE_DESCRIPTION("ROHM BD9576/BD9573 voltage regulator driver"); 1141 MODULE_LICENSE("GPL"); 1142 MODULE_ALIAS("platform:bd957x-pmic"); 1143