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