1 /* 2 * tps65912.c -- TI tps65912 3 * 4 * Copyright 2011 Texas Instruments Inc. 5 * 6 * Author: Margarita Olaya Cabrera <magi@slimlogic.co.uk> 7 * 8 * This program is free software; you can redistribute it and/or modify it 9 * under the terms of the GNU General Public License as published by the 10 * Free Software Foundation; either version 2 of the License, or (at your 11 * option) any later version. 12 * 13 * This driver is based on wm8350 implementation. 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/delay.h> 24 #include <linux/slab.h> 25 #include <linux/gpio.h> 26 #include <linux/mfd/tps65912.h> 27 28 /* DCDC's */ 29 #define TPS65912_REG_DCDC1 0 30 #define TPS65912_REG_DCDC2 1 31 #define TPS65912_REG_DCDC3 2 32 #define TPS65912_REG_DCDC4 3 33 34 /* LDOs */ 35 #define TPS65912_REG_LDO1 4 36 #define TPS65912_REG_LDO2 5 37 #define TPS65912_REG_LDO3 6 38 #define TPS65912_REG_LDO4 7 39 #define TPS65912_REG_LDO5 8 40 #define TPS65912_REG_LDO6 9 41 #define TPS65912_REG_LDO7 10 42 #define TPS65912_REG_LDO8 11 43 #define TPS65912_REG_LDO9 12 44 #define TPS65912_REG_LDO10 13 45 46 /* Number of step-down converters available */ 47 #define TPS65912_NUM_DCDC 4 48 49 /* Number of LDO voltage regulators available */ 50 #define TPS65912_NUM_LDO 10 51 52 /* Number of total regulators available */ 53 #define TPS65912_NUM_REGULATOR (TPS65912_NUM_DCDC + TPS65912_NUM_LDO) 54 55 #define TPS65912_REG_ENABLED 0x80 56 #define OP_SELREG_MASK 0x40 57 #define OP_SELREG_SHIFT 6 58 59 struct tps_info { 60 const char *name; 61 }; 62 63 static struct tps_info tps65912_regs[] = { 64 { 65 .name = "DCDC1", 66 }, 67 { 68 .name = "DCDC2", 69 }, 70 { 71 .name = "DCDC3", 72 }, 73 { 74 .name = "DCDC4", 75 }, 76 { 77 .name = "LDO1", 78 }, 79 { 80 .name = "LDO2", 81 }, 82 { 83 .name = "LDO3", 84 }, 85 { 86 .name = "LDO4", 87 }, 88 { 89 .name = "LDO5", 90 }, 91 { 92 .name = "LDO6", 93 }, 94 { 95 .name = "LDO7", 96 }, 97 { 98 .name = "LDO8", 99 }, 100 { 101 .name = "LDO9", 102 }, 103 { 104 .name = "LDO10", 105 }, 106 }; 107 108 struct tps65912_reg { 109 struct regulator_desc desc[TPS65912_NUM_REGULATOR]; 110 struct tps65912 *mfd; 111 struct regulator_dev *rdev[TPS65912_NUM_REGULATOR]; 112 struct tps_info *info[TPS65912_NUM_REGULATOR]; 113 /* for read/write access */ 114 struct mutex io_lock; 115 int mode; 116 int (*get_ctrl_reg)(int); 117 int dcdc1_range; 118 int dcdc2_range; 119 int dcdc3_range; 120 int dcdc4_range; 121 int pwm_mode_reg; 122 int eco_reg; 123 }; 124 125 static int tps65912_get_range(struct tps65912_reg *pmic, int id) 126 { 127 struct tps65912 *mfd = pmic->mfd; 128 129 if (id > TPS65912_REG_DCDC4) 130 return 0; 131 132 switch (id) { 133 case TPS65912_REG_DCDC1: 134 pmic->dcdc1_range = tps65912_reg_read(mfd, 135 TPS65912_DCDC1_LIMIT); 136 if (pmic->dcdc1_range < 0) 137 return pmic->dcdc1_range; 138 pmic->dcdc1_range = (pmic->dcdc1_range & 139 DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT; 140 return pmic->dcdc1_range; 141 case TPS65912_REG_DCDC2: 142 pmic->dcdc2_range = tps65912_reg_read(mfd, 143 TPS65912_DCDC2_LIMIT); 144 if (pmic->dcdc2_range < 0) 145 return pmic->dcdc2_range; 146 pmic->dcdc2_range = (pmic->dcdc2_range & 147 DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT; 148 return pmic->dcdc2_range; 149 case TPS65912_REG_DCDC3: 150 pmic->dcdc3_range = tps65912_reg_read(mfd, 151 TPS65912_DCDC3_LIMIT); 152 if (pmic->dcdc3_range < 0) 153 return pmic->dcdc3_range; 154 pmic->dcdc3_range = (pmic->dcdc3_range & 155 DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT; 156 return pmic->dcdc3_range; 157 case TPS65912_REG_DCDC4: 158 pmic->dcdc4_range = tps65912_reg_read(mfd, 159 TPS65912_DCDC4_LIMIT); 160 if (pmic->dcdc4_range < 0) 161 return pmic->dcdc4_range; 162 pmic->dcdc4_range = (pmic->dcdc4_range & 163 DCDC_LIMIT_RANGE_MASK) >> DCDC_LIMIT_RANGE_SHIFT; 164 return pmic->dcdc4_range; 165 default: 166 return 0; 167 } 168 } 169 170 static unsigned long tps65912_vsel_to_uv_range0(u8 vsel) 171 { 172 unsigned long uv; 173 174 uv = ((vsel * 12500) + 500000); 175 return uv; 176 } 177 178 static unsigned long tps65912_vsel_to_uv_range1(u8 vsel) 179 { 180 unsigned long uv; 181 182 uv = ((vsel * 12500) + 700000); 183 return uv; 184 } 185 186 static unsigned long tps65912_vsel_to_uv_range2(u8 vsel) 187 { 188 unsigned long uv; 189 190 uv = ((vsel * 25000) + 500000); 191 return uv; 192 } 193 194 static unsigned long tps65912_vsel_to_uv_range3(u8 vsel) 195 { 196 unsigned long uv; 197 198 if (vsel == 0x3f) 199 uv = 3800000; 200 else 201 uv = ((vsel * 50000) + 500000); 202 203 return uv; 204 } 205 206 static unsigned long tps65912_vsel_to_uv_ldo(u8 vsel) 207 { 208 unsigned long uv = 0; 209 210 if (vsel <= 32) 211 uv = ((vsel * 25000) + 800000); 212 else if (vsel > 32 && vsel <= 60) 213 uv = (((vsel - 32) * 50000) + 1600000); 214 else if (vsel > 60) 215 uv = (((vsel - 60) * 100000) + 3000000); 216 217 return uv; 218 } 219 220 static int tps65912_get_ctrl_register(int id) 221 { 222 switch (id) { 223 case TPS65912_REG_DCDC1: 224 return TPS65912_DCDC1_AVS; 225 case TPS65912_REG_DCDC2: 226 return TPS65912_DCDC2_AVS; 227 case TPS65912_REG_DCDC3: 228 return TPS65912_DCDC3_AVS; 229 case TPS65912_REG_DCDC4: 230 return TPS65912_DCDC4_AVS; 231 case TPS65912_REG_LDO1: 232 return TPS65912_LDO1_AVS; 233 case TPS65912_REG_LDO2: 234 return TPS65912_LDO2_AVS; 235 case TPS65912_REG_LDO3: 236 return TPS65912_LDO3_AVS; 237 case TPS65912_REG_LDO4: 238 return TPS65912_LDO4_AVS; 239 case TPS65912_REG_LDO5: 240 return TPS65912_LDO5; 241 case TPS65912_REG_LDO6: 242 return TPS65912_LDO6; 243 case TPS65912_REG_LDO7: 244 return TPS65912_LDO7; 245 case TPS65912_REG_LDO8: 246 return TPS65912_LDO8; 247 case TPS65912_REG_LDO9: 248 return TPS65912_LDO9; 249 case TPS65912_REG_LDO10: 250 return TPS65912_LDO10; 251 default: 252 return -EINVAL; 253 } 254 } 255 256 static int tps65912_get_dcdc_sel_register(struct tps65912_reg *pmic, int id) 257 { 258 struct tps65912 *mfd = pmic->mfd; 259 int opvsel = 0, sr = 0; 260 u8 reg = 0; 261 262 if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_DCDC4) 263 return -EINVAL; 264 265 switch (id) { 266 case TPS65912_REG_DCDC1: 267 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC1_OP); 268 sr = ((opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT); 269 if (sr) 270 reg = TPS65912_DCDC1_AVS; 271 else 272 reg = TPS65912_DCDC1_OP; 273 break; 274 case TPS65912_REG_DCDC2: 275 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC2_OP); 276 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT; 277 if (sr) 278 reg = TPS65912_DCDC2_AVS; 279 else 280 reg = TPS65912_DCDC2_OP; 281 break; 282 case TPS65912_REG_DCDC3: 283 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC3_OP); 284 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT; 285 if (sr) 286 reg = TPS65912_DCDC3_AVS; 287 else 288 reg = TPS65912_DCDC3_OP; 289 break; 290 case TPS65912_REG_DCDC4: 291 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC4_OP); 292 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT; 293 if (sr) 294 reg = TPS65912_DCDC4_AVS; 295 else 296 reg = TPS65912_DCDC4_OP; 297 break; 298 } 299 return reg; 300 } 301 302 static int tps65912_get_ldo_sel_register(struct tps65912_reg *pmic, int id) 303 { 304 struct tps65912 *mfd = pmic->mfd; 305 int opvsel = 0, sr = 0; 306 u8 reg = 0; 307 308 if (id < TPS65912_REG_LDO1 || id > TPS65912_REG_LDO10) 309 return -EINVAL; 310 311 switch (id) { 312 case TPS65912_REG_LDO1: 313 opvsel = tps65912_reg_read(mfd, TPS65912_LDO1_OP); 314 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT; 315 if (sr) 316 reg = TPS65912_LDO1_AVS; 317 else 318 reg = TPS65912_LDO1_OP; 319 break; 320 case TPS65912_REG_LDO2: 321 opvsel = tps65912_reg_read(mfd, TPS65912_LDO2_OP); 322 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT; 323 if (sr) 324 reg = TPS65912_LDO2_AVS; 325 else 326 reg = TPS65912_LDO2_OP; 327 break; 328 case TPS65912_REG_LDO3: 329 opvsel = tps65912_reg_read(mfd, TPS65912_LDO3_OP); 330 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT; 331 if (sr) 332 reg = TPS65912_LDO3_AVS; 333 else 334 reg = TPS65912_LDO3_OP; 335 break; 336 case TPS65912_REG_LDO4: 337 opvsel = tps65912_reg_read(mfd, TPS65912_LDO4_OP); 338 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT; 339 if (sr) 340 reg = TPS65912_LDO4_AVS; 341 else 342 reg = TPS65912_LDO4_OP; 343 break; 344 case TPS65912_REG_LDO5: 345 reg = TPS65912_LDO5; 346 break; 347 case TPS65912_REG_LDO6: 348 reg = TPS65912_LDO6; 349 break; 350 case TPS65912_REG_LDO7: 351 reg = TPS65912_LDO7; 352 break; 353 case TPS65912_REG_LDO8: 354 reg = TPS65912_LDO8; 355 break; 356 case TPS65912_REG_LDO9: 357 reg = TPS65912_LDO9; 358 break; 359 case TPS65912_REG_LDO10: 360 reg = TPS65912_LDO10; 361 break; 362 } 363 364 return reg; 365 } 366 367 static int tps65912_get_mode_regiters(struct tps65912_reg *pmic, int id) 368 { 369 switch (id) { 370 case TPS65912_REG_DCDC1: 371 pmic->pwm_mode_reg = TPS65912_DCDC1_CTRL; 372 pmic->eco_reg = TPS65912_DCDC1_AVS; 373 break; 374 case TPS65912_REG_DCDC2: 375 pmic->pwm_mode_reg = TPS65912_DCDC2_CTRL; 376 pmic->eco_reg = TPS65912_DCDC2_AVS; 377 break; 378 case TPS65912_REG_DCDC3: 379 pmic->pwm_mode_reg = TPS65912_DCDC3_CTRL; 380 pmic->eco_reg = TPS65912_DCDC3_AVS; 381 break; 382 case TPS65912_REG_DCDC4: 383 pmic->pwm_mode_reg = TPS65912_DCDC4_CTRL; 384 pmic->eco_reg = TPS65912_DCDC4_AVS; 385 break; 386 default: 387 return -EINVAL; 388 } 389 390 return 0; 391 } 392 393 static int tps65912_reg_is_enabled(struct regulator_dev *dev) 394 { 395 struct tps65912_reg *pmic = rdev_get_drvdata(dev); 396 struct tps65912 *mfd = pmic->mfd; 397 int reg, value, id = rdev_get_id(dev); 398 399 if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10) 400 return -EINVAL; 401 402 reg = pmic->get_ctrl_reg(id); 403 if (reg < 0) 404 return reg; 405 406 value = tps65912_reg_read(mfd, reg); 407 if (value < 0) 408 return value; 409 410 return value & TPS65912_REG_ENABLED; 411 } 412 413 static int tps65912_reg_enable(struct regulator_dev *dev) 414 { 415 struct tps65912_reg *pmic = rdev_get_drvdata(dev); 416 struct tps65912 *mfd = pmic->mfd; 417 int id = rdev_get_id(dev); 418 int reg; 419 420 if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10) 421 return -EINVAL; 422 423 reg = pmic->get_ctrl_reg(id); 424 if (reg < 0) 425 return reg; 426 427 return tps65912_set_bits(mfd, reg, TPS65912_REG_ENABLED); 428 } 429 430 static int tps65912_reg_disable(struct regulator_dev *dev) 431 { 432 struct tps65912_reg *pmic = rdev_get_drvdata(dev); 433 struct tps65912 *mfd = pmic->mfd; 434 int id = rdev_get_id(dev), reg; 435 436 reg = pmic->get_ctrl_reg(id); 437 if (reg < 0) 438 return reg; 439 440 return tps65912_clear_bits(mfd, reg, TPS65912_REG_ENABLED); 441 } 442 443 static int tps65912_set_mode(struct regulator_dev *dev, unsigned int mode) 444 { 445 struct tps65912_reg *pmic = rdev_get_drvdata(dev); 446 struct tps65912 *mfd = pmic->mfd; 447 int pwm_mode, eco, id = rdev_get_id(dev); 448 449 tps65912_get_mode_regiters(pmic, id); 450 451 pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg); 452 eco = tps65912_reg_read(mfd, pmic->eco_reg); 453 454 pwm_mode &= DCDCCTRL_DCDC_MODE_MASK; 455 eco &= DCDC_AVS_ECO_MASK; 456 457 switch (mode) { 458 case REGULATOR_MODE_FAST: 459 /* Verify if mode alredy set */ 460 if (pwm_mode && !eco) 461 break; 462 tps65912_set_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK); 463 tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK); 464 break; 465 case REGULATOR_MODE_NORMAL: 466 case REGULATOR_MODE_IDLE: 467 if (!pwm_mode && !eco) 468 break; 469 tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK); 470 tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK); 471 break; 472 case REGULATOR_MODE_STANDBY: 473 if (!pwm_mode && eco) 474 break; 475 tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK); 476 tps65912_set_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK); 477 break; 478 default: 479 return -EINVAL; 480 } 481 482 return 0; 483 } 484 485 static unsigned int tps65912_get_mode(struct regulator_dev *dev) 486 { 487 struct tps65912_reg *pmic = rdev_get_drvdata(dev); 488 struct tps65912 *mfd = pmic->mfd; 489 int pwm_mode, eco, mode = 0, id = rdev_get_id(dev); 490 491 tps65912_get_mode_regiters(pmic, id); 492 493 pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg); 494 eco = tps65912_reg_read(mfd, pmic->eco_reg); 495 496 pwm_mode &= DCDCCTRL_DCDC_MODE_MASK; 497 eco &= DCDC_AVS_ECO_MASK; 498 499 if (pwm_mode && !eco) 500 mode = REGULATOR_MODE_FAST; 501 else if (!pwm_mode && !eco) 502 mode = REGULATOR_MODE_NORMAL; 503 else if (!pwm_mode && eco) 504 mode = REGULATOR_MODE_STANDBY; 505 506 return mode; 507 } 508 509 static int tps65912_get_voltage_dcdc(struct regulator_dev *dev) 510 { 511 struct tps65912_reg *pmic = rdev_get_drvdata(dev); 512 struct tps65912 *mfd = pmic->mfd; 513 int id = rdev_get_id(dev), voltage = 0, range; 514 int opvsel = 0, avsel = 0, sr, vsel; 515 516 switch (id) { 517 case TPS65912_REG_DCDC1: 518 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC1_OP); 519 avsel = tps65912_reg_read(mfd, TPS65912_DCDC1_AVS); 520 range = pmic->dcdc1_range; 521 break; 522 case TPS65912_REG_DCDC2: 523 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC2_OP); 524 avsel = tps65912_reg_read(mfd, TPS65912_DCDC2_AVS); 525 range = pmic->dcdc2_range; 526 break; 527 case TPS65912_REG_DCDC3: 528 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC3_OP); 529 avsel = tps65912_reg_read(mfd, TPS65912_DCDC3_AVS); 530 range = pmic->dcdc3_range; 531 break; 532 case TPS65912_REG_DCDC4: 533 opvsel = tps65912_reg_read(mfd, TPS65912_DCDC4_OP); 534 avsel = tps65912_reg_read(mfd, TPS65912_DCDC4_AVS); 535 range = pmic->dcdc4_range; 536 break; 537 default: 538 return -EINVAL; 539 } 540 541 sr = (opvsel & OP_SELREG_MASK) >> OP_SELREG_SHIFT; 542 if (sr) 543 vsel = avsel; 544 else 545 vsel = opvsel; 546 vsel &= 0x3F; 547 548 switch (range) { 549 case 0: 550 /* 0.5 - 1.2875V in 12.5mV steps */ 551 voltage = tps65912_vsel_to_uv_range0(vsel); 552 break; 553 case 1: 554 /* 0.7 - 1.4875V in 12.5mV steps */ 555 voltage = tps65912_vsel_to_uv_range1(vsel); 556 break; 557 case 2: 558 /* 0.5 - 2.075V in 25mV steps */ 559 voltage = tps65912_vsel_to_uv_range2(vsel); 560 break; 561 case 3: 562 /* 0.5 - 3.8V in 50mV steps */ 563 voltage = tps65912_vsel_to_uv_range3(vsel); 564 break; 565 } 566 return voltage; 567 } 568 569 static int tps65912_set_voltage_dcdc(struct regulator_dev *dev, 570 unsigned selector) 571 { 572 struct tps65912_reg *pmic = rdev_get_drvdata(dev); 573 struct tps65912 *mfd = pmic->mfd; 574 int id = rdev_get_id(dev); 575 int value; 576 u8 reg; 577 578 reg = tps65912_get_dcdc_sel_register(pmic, id); 579 value = tps65912_reg_read(mfd, reg); 580 value &= 0xC0; 581 return tps65912_reg_write(mfd, reg, selector | value); 582 } 583 584 static int tps65912_get_voltage_ldo(struct regulator_dev *dev) 585 { 586 struct tps65912_reg *pmic = rdev_get_drvdata(dev); 587 struct tps65912 *mfd = pmic->mfd; 588 int id = rdev_get_id(dev); 589 int vsel = 0; 590 u8 reg; 591 592 reg = tps65912_get_ldo_sel_register(pmic, id); 593 vsel = tps65912_reg_read(mfd, reg); 594 vsel &= 0x3F; 595 596 return tps65912_vsel_to_uv_ldo(vsel); 597 } 598 599 static int tps65912_set_voltage_ldo(struct regulator_dev *dev, 600 unsigned selector) 601 { 602 struct tps65912_reg *pmic = rdev_get_drvdata(dev); 603 struct tps65912 *mfd = pmic->mfd; 604 int id = rdev_get_id(dev), reg, value; 605 606 reg = tps65912_get_ldo_sel_register(pmic, id); 607 value = tps65912_reg_read(mfd, reg); 608 value &= 0xC0; 609 return tps65912_reg_write(mfd, reg, selector | value); 610 } 611 612 static int tps65912_list_voltage_dcdc(struct regulator_dev *dev, 613 unsigned selector) 614 { 615 struct tps65912_reg *pmic = rdev_get_drvdata(dev); 616 int range, voltage = 0, id = rdev_get_id(dev); 617 618 switch (id) { 619 case TPS65912_REG_DCDC1: 620 range = pmic->dcdc1_range; 621 break; 622 case TPS65912_REG_DCDC2: 623 range = pmic->dcdc2_range; 624 break; 625 case TPS65912_REG_DCDC3: 626 range = pmic->dcdc3_range; 627 break; 628 case TPS65912_REG_DCDC4: 629 range = pmic->dcdc4_range; 630 break; 631 default: 632 return -EINVAL; 633 } 634 635 switch (range) { 636 case 0: 637 /* 0.5 - 1.2875V in 12.5mV steps */ 638 voltage = tps65912_vsel_to_uv_range0(selector); 639 break; 640 case 1: 641 /* 0.7 - 1.4875V in 12.5mV steps */ 642 voltage = tps65912_vsel_to_uv_range1(selector); 643 break; 644 case 2: 645 /* 0.5 - 2.075V in 25mV steps */ 646 voltage = tps65912_vsel_to_uv_range2(selector); 647 break; 648 case 3: 649 /* 0.5 - 3.8V in 50mV steps */ 650 voltage = tps65912_vsel_to_uv_range3(selector); 651 break; 652 } 653 return voltage; 654 } 655 656 static int tps65912_list_voltage_ldo(struct regulator_dev *dev, 657 unsigned selector) 658 { 659 int ldo = rdev_get_id(dev); 660 661 if (ldo < TPS65912_REG_LDO1 || ldo > TPS65912_REG_LDO10) 662 return -EINVAL; 663 664 return tps65912_vsel_to_uv_ldo(selector); 665 } 666 667 /* Operations permitted on DCDCx */ 668 static struct regulator_ops tps65912_ops_dcdc = { 669 .is_enabled = tps65912_reg_is_enabled, 670 .enable = tps65912_reg_enable, 671 .disable = tps65912_reg_disable, 672 .set_mode = tps65912_set_mode, 673 .get_mode = tps65912_get_mode, 674 .get_voltage = tps65912_get_voltage_dcdc, 675 .set_voltage_sel = tps65912_set_voltage_dcdc, 676 .list_voltage = tps65912_list_voltage_dcdc, 677 }; 678 679 /* Operations permitted on LDOx */ 680 static struct regulator_ops tps65912_ops_ldo = { 681 .is_enabled = tps65912_reg_is_enabled, 682 .enable = tps65912_reg_enable, 683 .disable = tps65912_reg_disable, 684 .get_voltage = tps65912_get_voltage_ldo, 685 .set_voltage_sel = tps65912_set_voltage_ldo, 686 .list_voltage = tps65912_list_voltage_ldo, 687 }; 688 689 static __devinit int tps65912_probe(struct platform_device *pdev) 690 { 691 struct tps65912 *tps65912 = dev_get_drvdata(pdev->dev.parent); 692 struct tps_info *info; 693 struct regulator_init_data *reg_data; 694 struct regulator_dev *rdev; 695 struct tps65912_reg *pmic; 696 struct tps65912_board *pmic_plat_data; 697 int i, err; 698 699 pmic_plat_data = dev_get_platdata(tps65912->dev); 700 if (!pmic_plat_data) 701 return -EINVAL; 702 703 reg_data = pmic_plat_data->tps65912_pmic_init_data; 704 705 pmic = kzalloc(sizeof(*pmic), GFP_KERNEL); 706 if (!pmic) 707 return -ENOMEM; 708 709 mutex_init(&pmic->io_lock); 710 pmic->mfd = tps65912; 711 platform_set_drvdata(pdev, pmic); 712 713 pmic->get_ctrl_reg = &tps65912_get_ctrl_register; 714 info = tps65912_regs; 715 716 for (i = 0; i < TPS65912_NUM_REGULATOR; i++, info++, reg_data++) { 717 int range = 0; 718 /* Register the regulators */ 719 pmic->info[i] = info; 720 721 pmic->desc[i].name = info->name; 722 pmic->desc[i].id = i; 723 pmic->desc[i].n_voltages = 64; 724 pmic->desc[i].ops = (i > TPS65912_REG_DCDC4 ? 725 &tps65912_ops_ldo : &tps65912_ops_dcdc); 726 pmic->desc[i].type = REGULATOR_VOLTAGE; 727 pmic->desc[i].owner = THIS_MODULE; 728 range = tps65912_get_range(pmic, i); 729 rdev = regulator_register(&pmic->desc[i], 730 tps65912->dev, reg_data, pmic); 731 if (IS_ERR(rdev)) { 732 dev_err(tps65912->dev, 733 "failed to register %s regulator\n", 734 pdev->name); 735 err = PTR_ERR(rdev); 736 goto err; 737 } 738 739 /* Save regulator for cleanup */ 740 pmic->rdev[i] = rdev; 741 } 742 return 0; 743 744 err: 745 while (--i >= 0) 746 regulator_unregister(pmic->rdev[i]); 747 748 kfree(pmic); 749 return err; 750 } 751 752 static int __devexit tps65912_remove(struct platform_device *pdev) 753 { 754 struct tps65912_reg *tps65912_reg = platform_get_drvdata(pdev); 755 int i; 756 757 for (i = 0; i < TPS65912_NUM_REGULATOR; i++) 758 regulator_unregister(tps65912_reg->rdev[i]); 759 760 kfree(tps65912_reg); 761 return 0; 762 } 763 764 static struct platform_driver tps65912_driver = { 765 .driver = { 766 .name = "tps65912-pmic", 767 .owner = THIS_MODULE, 768 }, 769 .probe = tps65912_probe, 770 .remove = __devexit_p(tps65912_remove), 771 }; 772 773 /** 774 * tps65912_init 775 * 776 * Module init function 777 */ 778 static int __init tps65912_init(void) 779 { 780 return platform_driver_register(&tps65912_driver); 781 } 782 subsys_initcall(tps65912_init); 783 784 /** 785 * tps65912_cleanup 786 * 787 * Module exit function 788 */ 789 static void __exit tps65912_cleanup(void) 790 { 791 platform_driver_unregister(&tps65912_driver); 792 } 793 module_exit(tps65912_cleanup); 794 795 MODULE_AUTHOR("Margarita Olaya Cabrera <magi@slimlogic.co.uk>"); 796 MODULE_DESCRIPTION("TPS65912 voltage regulator driver"); 797 MODULE_LICENSE("GPL v2"); 798 MODULE_ALIAS("platform:tps65912-pmic"); 799