1 /* 2 * Driver for Regulator part of Palmas PMIC Chips 3 * 4 * Copyright 2011-2012 Texas Instruments Inc. 5 * 6 * Author: Graeme Gregory <gg@slimlogic.co.uk> 7 * Author: Ian Lartey <ian@slimlogic.co.uk> 8 * 9 * This program is free software; you can redistribute it and/or modify it 10 * under the terms of the GNU General Public License as published by the 11 * Free Software Foundation; either version 2 of the License, or (at your 12 * option) any later version. 13 * 14 */ 15 16 #include <linux/kernel.h> 17 #include <linux/module.h> 18 #include <linux/init.h> 19 #include <linux/err.h> 20 #include <linux/platform_device.h> 21 #include <linux/regulator/driver.h> 22 #include <linux/regulator/machine.h> 23 #include <linux/slab.h> 24 #include <linux/regmap.h> 25 #include <linux/mfd/palmas.h> 26 #include <linux/of.h> 27 #include <linux/of_platform.h> 28 #include <linux/regulator/of_regulator.h> 29 30 struct regs_info { 31 char *name; 32 u8 vsel_addr; 33 u8 ctrl_addr; 34 u8 tstep_addr; 35 }; 36 37 static const struct regs_info palmas_regs_info[] = { 38 { 39 .name = "SMPS12", 40 .vsel_addr = PALMAS_SMPS12_VOLTAGE, 41 .ctrl_addr = PALMAS_SMPS12_CTRL, 42 .tstep_addr = PALMAS_SMPS12_TSTEP, 43 }, 44 { 45 .name = "SMPS123", 46 .vsel_addr = PALMAS_SMPS12_VOLTAGE, 47 .ctrl_addr = PALMAS_SMPS12_CTRL, 48 .tstep_addr = PALMAS_SMPS12_TSTEP, 49 }, 50 { 51 .name = "SMPS3", 52 .vsel_addr = PALMAS_SMPS3_VOLTAGE, 53 .ctrl_addr = PALMAS_SMPS3_CTRL, 54 }, 55 { 56 .name = "SMPS45", 57 .vsel_addr = PALMAS_SMPS45_VOLTAGE, 58 .ctrl_addr = PALMAS_SMPS45_CTRL, 59 .tstep_addr = PALMAS_SMPS45_TSTEP, 60 }, 61 { 62 .name = "SMPS457", 63 .vsel_addr = PALMAS_SMPS45_VOLTAGE, 64 .ctrl_addr = PALMAS_SMPS45_CTRL, 65 .tstep_addr = PALMAS_SMPS45_TSTEP, 66 }, 67 { 68 .name = "SMPS6", 69 .vsel_addr = PALMAS_SMPS6_VOLTAGE, 70 .ctrl_addr = PALMAS_SMPS6_CTRL, 71 .tstep_addr = PALMAS_SMPS6_TSTEP, 72 }, 73 { 74 .name = "SMPS7", 75 .vsel_addr = PALMAS_SMPS7_VOLTAGE, 76 .ctrl_addr = PALMAS_SMPS7_CTRL, 77 }, 78 { 79 .name = "SMPS8", 80 .vsel_addr = PALMAS_SMPS8_VOLTAGE, 81 .ctrl_addr = PALMAS_SMPS8_CTRL, 82 .tstep_addr = PALMAS_SMPS8_TSTEP, 83 }, 84 { 85 .name = "SMPS9", 86 .vsel_addr = PALMAS_SMPS9_VOLTAGE, 87 .ctrl_addr = PALMAS_SMPS9_CTRL, 88 }, 89 { 90 .name = "SMPS10", 91 }, 92 { 93 .name = "LDO1", 94 .vsel_addr = PALMAS_LDO1_VOLTAGE, 95 .ctrl_addr = PALMAS_LDO1_CTRL, 96 }, 97 { 98 .name = "LDO2", 99 .vsel_addr = PALMAS_LDO2_VOLTAGE, 100 .ctrl_addr = PALMAS_LDO2_CTRL, 101 }, 102 { 103 .name = "LDO3", 104 .vsel_addr = PALMAS_LDO3_VOLTAGE, 105 .ctrl_addr = PALMAS_LDO3_CTRL, 106 }, 107 { 108 .name = "LDO4", 109 .vsel_addr = PALMAS_LDO4_VOLTAGE, 110 .ctrl_addr = PALMAS_LDO4_CTRL, 111 }, 112 { 113 .name = "LDO5", 114 .vsel_addr = PALMAS_LDO5_VOLTAGE, 115 .ctrl_addr = PALMAS_LDO5_CTRL, 116 }, 117 { 118 .name = "LDO6", 119 .vsel_addr = PALMAS_LDO6_VOLTAGE, 120 .ctrl_addr = PALMAS_LDO6_CTRL, 121 }, 122 { 123 .name = "LDO7", 124 .vsel_addr = PALMAS_LDO7_VOLTAGE, 125 .ctrl_addr = PALMAS_LDO7_CTRL, 126 }, 127 { 128 .name = "LDO8", 129 .vsel_addr = PALMAS_LDO8_VOLTAGE, 130 .ctrl_addr = PALMAS_LDO8_CTRL, 131 }, 132 { 133 .name = "LDO9", 134 .vsel_addr = PALMAS_LDO9_VOLTAGE, 135 .ctrl_addr = PALMAS_LDO9_CTRL, 136 }, 137 { 138 .name = "LDOLN", 139 .vsel_addr = PALMAS_LDOLN_VOLTAGE, 140 .ctrl_addr = PALMAS_LDOLN_CTRL, 141 }, 142 { 143 .name = "LDOUSB", 144 .vsel_addr = PALMAS_LDOUSB_VOLTAGE, 145 .ctrl_addr = PALMAS_LDOUSB_CTRL, 146 }, 147 }; 148 149 #define SMPS_CTRL_MODE_OFF 0x00 150 #define SMPS_CTRL_MODE_ON 0x01 151 #define SMPS_CTRL_MODE_ECO 0x02 152 #define SMPS_CTRL_MODE_PWM 0x03 153 154 /* These values are derived from the data sheet. And are the number of steps 155 * where there is a voltage change, the ranges at beginning and end of register 156 * max/min values where there are no change are ommitted. 157 * 158 * So they are basically (maxV-minV)/stepV 159 */ 160 #define PALMAS_SMPS_NUM_VOLTAGES 117 161 #define PALMAS_SMPS10_NUM_VOLTAGES 2 162 #define PALMAS_LDO_NUM_VOLTAGES 50 163 164 #define SMPS10_VSEL (1<<3) 165 #define SMPS10_BOOST_EN (1<<2) 166 #define SMPS10_BYPASS_EN (1<<1) 167 #define SMPS10_SWITCH_EN (1<<0) 168 169 #define REGULATOR_SLAVE 0 170 171 static int palmas_smps_read(struct palmas *palmas, unsigned int reg, 172 unsigned int *dest) 173 { 174 unsigned int addr; 175 176 addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg); 177 178 return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest); 179 } 180 181 static int palmas_smps_write(struct palmas *palmas, unsigned int reg, 182 unsigned int value) 183 { 184 unsigned int addr; 185 186 addr = PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, reg); 187 188 return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value); 189 } 190 191 static int palmas_ldo_read(struct palmas *palmas, unsigned int reg, 192 unsigned int *dest) 193 { 194 unsigned int addr; 195 196 addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg); 197 198 return regmap_read(palmas->regmap[REGULATOR_SLAVE], addr, dest); 199 } 200 201 static int palmas_ldo_write(struct palmas *palmas, unsigned int reg, 202 unsigned int value) 203 { 204 unsigned int addr; 205 206 addr = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, reg); 207 208 return regmap_write(palmas->regmap[REGULATOR_SLAVE], addr, value); 209 } 210 211 static int palmas_is_enabled_smps(struct regulator_dev *dev) 212 { 213 struct palmas_pmic *pmic = rdev_get_drvdata(dev); 214 int id = rdev_get_id(dev); 215 unsigned int reg; 216 217 palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, ®); 218 219 reg &= PALMAS_SMPS12_CTRL_STATUS_MASK; 220 reg >>= PALMAS_SMPS12_CTRL_STATUS_SHIFT; 221 222 return !!(reg); 223 } 224 225 static int palmas_enable_smps(struct regulator_dev *dev) 226 { 227 struct palmas_pmic *pmic = rdev_get_drvdata(dev); 228 int id = rdev_get_id(dev); 229 unsigned int reg; 230 231 palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, ®); 232 233 reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK; 234 reg |= SMPS_CTRL_MODE_ON; 235 236 palmas_smps_write(pmic->palmas, palmas_regs_info[id].ctrl_addr, reg); 237 238 return 0; 239 } 240 241 static int palmas_disable_smps(struct regulator_dev *dev) 242 { 243 struct palmas_pmic *pmic = rdev_get_drvdata(dev); 244 int id = rdev_get_id(dev); 245 unsigned int reg; 246 247 palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, ®); 248 249 reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK; 250 251 palmas_smps_write(pmic->palmas, palmas_regs_info[id].ctrl_addr, reg); 252 253 return 0; 254 } 255 256 257 static int palmas_set_mode_smps(struct regulator_dev *dev, unsigned int mode) 258 { 259 struct palmas_pmic *pmic = rdev_get_drvdata(dev); 260 int id = rdev_get_id(dev); 261 unsigned int reg; 262 263 palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, ®); 264 reg &= ~PALMAS_SMPS12_CTRL_MODE_ACTIVE_MASK; 265 266 switch (mode) { 267 case REGULATOR_MODE_NORMAL: 268 reg |= SMPS_CTRL_MODE_ON; 269 break; 270 case REGULATOR_MODE_IDLE: 271 reg |= SMPS_CTRL_MODE_ECO; 272 break; 273 case REGULATOR_MODE_FAST: 274 reg |= SMPS_CTRL_MODE_PWM; 275 break; 276 default: 277 return -EINVAL; 278 } 279 palmas_smps_write(pmic->palmas, palmas_regs_info[id].ctrl_addr, reg); 280 281 return 0; 282 } 283 284 static unsigned int palmas_get_mode_smps(struct regulator_dev *dev) 285 { 286 struct palmas_pmic *pmic = rdev_get_drvdata(dev); 287 int id = rdev_get_id(dev); 288 unsigned int reg; 289 290 palmas_smps_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, ®); 291 reg &= PALMAS_SMPS12_CTRL_STATUS_MASK; 292 reg >>= PALMAS_SMPS12_CTRL_STATUS_SHIFT; 293 294 switch (reg) { 295 case SMPS_CTRL_MODE_ON: 296 return REGULATOR_MODE_NORMAL; 297 case SMPS_CTRL_MODE_ECO: 298 return REGULATOR_MODE_IDLE; 299 case SMPS_CTRL_MODE_PWM: 300 return REGULATOR_MODE_FAST; 301 } 302 303 return 0; 304 } 305 306 static int palmas_list_voltage_smps(struct regulator_dev *dev, 307 unsigned selector) 308 { 309 struct palmas_pmic *pmic = rdev_get_drvdata(dev); 310 int id = rdev_get_id(dev); 311 int mult = 1; 312 313 /* Read the multiplier set in VSEL register to return 314 * the correct voltage. 315 */ 316 if (pmic->range[id]) 317 mult = 2; 318 319 if (selector == 0) 320 return 0; 321 else if (selector < 6) 322 return 500000 * mult; 323 else 324 /* Voltage is linear mapping starting from selector 6, 325 * volt = (0.49V + ((selector - 5) * 0.01V)) * RANGE 326 * RANGE is either x1 or x2 327 */ 328 return (490000 + ((selector - 5) * 10000)) * mult; 329 } 330 331 static int palmas_map_voltage_smps(struct regulator_dev *rdev, 332 int min_uV, int max_uV) 333 { 334 struct palmas_pmic *pmic = rdev_get_drvdata(rdev); 335 int id = rdev_get_id(rdev); 336 int ret, voltage; 337 338 if (min_uV == 0) 339 return 0; 340 341 if (pmic->range[id]) { /* RANGE is x2 */ 342 if (min_uV < 1000000) 343 min_uV = 1000000; 344 ret = DIV_ROUND_UP(min_uV - 1000000, 20000) + 6; 345 } else { /* RANGE is x1 */ 346 if (min_uV < 500000) 347 min_uV = 500000; 348 ret = DIV_ROUND_UP(min_uV - 500000, 10000) + 6; 349 } 350 351 /* Map back into a voltage to verify we're still in bounds */ 352 voltage = palmas_list_voltage_smps(rdev, ret); 353 if (voltage < min_uV || voltage > max_uV) 354 return -EINVAL; 355 356 return ret; 357 } 358 359 static struct regulator_ops palmas_ops_smps = { 360 .is_enabled = palmas_is_enabled_smps, 361 .enable = palmas_enable_smps, 362 .disable = palmas_disable_smps, 363 .set_mode = palmas_set_mode_smps, 364 .get_mode = palmas_get_mode_smps, 365 .get_voltage_sel = regulator_get_voltage_sel_regmap, 366 .set_voltage_sel = regulator_set_voltage_sel_regmap, 367 .list_voltage = palmas_list_voltage_smps, 368 .map_voltage = palmas_map_voltage_smps, 369 }; 370 371 static struct regulator_ops palmas_ops_smps10 = { 372 .is_enabled = regulator_is_enabled_regmap, 373 .enable = regulator_enable_regmap, 374 .disable = regulator_disable_regmap, 375 .get_voltage_sel = regulator_get_voltage_sel_regmap, 376 .set_voltage_sel = regulator_set_voltage_sel_regmap, 377 .list_voltage = regulator_list_voltage_linear, 378 .map_voltage = regulator_map_voltage_linear, 379 }; 380 381 static int palmas_is_enabled_ldo(struct regulator_dev *dev) 382 { 383 struct palmas_pmic *pmic = rdev_get_drvdata(dev); 384 int id = rdev_get_id(dev); 385 unsigned int reg; 386 387 palmas_ldo_read(pmic->palmas, palmas_regs_info[id].ctrl_addr, ®); 388 389 reg &= PALMAS_LDO1_CTRL_STATUS; 390 391 return !!(reg); 392 } 393 394 static struct regulator_ops palmas_ops_ldo = { 395 .is_enabled = palmas_is_enabled_ldo, 396 .enable = regulator_enable_regmap, 397 .disable = regulator_disable_regmap, 398 .get_voltage_sel = regulator_get_voltage_sel_regmap, 399 .set_voltage_sel = regulator_set_voltage_sel_regmap, 400 .list_voltage = regulator_list_voltage_linear, 401 .map_voltage = regulator_map_voltage_linear, 402 }; 403 404 /* 405 * setup the hardware based sleep configuration of the SMPS/LDO regulators 406 * from the platform data. This is different to the software based control 407 * supported by the regulator framework as it is controlled by toggling 408 * pins on the PMIC such as PREQ, SYSEN, ... 409 */ 410 static int palmas_smps_init(struct palmas *palmas, int id, 411 struct palmas_reg_init *reg_init) 412 { 413 unsigned int reg; 414 unsigned int addr; 415 int ret; 416 417 addr = palmas_regs_info[id].ctrl_addr; 418 419 ret = palmas_smps_read(palmas, addr, ®); 420 if (ret) 421 return ret; 422 423 switch (id) { 424 case PALMAS_REG_SMPS10: 425 if (reg_init->mode_sleep) { 426 reg &= ~PALMAS_SMPS10_CTRL_MODE_SLEEP_MASK; 427 reg |= reg_init->mode_sleep << 428 PALMAS_SMPS10_CTRL_MODE_SLEEP_SHIFT; 429 } 430 break; 431 default: 432 if (reg_init->warm_reset) 433 reg |= PALMAS_SMPS12_CTRL_WR_S; 434 435 if (reg_init->roof_floor) 436 reg |= PALMAS_SMPS12_CTRL_ROOF_FLOOR_EN; 437 438 if (reg_init->mode_sleep) { 439 reg &= ~PALMAS_SMPS12_CTRL_MODE_SLEEP_MASK; 440 reg |= reg_init->mode_sleep << 441 PALMAS_SMPS12_CTRL_MODE_SLEEP_SHIFT; 442 } 443 } 444 445 ret = palmas_smps_write(palmas, addr, reg); 446 if (ret) 447 return ret; 448 449 if (palmas_regs_info[id].tstep_addr && reg_init->tstep) { 450 addr = palmas_regs_info[id].tstep_addr; 451 452 reg = reg_init->tstep & PALMAS_SMPS12_TSTEP_TSTEP_MASK; 453 454 ret = palmas_smps_write(palmas, addr, reg); 455 if (ret) 456 return ret; 457 } 458 459 if (palmas_regs_info[id].vsel_addr && reg_init->vsel) { 460 addr = palmas_regs_info[id].vsel_addr; 461 462 reg = reg_init->vsel; 463 464 ret = palmas_smps_write(palmas, addr, reg); 465 if (ret) 466 return ret; 467 } 468 469 470 return 0; 471 } 472 473 static int palmas_ldo_init(struct palmas *palmas, int id, 474 struct palmas_reg_init *reg_init) 475 { 476 unsigned int reg; 477 unsigned int addr; 478 int ret; 479 480 addr = palmas_regs_info[id].ctrl_addr; 481 482 ret = palmas_ldo_read(palmas, addr, ®); 483 if (ret) 484 return ret; 485 486 if (reg_init->warm_reset) 487 reg |= PALMAS_LDO1_CTRL_WR_S; 488 489 if (reg_init->mode_sleep) 490 reg |= PALMAS_LDO1_CTRL_MODE_SLEEP; 491 492 ret = palmas_ldo_write(palmas, addr, reg); 493 if (ret) 494 return ret; 495 496 return 0; 497 } 498 499 static struct of_regulator_match palmas_matches[] = { 500 { .name = "smps12", }, 501 { .name = "smps123", }, 502 { .name = "smps3", }, 503 { .name = "smps45", }, 504 { .name = "smps457", }, 505 { .name = "smps6", }, 506 { .name = "smps7", }, 507 { .name = "smps8", }, 508 { .name = "smps9", }, 509 { .name = "smps10", }, 510 { .name = "ldo1", }, 511 { .name = "ldo2", }, 512 { .name = "ldo3", }, 513 { .name = "ldo4", }, 514 { .name = "ldo5", }, 515 { .name = "ldo6", }, 516 { .name = "ldo7", }, 517 { .name = "ldo8", }, 518 { .name = "ldo9", }, 519 { .name = "ldoln", }, 520 { .name = "ldousb", }, 521 }; 522 523 static void palmas_dt_to_pdata(struct device *dev, 524 struct device_node *node, 525 struct palmas_pmic_platform_data *pdata) 526 { 527 struct device_node *regulators; 528 u32 prop; 529 int idx, ret; 530 531 node = of_node_get(node); 532 regulators = of_find_node_by_name(node, "regulators"); 533 if (!regulators) { 534 dev_info(dev, "regulator node not found\n"); 535 return; 536 } 537 538 ret = of_regulator_match(dev, regulators, palmas_matches, 539 PALMAS_NUM_REGS); 540 of_node_put(regulators); 541 if (ret < 0) { 542 dev_err(dev, "Error parsing regulator init data: %d\n", ret); 543 return; 544 } 545 546 for (idx = 0; idx < PALMAS_NUM_REGS; idx++) { 547 if (!palmas_matches[idx].init_data || 548 !palmas_matches[idx].of_node) 549 continue; 550 551 pdata->reg_data[idx] = palmas_matches[idx].init_data; 552 553 pdata->reg_init[idx] = devm_kzalloc(dev, 554 sizeof(struct palmas_reg_init), GFP_KERNEL); 555 556 ret = of_property_read_u32(palmas_matches[idx].of_node, 557 "ti,warm_reset", &prop); 558 if (!ret) 559 pdata->reg_init[idx]->warm_reset = prop; 560 561 ret = of_property_read_u32(palmas_matches[idx].of_node, 562 "ti,roof_floor", &prop); 563 if (!ret) 564 pdata->reg_init[idx]->roof_floor = prop; 565 566 ret = of_property_read_u32(palmas_matches[idx].of_node, 567 "ti,mode_sleep", &prop); 568 if (!ret) 569 pdata->reg_init[idx]->mode_sleep = prop; 570 571 ret = of_property_read_u32(palmas_matches[idx].of_node, 572 "ti,tstep", &prop); 573 if (!ret) 574 pdata->reg_init[idx]->tstep = prop; 575 576 ret = of_property_read_u32(palmas_matches[idx].of_node, 577 "ti,vsel", &prop); 578 if (!ret) 579 pdata->reg_init[idx]->vsel = prop; 580 } 581 582 ret = of_property_read_u32(node, "ti,ldo6_vibrator", &prop); 583 if (!ret) 584 pdata->ldo6_vibrator = prop; 585 } 586 587 588 static int palmas_probe(struct platform_device *pdev) 589 { 590 struct palmas *palmas = dev_get_drvdata(pdev->dev.parent); 591 struct palmas_pmic_platform_data *pdata = pdev->dev.platform_data; 592 struct device_node *node = pdev->dev.of_node; 593 struct regulator_dev *rdev; 594 struct regulator_config config = { }; 595 struct palmas_pmic *pmic; 596 struct palmas_reg_init *reg_init; 597 int id = 0, ret; 598 unsigned int addr, reg; 599 600 if (node && !pdata) { 601 pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL); 602 603 if (!pdata) 604 return -ENOMEM; 605 606 palmas_dt_to_pdata(&pdev->dev, node, pdata); 607 } 608 609 pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL); 610 if (!pmic) 611 return -ENOMEM; 612 613 pmic->dev = &pdev->dev; 614 pmic->palmas = palmas; 615 palmas->pmic = pmic; 616 platform_set_drvdata(pdev, pmic); 617 618 ret = palmas_smps_read(palmas, PALMAS_SMPS_CTRL, ®); 619 if (ret) 620 return ret; 621 622 if (reg & PALMAS_SMPS_CTRL_SMPS12_SMPS123_EN) 623 pmic->smps123 = 1; 624 625 if (reg & PALMAS_SMPS_CTRL_SMPS45_SMPS457_EN) 626 pmic->smps457 = 1; 627 628 config.regmap = palmas->regmap[REGULATOR_SLAVE]; 629 config.dev = &pdev->dev; 630 config.driver_data = pmic; 631 632 for (id = 0; id < PALMAS_REG_LDO1; id++) { 633 634 /* 635 * Miss out regulators which are not available due 636 * to slaving configurations. 637 */ 638 switch (id) { 639 case PALMAS_REG_SMPS12: 640 case PALMAS_REG_SMPS3: 641 if (pmic->smps123) 642 continue; 643 break; 644 case PALMAS_REG_SMPS123: 645 if (!pmic->smps123) 646 continue; 647 break; 648 case PALMAS_REG_SMPS45: 649 case PALMAS_REG_SMPS7: 650 if (pmic->smps457) 651 continue; 652 break; 653 case PALMAS_REG_SMPS457: 654 if (!pmic->smps457) 655 continue; 656 } 657 658 /* Initialise sleep/init values from platform data */ 659 if (pdata && pdata->reg_init[id]) { 660 reg_init = pdata->reg_init[id]; 661 ret = palmas_smps_init(palmas, id, reg_init); 662 if (ret) 663 goto err_unregister_regulator; 664 } 665 666 /* Register the regulators */ 667 pmic->desc[id].name = palmas_regs_info[id].name; 668 pmic->desc[id].id = id; 669 670 switch (id) { 671 case PALMAS_REG_SMPS10: 672 pmic->desc[id].n_voltages = PALMAS_SMPS10_NUM_VOLTAGES; 673 pmic->desc[id].ops = &palmas_ops_smps10; 674 pmic->desc[id].vsel_reg = 675 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, 676 PALMAS_SMPS10_CTRL); 677 pmic->desc[id].vsel_mask = SMPS10_VSEL; 678 pmic->desc[id].enable_reg = 679 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, 680 PALMAS_SMPS10_STATUS); 681 pmic->desc[id].enable_mask = SMPS10_BOOST_EN; 682 pmic->desc[id].min_uV = 3750000; 683 pmic->desc[id].uV_step = 1250000; 684 break; 685 default: 686 /* 687 * Read and store the RANGE bit for later use 688 * This must be done before regulator is probed, 689 * otherwise we error in probe with unsupportable ranges. 690 */ 691 addr = palmas_regs_info[id].vsel_addr; 692 693 ret = palmas_smps_read(pmic->palmas, addr, ®); 694 if (ret) 695 goto err_unregister_regulator; 696 if (reg & PALMAS_SMPS12_VOLTAGE_RANGE) 697 pmic->range[id] = 1; 698 699 pmic->desc[id].ops = &palmas_ops_smps; 700 pmic->desc[id].n_voltages = PALMAS_SMPS_NUM_VOLTAGES; 701 pmic->desc[id].vsel_reg = 702 PALMAS_BASE_TO_REG(PALMAS_SMPS_BASE, 703 palmas_regs_info[id].vsel_addr); 704 pmic->desc[id].vsel_mask = 705 PALMAS_SMPS12_VOLTAGE_VSEL_MASK; 706 } 707 708 pmic->desc[id].type = REGULATOR_VOLTAGE; 709 pmic->desc[id].owner = THIS_MODULE; 710 711 if (pdata) 712 config.init_data = pdata->reg_data[id]; 713 else 714 config.init_data = NULL; 715 716 config.of_node = palmas_matches[id].of_node; 717 718 rdev = regulator_register(&pmic->desc[id], &config); 719 if (IS_ERR(rdev)) { 720 dev_err(&pdev->dev, 721 "failed to register %s regulator\n", 722 pdev->name); 723 ret = PTR_ERR(rdev); 724 goto err_unregister_regulator; 725 } 726 727 /* Save regulator for cleanup */ 728 pmic->rdev[id] = rdev; 729 } 730 731 /* Start this loop from the id left from previous loop */ 732 for (; id < PALMAS_NUM_REGS; id++) { 733 734 /* Miss out regulators which are not available due 735 * to alternate functions. 736 */ 737 738 /* Register the regulators */ 739 pmic->desc[id].name = palmas_regs_info[id].name; 740 pmic->desc[id].id = id; 741 pmic->desc[id].n_voltages = PALMAS_LDO_NUM_VOLTAGES; 742 743 pmic->desc[id].ops = &palmas_ops_ldo; 744 745 pmic->desc[id].type = REGULATOR_VOLTAGE; 746 pmic->desc[id].owner = THIS_MODULE; 747 pmic->desc[id].min_uV = 900000; 748 pmic->desc[id].uV_step = 50000; 749 pmic->desc[id].linear_min_sel = 1; 750 pmic->desc[id].vsel_reg = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, 751 palmas_regs_info[id].vsel_addr); 752 pmic->desc[id].vsel_mask = PALMAS_LDO1_VOLTAGE_VSEL_MASK; 753 pmic->desc[id].enable_reg = PALMAS_BASE_TO_REG(PALMAS_LDO_BASE, 754 palmas_regs_info[id].ctrl_addr); 755 pmic->desc[id].enable_mask = PALMAS_LDO1_CTRL_MODE_ACTIVE; 756 757 if (pdata) 758 config.init_data = pdata->reg_data[id]; 759 else 760 config.init_data = NULL; 761 762 config.of_node = palmas_matches[id].of_node; 763 764 rdev = regulator_register(&pmic->desc[id], &config); 765 if (IS_ERR(rdev)) { 766 dev_err(&pdev->dev, 767 "failed to register %s regulator\n", 768 pdev->name); 769 ret = PTR_ERR(rdev); 770 goto err_unregister_regulator; 771 } 772 773 /* Save regulator for cleanup */ 774 pmic->rdev[id] = rdev; 775 776 /* Initialise sleep/init values from platform data */ 777 if (pdata) { 778 reg_init = pdata->reg_init[id]; 779 if (reg_init) { 780 ret = palmas_ldo_init(palmas, id, reg_init); 781 if (ret) { 782 regulator_unregister(pmic->rdev[id]); 783 goto err_unregister_regulator; 784 } 785 } 786 } 787 } 788 789 return 0; 790 791 err_unregister_regulator: 792 while (--id >= 0) 793 regulator_unregister(pmic->rdev[id]); 794 return ret; 795 } 796 797 static int palmas_remove(struct platform_device *pdev) 798 { 799 struct palmas_pmic *pmic = platform_get_drvdata(pdev); 800 int id; 801 802 for (id = 0; id < PALMAS_NUM_REGS; id++) 803 regulator_unregister(pmic->rdev[id]); 804 return 0; 805 } 806 807 static struct of_device_id of_palmas_match_tbl[] = { 808 { .compatible = "ti,palmas-pmic", }, 809 { /* end */ } 810 }; 811 812 static struct platform_driver palmas_driver = { 813 .driver = { 814 .name = "palmas-pmic", 815 .of_match_table = of_palmas_match_tbl, 816 .owner = THIS_MODULE, 817 }, 818 .probe = palmas_probe, 819 .remove = palmas_remove, 820 }; 821 822 static int __init palmas_init(void) 823 { 824 return platform_driver_register(&palmas_driver); 825 } 826 subsys_initcall(palmas_init); 827 828 static void __exit palmas_exit(void) 829 { 830 platform_driver_unregister(&palmas_driver); 831 } 832 module_exit(palmas_exit); 833 834 MODULE_AUTHOR("Graeme Gregory <gg@slimlogic.co.uk>"); 835 MODULE_DESCRIPTION("Palmas voltage regulator driver"); 836 MODULE_LICENSE("GPL"); 837 MODULE_ALIAS("platform:palmas-pmic"); 838 MODULE_DEVICE_TABLE(of, of_palmas_match_tbl); 839