1 /* 2 * Regulator device driver for DA9061 and DA9062. 3 * Copyright (C) 2015-2017 Dialog Semiconductor 4 * 5 * This program is free software; you can redistribute it and/or 6 * modify it under the terms of the GNU General Public License 7 * as published by the Free Software Foundation; either version 2 8 * of the License, or (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 13 * GNU General Public License for more details. 14 */ 15 #include <linux/kernel.h> 16 #include <linux/module.h> 17 #include <linux/init.h> 18 #include <linux/err.h> 19 #include <linux/slab.h> 20 #include <linux/of.h> 21 #include <linux/platform_device.h> 22 #include <linux/regmap.h> 23 #include <linux/regulator/driver.h> 24 #include <linux/regulator/machine.h> 25 #include <linux/regulator/of_regulator.h> 26 #include <linux/mfd/da9062/core.h> 27 #include <linux/mfd/da9062/registers.h> 28 29 /* Regulator IDs */ 30 enum { 31 DA9061_ID_BUCK1, 32 DA9061_ID_BUCK2, 33 DA9061_ID_BUCK3, 34 DA9061_ID_LDO1, 35 DA9061_ID_LDO2, 36 DA9061_ID_LDO3, 37 DA9061_ID_LDO4, 38 DA9061_MAX_REGULATORS, 39 }; 40 41 enum { 42 DA9062_ID_BUCK1, 43 DA9062_ID_BUCK2, 44 DA9062_ID_BUCK3, 45 DA9062_ID_BUCK4, 46 DA9062_ID_LDO1, 47 DA9062_ID_LDO2, 48 DA9062_ID_LDO3, 49 DA9062_ID_LDO4, 50 DA9062_MAX_REGULATORS, 51 }; 52 53 /* Regulator capabilities and registers description */ 54 struct da9062_regulator_info { 55 struct regulator_desc desc; 56 /* Current limiting */ 57 unsigned int n_current_limits; 58 const int *current_limits; 59 /* Main register fields */ 60 struct reg_field mode; 61 struct reg_field suspend; 62 struct reg_field sleep; 63 struct reg_field suspend_sleep; 64 unsigned int suspend_vsel_reg; 65 struct reg_field ilimit; 66 /* Event detection bit */ 67 struct reg_field oc_event; 68 }; 69 70 /* Single regulator settings */ 71 struct da9062_regulator { 72 struct regulator_desc desc; 73 struct regulator_dev *rdev; 74 struct da9062 *hw; 75 const struct da9062_regulator_info *info; 76 77 struct regmap_field *mode; 78 struct regmap_field *suspend; 79 struct regmap_field *sleep; 80 struct regmap_field *suspend_sleep; 81 struct regmap_field *ilimit; 82 }; 83 84 /* Encapsulates all information for the regulators driver */ 85 struct da9062_regulators { 86 int irq_ldo_lim; 87 unsigned n_regulators; 88 /* Array size to be defined during init. Keep at end. */ 89 struct da9062_regulator regulator[0]; 90 }; 91 92 /* BUCK modes */ 93 enum { 94 BUCK_MODE_MANUAL, /* 0 */ 95 BUCK_MODE_SLEEP, /* 1 */ 96 BUCK_MODE_SYNC, /* 2 */ 97 BUCK_MODE_AUTO /* 3 */ 98 }; 99 100 /* Regulator operations */ 101 102 /* Current limits array (in uA) 103 * - DA9061_ID_[BUCK1|BUCK3] 104 * - DA9062_ID_[BUCK1|BUCK2|BUCK4] 105 * Entry indexes corresponds to register values. 106 */ 107 static const int da9062_buck_a_limits[] = { 108 500000, 600000, 700000, 800000, 900000, 1000000, 1100000, 1200000, 109 1300000, 1400000, 1500000, 1600000, 1700000, 1800000, 1900000, 2000000 110 }; 111 112 /* Current limits array (in uA) 113 * - DA9061_ID_BUCK2 114 * - DA9062_ID_BUCK3 115 * Entry indexes corresponds to register values. 116 */ 117 static const int da9062_buck_b_limits[] = { 118 1500000, 1600000, 1700000, 1800000, 1900000, 2000000, 2100000, 2200000, 119 2300000, 2400000, 2500000, 2600000, 2700000, 2800000, 2900000, 3000000 120 }; 121 122 static int da9062_set_current_limit(struct regulator_dev *rdev, 123 int min_ua, int max_ua) 124 { 125 struct da9062_regulator *regl = rdev_get_drvdata(rdev); 126 const struct da9062_regulator_info *rinfo = regl->info; 127 int n, tval; 128 129 for (n = rinfo->n_current_limits - 1; n >= 0; n--) { 130 tval = rinfo->current_limits[n]; 131 if (tval >= min_ua && tval <= max_ua) 132 return regmap_field_write(regl->ilimit, n); 133 } 134 135 return -EINVAL; 136 } 137 138 static int da9062_get_current_limit(struct regulator_dev *rdev) 139 { 140 struct da9062_regulator *regl = rdev_get_drvdata(rdev); 141 const struct da9062_regulator_info *rinfo = regl->info; 142 unsigned int sel; 143 int ret; 144 145 ret = regmap_field_read(regl->ilimit, &sel); 146 if (ret < 0) 147 return ret; 148 149 if (sel >= rinfo->n_current_limits) 150 sel = rinfo->n_current_limits - 1; 151 152 return rinfo->current_limits[sel]; 153 } 154 155 static int da9062_buck_set_mode(struct regulator_dev *rdev, unsigned mode) 156 { 157 struct da9062_regulator *regl = rdev_get_drvdata(rdev); 158 unsigned val; 159 160 switch (mode) { 161 case REGULATOR_MODE_FAST: 162 val = BUCK_MODE_SYNC; 163 break; 164 case REGULATOR_MODE_NORMAL: 165 val = BUCK_MODE_AUTO; 166 break; 167 case REGULATOR_MODE_STANDBY: 168 val = BUCK_MODE_SLEEP; 169 break; 170 default: 171 return -EINVAL; 172 } 173 174 return regmap_field_write(regl->mode, val); 175 } 176 177 /* 178 * Bucks use single mode register field for normal operation 179 * and suspend state. 180 * There are 3 modes to map to: FAST, NORMAL, and STANDBY. 181 */ 182 183 static unsigned da9062_buck_get_mode(struct regulator_dev *rdev) 184 { 185 struct da9062_regulator *regl = rdev_get_drvdata(rdev); 186 struct regmap_field *field; 187 unsigned int val, mode = 0; 188 int ret; 189 190 ret = regmap_field_read(regl->mode, &val); 191 if (ret < 0) 192 return ret; 193 194 switch (val) { 195 default: 196 case BUCK_MODE_MANUAL: 197 mode = REGULATOR_MODE_FAST | REGULATOR_MODE_STANDBY; 198 /* Sleep flag bit decides the mode */ 199 break; 200 case BUCK_MODE_SLEEP: 201 return REGULATOR_MODE_STANDBY; 202 case BUCK_MODE_SYNC: 203 return REGULATOR_MODE_FAST; 204 case BUCK_MODE_AUTO: 205 return REGULATOR_MODE_NORMAL; 206 } 207 208 /* Detect current regulator state */ 209 ret = regmap_field_read(regl->suspend, &val); 210 if (ret < 0) 211 return 0; 212 213 /* Read regulator mode from proper register, depending on state */ 214 if (val) 215 field = regl->suspend_sleep; 216 else 217 field = regl->sleep; 218 219 ret = regmap_field_read(field, &val); 220 if (ret < 0) 221 return 0; 222 223 if (val) 224 mode &= REGULATOR_MODE_STANDBY; 225 else 226 mode &= REGULATOR_MODE_NORMAL | REGULATOR_MODE_FAST; 227 228 return mode; 229 } 230 231 /* 232 * LDOs use sleep flags - one for normal and one for suspend state. 233 * There are 2 modes to map to: NORMAL and STANDBY (sleep) for each state. 234 */ 235 236 static int da9062_ldo_set_mode(struct regulator_dev *rdev, unsigned mode) 237 { 238 struct da9062_regulator *regl = rdev_get_drvdata(rdev); 239 unsigned val; 240 241 switch (mode) { 242 case REGULATOR_MODE_NORMAL: 243 val = 0; 244 break; 245 case REGULATOR_MODE_STANDBY: 246 val = 1; 247 break; 248 default: 249 return -EINVAL; 250 } 251 252 return regmap_field_write(regl->sleep, val); 253 } 254 255 static unsigned da9062_ldo_get_mode(struct regulator_dev *rdev) 256 { 257 struct da9062_regulator *regl = rdev_get_drvdata(rdev); 258 struct regmap_field *field; 259 int ret, val; 260 261 /* Detect current regulator state */ 262 ret = regmap_field_read(regl->suspend, &val); 263 if (ret < 0) 264 return 0; 265 266 /* Read regulator mode from proper register, depending on state */ 267 if (val) 268 field = regl->suspend_sleep; 269 else 270 field = regl->sleep; 271 272 ret = regmap_field_read(field, &val); 273 if (ret < 0) 274 return 0; 275 276 if (val) 277 return REGULATOR_MODE_STANDBY; 278 else 279 return REGULATOR_MODE_NORMAL; 280 } 281 282 static int da9062_buck_get_status(struct regulator_dev *rdev) 283 { 284 int ret = regulator_is_enabled_regmap(rdev); 285 286 if (ret == 0) { 287 ret = REGULATOR_STATUS_OFF; 288 } else if (ret > 0) { 289 ret = da9062_buck_get_mode(rdev); 290 if (ret > 0) 291 ret = regulator_mode_to_status(ret); 292 else if (ret == 0) 293 ret = -EIO; 294 } 295 296 return ret; 297 } 298 299 static int da9062_ldo_get_status(struct regulator_dev *rdev) 300 { 301 int ret = regulator_is_enabled_regmap(rdev); 302 303 if (ret == 0) { 304 ret = REGULATOR_STATUS_OFF; 305 } else if (ret > 0) { 306 ret = da9062_ldo_get_mode(rdev); 307 if (ret > 0) 308 ret = regulator_mode_to_status(ret); 309 else if (ret == 0) 310 ret = -EIO; 311 } 312 313 return ret; 314 } 315 316 static int da9062_set_suspend_voltage(struct regulator_dev *rdev, int uv) 317 { 318 struct da9062_regulator *regl = rdev_get_drvdata(rdev); 319 const struct da9062_regulator_info *rinfo = regl->info; 320 int ret, sel; 321 322 sel = regulator_map_voltage_linear(rdev, uv, uv); 323 if (sel < 0) 324 return sel; 325 326 sel <<= ffs(rdev->desc->vsel_mask) - 1; 327 328 ret = regmap_update_bits(regl->hw->regmap, rinfo->suspend_vsel_reg, 329 rdev->desc->vsel_mask, sel); 330 331 return ret; 332 } 333 334 static int da9062_suspend_enable(struct regulator_dev *rdev) 335 { 336 struct da9062_regulator *regl = rdev_get_drvdata(rdev); 337 338 return regmap_field_write(regl->suspend, 1); 339 } 340 341 static int da9062_suspend_disable(struct regulator_dev *rdev) 342 { 343 struct da9062_regulator *regl = rdev_get_drvdata(rdev); 344 345 return regmap_field_write(regl->suspend, 0); 346 } 347 348 static int da9062_buck_set_suspend_mode(struct regulator_dev *rdev, 349 unsigned mode) 350 { 351 struct da9062_regulator *regl = rdev_get_drvdata(rdev); 352 int val; 353 354 switch (mode) { 355 case REGULATOR_MODE_FAST: 356 val = BUCK_MODE_SYNC; 357 break; 358 case REGULATOR_MODE_NORMAL: 359 val = BUCK_MODE_AUTO; 360 break; 361 case REGULATOR_MODE_STANDBY: 362 val = BUCK_MODE_SLEEP; 363 break; 364 default: 365 return -EINVAL; 366 } 367 368 return regmap_field_write(regl->mode, val); 369 } 370 371 static int da9062_ldo_set_suspend_mode(struct regulator_dev *rdev, 372 unsigned mode) 373 { 374 struct da9062_regulator *regl = rdev_get_drvdata(rdev); 375 unsigned val; 376 377 switch (mode) { 378 case REGULATOR_MODE_NORMAL: 379 val = 0; 380 break; 381 case REGULATOR_MODE_STANDBY: 382 val = 1; 383 break; 384 default: 385 return -EINVAL; 386 } 387 388 return regmap_field_write(regl->suspend_sleep, val); 389 } 390 391 static const struct regulator_ops da9062_buck_ops = { 392 .enable = regulator_enable_regmap, 393 .disable = regulator_disable_regmap, 394 .is_enabled = regulator_is_enabled_regmap, 395 .get_voltage_sel = regulator_get_voltage_sel_regmap, 396 .set_voltage_sel = regulator_set_voltage_sel_regmap, 397 .list_voltage = regulator_list_voltage_linear, 398 .set_current_limit = da9062_set_current_limit, 399 .get_current_limit = da9062_get_current_limit, 400 .set_mode = da9062_buck_set_mode, 401 .get_mode = da9062_buck_get_mode, 402 .get_status = da9062_buck_get_status, 403 .set_suspend_voltage = da9062_set_suspend_voltage, 404 .set_suspend_enable = da9062_suspend_enable, 405 .set_suspend_disable = da9062_suspend_disable, 406 .set_suspend_mode = da9062_buck_set_suspend_mode, 407 }; 408 409 static const struct regulator_ops da9062_ldo_ops = { 410 .enable = regulator_enable_regmap, 411 .disable = regulator_disable_regmap, 412 .is_enabled = regulator_is_enabled_regmap, 413 .get_voltage_sel = regulator_get_voltage_sel_regmap, 414 .set_voltage_sel = regulator_set_voltage_sel_regmap, 415 .list_voltage = regulator_list_voltage_linear, 416 .set_mode = da9062_ldo_set_mode, 417 .get_mode = da9062_ldo_get_mode, 418 .get_status = da9062_ldo_get_status, 419 .set_suspend_voltage = da9062_set_suspend_voltage, 420 .set_suspend_enable = da9062_suspend_enable, 421 .set_suspend_disable = da9062_suspend_disable, 422 .set_suspend_mode = da9062_ldo_set_suspend_mode, 423 }; 424 425 /* DA9061 Regulator information */ 426 static const struct da9062_regulator_info local_da9061_regulator_info[] = { 427 { 428 .desc.id = DA9061_ID_BUCK1, 429 .desc.name = "DA9061 BUCK1", 430 .desc.of_match = of_match_ptr("buck1"), 431 .desc.regulators_node = of_match_ptr("regulators"), 432 .desc.ops = &da9062_buck_ops, 433 .desc.min_uV = (300) * 1000, 434 .desc.uV_step = (10) * 1000, 435 .desc.n_voltages = ((1570) - (300))/(10) + 1, 436 .current_limits = da9062_buck_a_limits, 437 .n_current_limits = ARRAY_SIZE(da9062_buck_a_limits), 438 .desc.enable_reg = DA9062AA_BUCK1_CONT, 439 .desc.enable_mask = DA9062AA_BUCK1_EN_MASK, 440 .desc.vsel_reg = DA9062AA_VBUCK1_A, 441 .desc.vsel_mask = DA9062AA_VBUCK1_A_MASK, 442 .desc.linear_min_sel = 0, 443 .sleep = REG_FIELD(DA9062AA_VBUCK1_A, 444 __builtin_ffs((int)DA9062AA_BUCK1_SL_A_MASK) - 1, 445 sizeof(unsigned int) * 8 - 446 __builtin_clz((DA9062AA_BUCK1_SL_A_MASK)) - 1), 447 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK1_B, 448 __builtin_ffs((int)DA9062AA_BUCK1_SL_B_MASK) - 1, 449 sizeof(unsigned int) * 8 - 450 __builtin_clz((DA9062AA_BUCK1_SL_B_MASK)) - 1), 451 .suspend_vsel_reg = DA9062AA_VBUCK1_B, 452 .mode = REG_FIELD(DA9062AA_BUCK1_CFG, 453 __builtin_ffs((int)DA9062AA_BUCK1_MODE_MASK) - 1, 454 sizeof(unsigned int) * 8 - 455 __builtin_clz((DA9062AA_BUCK1_MODE_MASK)) - 1), 456 .suspend = REG_FIELD(DA9062AA_DVC_1, 457 __builtin_ffs((int)DA9062AA_VBUCK1_SEL_MASK) - 1, 458 sizeof(unsigned int) * 8 - 459 __builtin_clz((DA9062AA_VBUCK1_SEL_MASK)) - 1), 460 .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_C, 461 __builtin_ffs((int)DA9062AA_BUCK1_ILIM_MASK) - 1, 462 sizeof(unsigned int) * 8 - 463 __builtin_clz((DA9062AA_BUCK1_ILIM_MASK)) - 1), 464 }, 465 { 466 .desc.id = DA9061_ID_BUCK2, 467 .desc.name = "DA9061 BUCK2", 468 .desc.of_match = of_match_ptr("buck2"), 469 .desc.regulators_node = of_match_ptr("regulators"), 470 .desc.ops = &da9062_buck_ops, 471 .desc.min_uV = (800) * 1000, 472 .desc.uV_step = (20) * 1000, 473 .desc.n_voltages = ((3340) - (800))/(20) + 1, 474 .current_limits = da9062_buck_b_limits, 475 .n_current_limits = ARRAY_SIZE(da9062_buck_b_limits), 476 .desc.enable_reg = DA9062AA_BUCK3_CONT, 477 .desc.enable_mask = DA9062AA_BUCK3_EN_MASK, 478 .desc.vsel_reg = DA9062AA_VBUCK3_A, 479 .desc.vsel_mask = DA9062AA_VBUCK3_A_MASK, 480 .desc.linear_min_sel = 0, 481 .sleep = REG_FIELD(DA9062AA_VBUCK3_A, 482 __builtin_ffs((int)DA9062AA_BUCK3_SL_A_MASK) - 1, 483 sizeof(unsigned int) * 8 - 484 __builtin_clz((DA9062AA_BUCK3_SL_A_MASK)) - 1), 485 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK3_B, 486 __builtin_ffs((int)DA9062AA_BUCK3_SL_B_MASK) - 1, 487 sizeof(unsigned int) * 8 - 488 __builtin_clz((DA9062AA_BUCK3_SL_B_MASK)) - 1), 489 .suspend_vsel_reg = DA9062AA_VBUCK3_B, 490 .mode = REG_FIELD(DA9062AA_BUCK3_CFG, 491 __builtin_ffs((int)DA9062AA_BUCK3_MODE_MASK) - 1, 492 sizeof(unsigned int) * 8 - 493 __builtin_clz((DA9062AA_BUCK3_MODE_MASK)) - 1), 494 .suspend = REG_FIELD(DA9062AA_DVC_1, 495 __builtin_ffs((int)DA9062AA_VBUCK3_SEL_MASK) - 1, 496 sizeof(unsigned int) * 8 - 497 __builtin_clz((DA9062AA_VBUCK3_SEL_MASK)) - 1), 498 .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_A, 499 __builtin_ffs((int)DA9062AA_BUCK3_ILIM_MASK) - 1, 500 sizeof(unsigned int) * 8 - 501 __builtin_clz((DA9062AA_BUCK3_ILIM_MASK)) - 1), 502 }, 503 { 504 .desc.id = DA9061_ID_BUCK3, 505 .desc.name = "DA9061 BUCK3", 506 .desc.of_match = of_match_ptr("buck3"), 507 .desc.regulators_node = of_match_ptr("regulators"), 508 .desc.ops = &da9062_buck_ops, 509 .desc.min_uV = (530) * 1000, 510 .desc.uV_step = (10) * 1000, 511 .desc.n_voltages = ((1800) - (530))/(10) + 1, 512 .current_limits = da9062_buck_a_limits, 513 .n_current_limits = ARRAY_SIZE(da9062_buck_a_limits), 514 .desc.enable_reg = DA9062AA_BUCK4_CONT, 515 .desc.enable_mask = DA9062AA_BUCK4_EN_MASK, 516 .desc.vsel_reg = DA9062AA_VBUCK4_A, 517 .desc.vsel_mask = DA9062AA_VBUCK4_A_MASK, 518 .desc.linear_min_sel = 0, 519 .sleep = REG_FIELD(DA9062AA_VBUCK4_A, 520 __builtin_ffs((int)DA9062AA_BUCK4_SL_A_MASK) - 1, 521 sizeof(unsigned int) * 8 - 522 __builtin_clz((DA9062AA_BUCK4_SL_A_MASK)) - 1), 523 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK4_B, 524 __builtin_ffs((int)DA9062AA_BUCK4_SL_B_MASK) - 1, 525 sizeof(unsigned int) * 8 - 526 __builtin_clz((DA9062AA_BUCK4_SL_B_MASK)) - 1), 527 .suspend_vsel_reg = DA9062AA_VBUCK4_B, 528 .mode = REG_FIELD(DA9062AA_BUCK4_CFG, 529 __builtin_ffs((int)DA9062AA_BUCK4_MODE_MASK) - 1, 530 sizeof(unsigned int) * 8 - 531 __builtin_clz((DA9062AA_BUCK4_MODE_MASK)) - 1), 532 .suspend = REG_FIELD(DA9062AA_DVC_1, 533 __builtin_ffs((int)DA9062AA_VBUCK4_SEL_MASK) - 1, 534 sizeof(unsigned int) * 8 - 535 __builtin_clz((DA9062AA_VBUCK4_SEL_MASK)) - 1), 536 .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_B, 537 __builtin_ffs((int)DA9062AA_BUCK4_ILIM_MASK) - 1, 538 sizeof(unsigned int) * 8 - 539 __builtin_clz((DA9062AA_BUCK4_ILIM_MASK)) - 1), 540 }, 541 { 542 .desc.id = DA9061_ID_LDO1, 543 .desc.name = "DA9061 LDO1", 544 .desc.of_match = of_match_ptr("ldo1"), 545 .desc.regulators_node = of_match_ptr("regulators"), 546 .desc.ops = &da9062_ldo_ops, 547 .desc.min_uV = (900) * 1000, 548 .desc.uV_step = (50) * 1000, 549 .desc.n_voltages = ((3600) - (900))/(50) + 1, 550 .desc.enable_reg = DA9062AA_LDO1_CONT, 551 .desc.enable_mask = DA9062AA_LDO1_EN_MASK, 552 .desc.vsel_reg = DA9062AA_VLDO1_A, 553 .desc.vsel_mask = DA9062AA_VLDO1_A_MASK, 554 .desc.linear_min_sel = 0, 555 .sleep = REG_FIELD(DA9062AA_VLDO1_A, 556 __builtin_ffs((int)DA9062AA_LDO1_SL_A_MASK) - 1, 557 sizeof(unsigned int) * 8 - 558 __builtin_clz((DA9062AA_LDO1_SL_A_MASK)) - 1), 559 .suspend_sleep = REG_FIELD(DA9062AA_VLDO1_B, 560 __builtin_ffs((int)DA9062AA_LDO1_SL_B_MASK) - 1, 561 sizeof(unsigned int) * 8 - 562 __builtin_clz((DA9062AA_LDO1_SL_B_MASK)) - 1), 563 .suspend_vsel_reg = DA9062AA_VLDO1_B, 564 .suspend = REG_FIELD(DA9062AA_DVC_1, 565 __builtin_ffs((int)DA9062AA_VLDO1_SEL_MASK) - 1, 566 sizeof(unsigned int) * 8 - 567 __builtin_clz((DA9062AA_VLDO1_SEL_MASK)) - 1), 568 .oc_event = REG_FIELD(DA9062AA_STATUS_D, 569 __builtin_ffs((int)DA9062AA_LDO1_ILIM_MASK) - 1, 570 sizeof(unsigned int) * 8 - 571 __builtin_clz((DA9062AA_LDO1_ILIM_MASK)) - 1), 572 }, 573 { 574 .desc.id = DA9061_ID_LDO2, 575 .desc.name = "DA9061 LDO2", 576 .desc.of_match = of_match_ptr("ldo2"), 577 .desc.regulators_node = of_match_ptr("regulators"), 578 .desc.ops = &da9062_ldo_ops, 579 .desc.min_uV = (900) * 1000, 580 .desc.uV_step = (50) * 1000, 581 .desc.n_voltages = ((3600) - (600))/(50) + 1, 582 .desc.enable_reg = DA9062AA_LDO2_CONT, 583 .desc.enable_mask = DA9062AA_LDO2_EN_MASK, 584 .desc.vsel_reg = DA9062AA_VLDO2_A, 585 .desc.vsel_mask = DA9062AA_VLDO2_A_MASK, 586 .desc.linear_min_sel = 0, 587 .sleep = REG_FIELD(DA9062AA_VLDO2_A, 588 __builtin_ffs((int)DA9062AA_LDO2_SL_A_MASK) - 1, 589 sizeof(unsigned int) * 8 - 590 __builtin_clz((DA9062AA_LDO2_SL_A_MASK)) - 1), 591 .suspend_sleep = REG_FIELD(DA9062AA_VLDO2_B, 592 __builtin_ffs((int)DA9062AA_LDO2_SL_B_MASK) - 1, 593 sizeof(unsigned int) * 8 - 594 __builtin_clz((DA9062AA_LDO2_SL_B_MASK)) - 1), 595 .suspend_vsel_reg = DA9062AA_VLDO2_B, 596 .suspend = REG_FIELD(DA9062AA_DVC_1, 597 __builtin_ffs((int)DA9062AA_VLDO2_SEL_MASK) - 1, 598 sizeof(unsigned int) * 8 - 599 __builtin_clz((DA9062AA_VLDO2_SEL_MASK)) - 1), 600 .oc_event = REG_FIELD(DA9062AA_STATUS_D, 601 __builtin_ffs((int)DA9062AA_LDO2_ILIM_MASK) - 1, 602 sizeof(unsigned int) * 8 - 603 __builtin_clz((DA9062AA_LDO2_ILIM_MASK)) - 1), 604 }, 605 { 606 .desc.id = DA9061_ID_LDO3, 607 .desc.name = "DA9061 LDO3", 608 .desc.of_match = of_match_ptr("ldo3"), 609 .desc.regulators_node = of_match_ptr("regulators"), 610 .desc.ops = &da9062_ldo_ops, 611 .desc.min_uV = (900) * 1000, 612 .desc.uV_step = (50) * 1000, 613 .desc.n_voltages = ((3600) - (900))/(50) + 1, 614 .desc.enable_reg = DA9062AA_LDO3_CONT, 615 .desc.enable_mask = DA9062AA_LDO3_EN_MASK, 616 .desc.vsel_reg = DA9062AA_VLDO3_A, 617 .desc.vsel_mask = DA9062AA_VLDO3_A_MASK, 618 .desc.linear_min_sel = 0, 619 .sleep = REG_FIELD(DA9062AA_VLDO3_A, 620 __builtin_ffs((int)DA9062AA_LDO3_SL_A_MASK) - 1, 621 sizeof(unsigned int) * 8 - 622 __builtin_clz((DA9062AA_LDO3_SL_A_MASK)) - 1), 623 .suspend_sleep = REG_FIELD(DA9062AA_VLDO3_B, 624 __builtin_ffs((int)DA9062AA_LDO3_SL_B_MASK) - 1, 625 sizeof(unsigned int) * 8 - 626 __builtin_clz((DA9062AA_LDO3_SL_B_MASK)) - 1), 627 .suspend_vsel_reg = DA9062AA_VLDO3_B, 628 .suspend = REG_FIELD(DA9062AA_DVC_1, 629 __builtin_ffs((int)DA9062AA_VLDO3_SEL_MASK) - 1, 630 sizeof(unsigned int) * 8 - 631 __builtin_clz((DA9062AA_VLDO3_SEL_MASK)) - 1), 632 .oc_event = REG_FIELD(DA9062AA_STATUS_D, 633 __builtin_ffs((int)DA9062AA_LDO3_ILIM_MASK) - 1, 634 sizeof(unsigned int) * 8 - 635 __builtin_clz((DA9062AA_LDO3_ILIM_MASK)) - 1), 636 }, 637 { 638 .desc.id = DA9061_ID_LDO4, 639 .desc.name = "DA9061 LDO4", 640 .desc.of_match = of_match_ptr("ldo4"), 641 .desc.regulators_node = of_match_ptr("regulators"), 642 .desc.ops = &da9062_ldo_ops, 643 .desc.min_uV = (900) * 1000, 644 .desc.uV_step = (50) * 1000, 645 .desc.n_voltages = ((3600) - (900))/(50) + 1, 646 .desc.enable_reg = DA9062AA_LDO4_CONT, 647 .desc.enable_mask = DA9062AA_LDO4_EN_MASK, 648 .desc.vsel_reg = DA9062AA_VLDO4_A, 649 .desc.vsel_mask = DA9062AA_VLDO4_A_MASK, 650 .desc.linear_min_sel = 0, 651 .sleep = REG_FIELD(DA9062AA_VLDO4_A, 652 __builtin_ffs((int)DA9062AA_LDO4_SL_A_MASK) - 1, 653 sizeof(unsigned int) * 8 - 654 __builtin_clz((DA9062AA_LDO4_SL_A_MASK)) - 1), 655 .suspend_sleep = REG_FIELD(DA9062AA_VLDO4_B, 656 __builtin_ffs((int)DA9062AA_LDO4_SL_B_MASK) - 1, 657 sizeof(unsigned int) * 8 - 658 __builtin_clz((DA9062AA_LDO4_SL_B_MASK)) - 1), 659 .suspend_vsel_reg = DA9062AA_VLDO4_B, 660 .suspend = REG_FIELD(DA9062AA_DVC_1, 661 __builtin_ffs((int)DA9062AA_VLDO4_SEL_MASK) - 1, 662 sizeof(unsigned int) * 8 - 663 __builtin_clz((DA9062AA_VLDO4_SEL_MASK)) - 1), 664 .oc_event = REG_FIELD(DA9062AA_STATUS_D, 665 __builtin_ffs((int)DA9062AA_LDO4_ILIM_MASK) - 1, 666 sizeof(unsigned int) * 8 - 667 __builtin_clz((DA9062AA_LDO4_ILIM_MASK)) - 1), 668 }, 669 }; 670 671 /* DA9062 Regulator information */ 672 static const struct da9062_regulator_info local_da9062_regulator_info[] = { 673 { 674 .desc.id = DA9062_ID_BUCK1, 675 .desc.name = "DA9062 BUCK1", 676 .desc.of_match = of_match_ptr("buck1"), 677 .desc.regulators_node = of_match_ptr("regulators"), 678 .desc.ops = &da9062_buck_ops, 679 .desc.min_uV = (300) * 1000, 680 .desc.uV_step = (10) * 1000, 681 .desc.n_voltages = ((1570) - (300))/(10) + 1, 682 .current_limits = da9062_buck_a_limits, 683 .n_current_limits = ARRAY_SIZE(da9062_buck_a_limits), 684 .desc.enable_reg = DA9062AA_BUCK1_CONT, 685 .desc.enable_mask = DA9062AA_BUCK1_EN_MASK, 686 .desc.vsel_reg = DA9062AA_VBUCK1_A, 687 .desc.vsel_mask = DA9062AA_VBUCK1_A_MASK, 688 .desc.linear_min_sel = 0, 689 .sleep = REG_FIELD(DA9062AA_VBUCK1_A, 690 __builtin_ffs((int)DA9062AA_BUCK1_SL_A_MASK) - 1, 691 sizeof(unsigned int) * 8 - 692 __builtin_clz((DA9062AA_BUCK1_SL_A_MASK)) - 1), 693 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK1_B, 694 __builtin_ffs((int)DA9062AA_BUCK1_SL_B_MASK) - 1, 695 sizeof(unsigned int) * 8 - 696 __builtin_clz((DA9062AA_BUCK1_SL_B_MASK)) - 1), 697 .suspend_vsel_reg = DA9062AA_VBUCK1_B, 698 .mode = REG_FIELD(DA9062AA_BUCK1_CFG, 699 __builtin_ffs((int)DA9062AA_BUCK1_MODE_MASK) - 1, 700 sizeof(unsigned int) * 8 - 701 __builtin_clz((DA9062AA_BUCK1_MODE_MASK)) - 1), 702 .suspend = REG_FIELD(DA9062AA_DVC_1, 703 __builtin_ffs((int)DA9062AA_VBUCK1_SEL_MASK) - 1, 704 sizeof(unsigned int) * 8 - 705 __builtin_clz((DA9062AA_VBUCK1_SEL_MASK)) - 1), 706 .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_C, 707 __builtin_ffs((int)DA9062AA_BUCK1_ILIM_MASK) - 1, 708 sizeof(unsigned int) * 8 - 709 __builtin_clz((DA9062AA_BUCK1_ILIM_MASK)) - 1), 710 }, 711 { 712 .desc.id = DA9062_ID_BUCK2, 713 .desc.name = "DA9062 BUCK2", 714 .desc.of_match = of_match_ptr("buck2"), 715 .desc.regulators_node = of_match_ptr("regulators"), 716 .desc.ops = &da9062_buck_ops, 717 .desc.min_uV = (300) * 1000, 718 .desc.uV_step = (10) * 1000, 719 .desc.n_voltages = ((1570) - (300))/(10) + 1, 720 .current_limits = da9062_buck_a_limits, 721 .n_current_limits = ARRAY_SIZE(da9062_buck_a_limits), 722 .desc.enable_reg = DA9062AA_BUCK2_CONT, 723 .desc.enable_mask = DA9062AA_BUCK2_EN_MASK, 724 .desc.vsel_reg = DA9062AA_VBUCK2_A, 725 .desc.vsel_mask = DA9062AA_VBUCK2_A_MASK, 726 .desc.linear_min_sel = 0, 727 .sleep = REG_FIELD(DA9062AA_VBUCK2_A, 728 __builtin_ffs((int)DA9062AA_BUCK2_SL_A_MASK) - 1, 729 sizeof(unsigned int) * 8 - 730 __builtin_clz((DA9062AA_BUCK2_SL_A_MASK)) - 1), 731 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK2_B, 732 __builtin_ffs((int)DA9062AA_BUCK2_SL_B_MASK) - 1, 733 sizeof(unsigned int) * 8 - 734 __builtin_clz((DA9062AA_BUCK2_SL_B_MASK)) - 1), 735 .suspend_vsel_reg = DA9062AA_VBUCK2_B, 736 .mode = REG_FIELD(DA9062AA_BUCK2_CFG, 737 __builtin_ffs((int)DA9062AA_BUCK2_MODE_MASK) - 1, 738 sizeof(unsigned int) * 8 - 739 __builtin_clz((DA9062AA_BUCK2_MODE_MASK)) - 1), 740 .suspend = REG_FIELD(DA9062AA_DVC_1, 741 __builtin_ffs((int)DA9062AA_VBUCK2_SEL_MASK) - 1, 742 sizeof(unsigned int) * 8 - 743 __builtin_clz((DA9062AA_VBUCK2_SEL_MASK)) - 1), 744 .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_C, 745 __builtin_ffs((int)DA9062AA_BUCK2_ILIM_MASK) - 1, 746 sizeof(unsigned int) * 8 - 747 __builtin_clz((DA9062AA_BUCK2_ILIM_MASK)) - 1), 748 }, 749 { 750 .desc.id = DA9062_ID_BUCK3, 751 .desc.name = "DA9062 BUCK3", 752 .desc.of_match = of_match_ptr("buck3"), 753 .desc.regulators_node = of_match_ptr("regulators"), 754 .desc.ops = &da9062_buck_ops, 755 .desc.min_uV = (800) * 1000, 756 .desc.uV_step = (20) * 1000, 757 .desc.n_voltages = ((3340) - (800))/(20) + 1, 758 .current_limits = da9062_buck_b_limits, 759 .n_current_limits = ARRAY_SIZE(da9062_buck_b_limits), 760 .desc.enable_reg = DA9062AA_BUCK3_CONT, 761 .desc.enable_mask = DA9062AA_BUCK3_EN_MASK, 762 .desc.vsel_reg = DA9062AA_VBUCK3_A, 763 .desc.vsel_mask = DA9062AA_VBUCK3_A_MASK, 764 .desc.linear_min_sel = 0, 765 .sleep = REG_FIELD(DA9062AA_VBUCK3_A, 766 __builtin_ffs((int)DA9062AA_BUCK3_SL_A_MASK) - 1, 767 sizeof(unsigned int) * 8 - 768 __builtin_clz((DA9062AA_BUCK3_SL_A_MASK)) - 1), 769 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK3_B, 770 __builtin_ffs((int)DA9062AA_BUCK3_SL_B_MASK) - 1, 771 sizeof(unsigned int) * 8 - 772 __builtin_clz((DA9062AA_BUCK3_SL_B_MASK)) - 1), 773 .suspend_vsel_reg = DA9062AA_VBUCK3_B, 774 .mode = REG_FIELD(DA9062AA_BUCK3_CFG, 775 __builtin_ffs((int)DA9062AA_BUCK3_MODE_MASK) - 1, 776 sizeof(unsigned int) * 8 - 777 __builtin_clz((DA9062AA_BUCK3_MODE_MASK)) - 1), 778 .suspend = REG_FIELD(DA9062AA_DVC_1, 779 __builtin_ffs((int)DA9062AA_VBUCK3_SEL_MASK) - 1, 780 sizeof(unsigned int) * 8 - 781 __builtin_clz((DA9062AA_VBUCK3_SEL_MASK)) - 1), 782 .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_A, 783 __builtin_ffs((int)DA9062AA_BUCK3_ILIM_MASK) - 1, 784 sizeof(unsigned int) * 8 - 785 __builtin_clz((DA9062AA_BUCK3_ILIM_MASK)) - 1), 786 }, 787 { 788 .desc.id = DA9062_ID_BUCK4, 789 .desc.name = "DA9062 BUCK4", 790 .desc.of_match = of_match_ptr("buck4"), 791 .desc.regulators_node = of_match_ptr("regulators"), 792 .desc.ops = &da9062_buck_ops, 793 .desc.min_uV = (530) * 1000, 794 .desc.uV_step = (10) * 1000, 795 .desc.n_voltages = ((1800) - (530))/(10) + 1, 796 .current_limits = da9062_buck_a_limits, 797 .n_current_limits = ARRAY_SIZE(da9062_buck_a_limits), 798 .desc.enable_reg = DA9062AA_BUCK4_CONT, 799 .desc.enable_mask = DA9062AA_BUCK4_EN_MASK, 800 .desc.vsel_reg = DA9062AA_VBUCK4_A, 801 .desc.vsel_mask = DA9062AA_VBUCK4_A_MASK, 802 .desc.linear_min_sel = 0, 803 .sleep = REG_FIELD(DA9062AA_VBUCK4_A, 804 __builtin_ffs((int)DA9062AA_BUCK4_SL_A_MASK) - 1, 805 sizeof(unsigned int) * 8 - 806 __builtin_clz((DA9062AA_BUCK4_SL_A_MASK)) - 1), 807 .suspend_sleep = REG_FIELD(DA9062AA_VBUCK4_B, 808 __builtin_ffs((int)DA9062AA_BUCK4_SL_B_MASK) - 1, 809 sizeof(unsigned int) * 8 - 810 __builtin_clz((DA9062AA_BUCK4_SL_B_MASK)) - 1), 811 .suspend_vsel_reg = DA9062AA_VBUCK4_B, 812 .mode = REG_FIELD(DA9062AA_BUCK4_CFG, 813 __builtin_ffs((int)DA9062AA_BUCK4_MODE_MASK) - 1, 814 sizeof(unsigned int) * 8 - 815 __builtin_clz((DA9062AA_BUCK4_MODE_MASK)) - 1), 816 .suspend = REG_FIELD(DA9062AA_DVC_1, 817 __builtin_ffs((int)DA9062AA_VBUCK4_SEL_MASK) - 1, 818 sizeof(unsigned int) * 8 - 819 __builtin_clz((DA9062AA_VBUCK4_SEL_MASK)) - 1), 820 .ilimit = REG_FIELD(DA9062AA_BUCK_ILIM_B, 821 __builtin_ffs((int)DA9062AA_BUCK4_ILIM_MASK) - 1, 822 sizeof(unsigned int) * 8 - 823 __builtin_clz((DA9062AA_BUCK4_ILIM_MASK)) - 1), 824 }, 825 { 826 .desc.id = DA9062_ID_LDO1, 827 .desc.name = "DA9062 LDO1", 828 .desc.of_match = of_match_ptr("ldo1"), 829 .desc.regulators_node = of_match_ptr("regulators"), 830 .desc.ops = &da9062_ldo_ops, 831 .desc.min_uV = (900) * 1000, 832 .desc.uV_step = (50) * 1000, 833 .desc.n_voltages = ((3600) - (900))/(50) + 1, 834 .desc.enable_reg = DA9062AA_LDO1_CONT, 835 .desc.enable_mask = DA9062AA_LDO1_EN_MASK, 836 .desc.vsel_reg = DA9062AA_VLDO1_A, 837 .desc.vsel_mask = DA9062AA_VLDO1_A_MASK, 838 .desc.linear_min_sel = 0, 839 .sleep = REG_FIELD(DA9062AA_VLDO1_A, 840 __builtin_ffs((int)DA9062AA_LDO1_SL_A_MASK) - 1, 841 sizeof(unsigned int) * 8 - 842 __builtin_clz((DA9062AA_LDO1_SL_A_MASK)) - 1), 843 .suspend_sleep = REG_FIELD(DA9062AA_VLDO1_B, 844 __builtin_ffs((int)DA9062AA_LDO1_SL_B_MASK) - 1, 845 sizeof(unsigned int) * 8 - 846 __builtin_clz((DA9062AA_LDO1_SL_B_MASK)) - 1), 847 .suspend_vsel_reg = DA9062AA_VLDO1_B, 848 .suspend = REG_FIELD(DA9062AA_DVC_1, 849 __builtin_ffs((int)DA9062AA_VLDO1_SEL_MASK) - 1, 850 sizeof(unsigned int) * 8 - 851 __builtin_clz((DA9062AA_VLDO1_SEL_MASK)) - 1), 852 .oc_event = REG_FIELD(DA9062AA_STATUS_D, 853 __builtin_ffs((int)DA9062AA_LDO1_ILIM_MASK) - 1, 854 sizeof(unsigned int) * 8 - 855 __builtin_clz((DA9062AA_LDO1_ILIM_MASK)) - 1), 856 }, 857 { 858 .desc.id = DA9062_ID_LDO2, 859 .desc.name = "DA9062 LDO2", 860 .desc.of_match = of_match_ptr("ldo2"), 861 .desc.regulators_node = of_match_ptr("regulators"), 862 .desc.ops = &da9062_ldo_ops, 863 .desc.min_uV = (900) * 1000, 864 .desc.uV_step = (50) * 1000, 865 .desc.n_voltages = ((3600) - (600))/(50) + 1, 866 .desc.enable_reg = DA9062AA_LDO2_CONT, 867 .desc.enable_mask = DA9062AA_LDO2_EN_MASK, 868 .desc.vsel_reg = DA9062AA_VLDO2_A, 869 .desc.vsel_mask = DA9062AA_VLDO2_A_MASK, 870 .desc.linear_min_sel = 0, 871 .sleep = REG_FIELD(DA9062AA_VLDO2_A, 872 __builtin_ffs((int)DA9062AA_LDO2_SL_A_MASK) - 1, 873 sizeof(unsigned int) * 8 - 874 __builtin_clz((DA9062AA_LDO2_SL_A_MASK)) - 1), 875 .suspend_sleep = REG_FIELD(DA9062AA_VLDO2_B, 876 __builtin_ffs((int)DA9062AA_LDO2_SL_B_MASK) - 1, 877 sizeof(unsigned int) * 8 - 878 __builtin_clz((DA9062AA_LDO2_SL_B_MASK)) - 1), 879 .suspend_vsel_reg = DA9062AA_VLDO2_B, 880 .suspend = REG_FIELD(DA9062AA_DVC_1, 881 __builtin_ffs((int)DA9062AA_VLDO2_SEL_MASK) - 1, 882 sizeof(unsigned int) * 8 - 883 __builtin_clz((DA9062AA_VLDO2_SEL_MASK)) - 1), 884 .oc_event = REG_FIELD(DA9062AA_STATUS_D, 885 __builtin_ffs((int)DA9062AA_LDO2_ILIM_MASK) - 1, 886 sizeof(unsigned int) * 8 - 887 __builtin_clz((DA9062AA_LDO2_ILIM_MASK)) - 1), 888 }, 889 { 890 .desc.id = DA9062_ID_LDO3, 891 .desc.name = "DA9062 LDO3", 892 .desc.of_match = of_match_ptr("ldo3"), 893 .desc.regulators_node = of_match_ptr("regulators"), 894 .desc.ops = &da9062_ldo_ops, 895 .desc.min_uV = (900) * 1000, 896 .desc.uV_step = (50) * 1000, 897 .desc.n_voltages = ((3600) - (900))/(50) + 1, 898 .desc.enable_reg = DA9062AA_LDO3_CONT, 899 .desc.enable_mask = DA9062AA_LDO3_EN_MASK, 900 .desc.vsel_reg = DA9062AA_VLDO3_A, 901 .desc.vsel_mask = DA9062AA_VLDO3_A_MASK, 902 .desc.linear_min_sel = 0, 903 .sleep = REG_FIELD(DA9062AA_VLDO3_A, 904 __builtin_ffs((int)DA9062AA_LDO3_SL_A_MASK) - 1, 905 sizeof(unsigned int) * 8 - 906 __builtin_clz((DA9062AA_LDO3_SL_A_MASK)) - 1), 907 .suspend_sleep = REG_FIELD(DA9062AA_VLDO3_B, 908 __builtin_ffs((int)DA9062AA_LDO3_SL_B_MASK) - 1, 909 sizeof(unsigned int) * 8 - 910 __builtin_clz((DA9062AA_LDO3_SL_B_MASK)) - 1), 911 .suspend_vsel_reg = DA9062AA_VLDO3_B, 912 .suspend = REG_FIELD(DA9062AA_DVC_1, 913 __builtin_ffs((int)DA9062AA_VLDO3_SEL_MASK) - 1, 914 sizeof(unsigned int) * 8 - 915 __builtin_clz((DA9062AA_VLDO3_SEL_MASK)) - 1), 916 .oc_event = REG_FIELD(DA9062AA_STATUS_D, 917 __builtin_ffs((int)DA9062AA_LDO3_ILIM_MASK) - 1, 918 sizeof(unsigned int) * 8 - 919 __builtin_clz((DA9062AA_LDO3_ILIM_MASK)) - 1), 920 }, 921 { 922 .desc.id = DA9062_ID_LDO4, 923 .desc.name = "DA9062 LDO4", 924 .desc.of_match = of_match_ptr("ldo4"), 925 .desc.regulators_node = of_match_ptr("regulators"), 926 .desc.ops = &da9062_ldo_ops, 927 .desc.min_uV = (900) * 1000, 928 .desc.uV_step = (50) * 1000, 929 .desc.n_voltages = ((3600) - (900))/(50) + 1, 930 .desc.enable_reg = DA9062AA_LDO4_CONT, 931 .desc.enable_mask = DA9062AA_LDO4_EN_MASK, 932 .desc.vsel_reg = DA9062AA_VLDO4_A, 933 .desc.vsel_mask = DA9062AA_VLDO4_A_MASK, 934 .desc.linear_min_sel = 0, 935 .sleep = REG_FIELD(DA9062AA_VLDO4_A, 936 __builtin_ffs((int)DA9062AA_LDO4_SL_A_MASK) - 1, 937 sizeof(unsigned int) * 8 - 938 __builtin_clz((DA9062AA_LDO4_SL_A_MASK)) - 1), 939 .suspend_sleep = REG_FIELD(DA9062AA_VLDO4_B, 940 __builtin_ffs((int)DA9062AA_LDO4_SL_B_MASK) - 1, 941 sizeof(unsigned int) * 8 - 942 __builtin_clz((DA9062AA_LDO4_SL_B_MASK)) - 1), 943 .suspend_vsel_reg = DA9062AA_VLDO4_B, 944 .suspend = REG_FIELD(DA9062AA_DVC_1, 945 __builtin_ffs((int)DA9062AA_VLDO4_SEL_MASK) - 1, 946 sizeof(unsigned int) * 8 - 947 __builtin_clz((DA9062AA_VLDO4_SEL_MASK)) - 1), 948 .oc_event = REG_FIELD(DA9062AA_STATUS_D, 949 __builtin_ffs((int)DA9062AA_LDO4_ILIM_MASK) - 1, 950 sizeof(unsigned int) * 8 - 951 __builtin_clz((DA9062AA_LDO4_ILIM_MASK)) - 1), 952 }, 953 }; 954 955 /* Regulator interrupt handlers */ 956 static irqreturn_t da9062_ldo_lim_event(int irq, void *data) 957 { 958 struct da9062_regulators *regulators = data; 959 struct da9062 *hw = regulators->regulator[0].hw; 960 struct da9062_regulator *regl; 961 int handled = IRQ_NONE; 962 int bits, i, ret; 963 964 ret = regmap_read(hw->regmap, DA9062AA_STATUS_D, &bits); 965 if (ret < 0) { 966 dev_err(hw->dev, 967 "Failed to read LDO overcurrent indicator\n"); 968 goto ldo_lim_error; 969 } 970 971 for (i = regulators->n_regulators - 1; i >= 0; i--) { 972 regl = ®ulators->regulator[i]; 973 if (regl->info->oc_event.reg != DA9062AA_STATUS_D) 974 continue; 975 976 if (BIT(regl->info->oc_event.lsb) & bits) { 977 regulator_notifier_call_chain(regl->rdev, 978 REGULATOR_EVENT_OVER_CURRENT, NULL); 979 handled = IRQ_HANDLED; 980 } 981 } 982 983 ldo_lim_error: 984 return handled; 985 } 986 987 static int da9062_regulator_probe(struct platform_device *pdev) 988 { 989 struct da9062 *chip = dev_get_drvdata(pdev->dev.parent); 990 struct da9062_regulators *regulators; 991 struct da9062_regulator *regl; 992 struct regulator_config config = { }; 993 const struct da9062_regulator_info *rinfo; 994 int irq, n, ret; 995 int max_regulators; 996 997 switch (chip->chip_type) { 998 case COMPAT_TYPE_DA9061: 999 max_regulators = DA9061_MAX_REGULATORS; 1000 rinfo = local_da9061_regulator_info; 1001 break; 1002 case COMPAT_TYPE_DA9062: 1003 max_regulators = DA9062_MAX_REGULATORS; 1004 rinfo = local_da9062_regulator_info; 1005 break; 1006 default: 1007 dev_err(chip->dev, "Unrecognised chip type\n"); 1008 return -ENODEV; 1009 } 1010 1011 /* Allocate memory required by usable regulators */ 1012 regulators = devm_kzalloc(&pdev->dev, struct_size(regulators, regulator, 1013 max_regulators), GFP_KERNEL); 1014 if (!regulators) 1015 return -ENOMEM; 1016 1017 regulators->n_regulators = max_regulators; 1018 platform_set_drvdata(pdev, regulators); 1019 1020 n = 0; 1021 while (n < regulators->n_regulators) { 1022 /* Initialise regulator structure */ 1023 regl = ®ulators->regulator[n]; 1024 regl->hw = chip; 1025 regl->info = &rinfo[n]; 1026 regl->desc = regl->info->desc; 1027 regl->desc.type = REGULATOR_VOLTAGE; 1028 regl->desc.owner = THIS_MODULE; 1029 1030 if (regl->info->mode.reg) { 1031 regl->mode = devm_regmap_field_alloc( 1032 &pdev->dev, 1033 chip->regmap, 1034 regl->info->mode); 1035 if (IS_ERR(regl->mode)) 1036 return PTR_ERR(regl->mode); 1037 } 1038 1039 if (regl->info->suspend.reg) { 1040 regl->suspend = devm_regmap_field_alloc( 1041 &pdev->dev, 1042 chip->regmap, 1043 regl->info->suspend); 1044 if (IS_ERR(regl->suspend)) 1045 return PTR_ERR(regl->suspend); 1046 } 1047 1048 if (regl->info->sleep.reg) { 1049 regl->sleep = devm_regmap_field_alloc( 1050 &pdev->dev, 1051 chip->regmap, 1052 regl->info->sleep); 1053 if (IS_ERR(regl->sleep)) 1054 return PTR_ERR(regl->sleep); 1055 } 1056 1057 if (regl->info->suspend_sleep.reg) { 1058 regl->suspend_sleep = devm_regmap_field_alloc( 1059 &pdev->dev, 1060 chip->regmap, 1061 regl->info->suspend_sleep); 1062 if (IS_ERR(regl->suspend_sleep)) 1063 return PTR_ERR(regl->suspend_sleep); 1064 } 1065 1066 if (regl->info->ilimit.reg) { 1067 regl->ilimit = devm_regmap_field_alloc( 1068 &pdev->dev, 1069 chip->regmap, 1070 regl->info->ilimit); 1071 if (IS_ERR(regl->ilimit)) 1072 return PTR_ERR(regl->ilimit); 1073 } 1074 1075 /* Register regulator */ 1076 memset(&config, 0, sizeof(config)); 1077 config.dev = chip->dev; 1078 config.driver_data = regl; 1079 config.regmap = chip->regmap; 1080 1081 regl->rdev = devm_regulator_register(&pdev->dev, ®l->desc, 1082 &config); 1083 if (IS_ERR(regl->rdev)) { 1084 dev_err(&pdev->dev, 1085 "Failed to register %s regulator\n", 1086 regl->desc.name); 1087 return PTR_ERR(regl->rdev); 1088 } 1089 1090 n++; 1091 } 1092 1093 /* LDOs overcurrent event support */ 1094 irq = platform_get_irq_byname(pdev, "LDO_LIM"); 1095 if (irq < 0) { 1096 dev_err(&pdev->dev, "Failed to get IRQ.\n"); 1097 return irq; 1098 } 1099 regulators->irq_ldo_lim = irq; 1100 1101 ret = devm_request_threaded_irq(&pdev->dev, irq, 1102 NULL, da9062_ldo_lim_event, 1103 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 1104 "LDO_LIM", regulators); 1105 if (ret) { 1106 dev_warn(&pdev->dev, 1107 "Failed to request LDO_LIM IRQ.\n"); 1108 regulators->irq_ldo_lim = -ENXIO; 1109 } 1110 1111 return 0; 1112 } 1113 1114 static struct platform_driver da9062_regulator_driver = { 1115 .driver = { 1116 .name = "da9062-regulators", 1117 }, 1118 .probe = da9062_regulator_probe, 1119 }; 1120 1121 static int __init da9062_regulator_init(void) 1122 { 1123 return platform_driver_register(&da9062_regulator_driver); 1124 } 1125 subsys_initcall(da9062_regulator_init); 1126 1127 static void __exit da9062_regulator_cleanup(void) 1128 { 1129 platform_driver_unregister(&da9062_regulator_driver); 1130 } 1131 module_exit(da9062_regulator_cleanup); 1132 1133 /* Module information */ 1134 MODULE_AUTHOR("S Twiss <stwiss.opensource@diasemi.com>"); 1135 MODULE_DESCRIPTION("REGULATOR device driver for Dialog DA9062 and DA9061"); 1136 MODULE_LICENSE("GPL"); 1137 MODULE_ALIAS("platform:da9062-regulators"); 1138