1 /* 2 * twl-regulator.c -- support regulators in twl4030/twl6030 family chips 3 * 4 * Copyright (C) 2008 David Brownell 5 * 6 * This program is free software; you can redistribute it and/or modify 7 * it under the terms of the GNU General Public License as published by 8 * the Free Software Foundation; either version 2 of the License, or 9 * (at your option) any later version. 10 */ 11 12 #include <linux/module.h> 13 #include <linux/init.h> 14 #include <linux/err.h> 15 #include <linux/delay.h> 16 #include <linux/platform_device.h> 17 #include <linux/regulator/driver.h> 18 #include <linux/regulator/machine.h> 19 #include <linux/i2c/twl.h> 20 21 22 /* 23 * The TWL4030/TW5030/TPS659x0/TWL6030 family chips include power management, a 24 * USB OTG transceiver, an RTC, ADC, PWM, and lots more. Some versions 25 * include an audio codec, battery charger, and more voltage regulators. 26 * These chips are often used in OMAP-based systems. 27 * 28 * This driver implements software-based resource control for various 29 * voltage regulators. This is usually augmented with state machine 30 * based control. 31 */ 32 33 struct twlreg_info { 34 /* start of regulator's PM_RECEIVER control register bank */ 35 u8 base; 36 37 /* twl resource ID, for resource control state machine */ 38 u8 id; 39 40 /* voltage in mV = table[VSEL]; table_len must be a power-of-two */ 41 u8 table_len; 42 const u16 *table; 43 44 /* regulator specific turn-on delay */ 45 u16 delay; 46 47 /* State REMAP default configuration */ 48 u8 remap; 49 50 /* chip constraints on regulator behavior */ 51 u16 min_mV; 52 u16 max_mV; 53 54 u8 flags; 55 56 /* used by regulator core */ 57 struct regulator_desc desc; 58 59 /* chip specific features */ 60 unsigned long features; 61 }; 62 63 64 /* LDO control registers ... offset is from the base of its register bank. 65 * The first three registers of all power resource banks help hardware to 66 * manage the various resource groups. 67 */ 68 /* Common offset in TWL4030/6030 */ 69 #define VREG_GRP 0 70 /* TWL4030 register offsets */ 71 #define VREG_TYPE 1 72 #define VREG_REMAP 2 73 #define VREG_DEDICATED 3 /* LDO control */ 74 /* TWL6030 register offsets */ 75 #define VREG_TRANS 1 76 #define VREG_STATE 2 77 #define VREG_VOLTAGE 3 78 #define VREG_VOLTAGE_SMPS 4 79 /* TWL6030 Misc register offsets */ 80 #define VREG_BC_ALL 1 81 #define VREG_BC_REF 2 82 #define VREG_BC_PROC 3 83 #define VREG_BC_CLK_RST 4 84 85 /* TWL6030 LDO register values for CFG_STATE */ 86 #define TWL6030_CFG_STATE_OFF 0x00 87 #define TWL6030_CFG_STATE_ON 0x01 88 #define TWL6030_CFG_STATE_OFF2 0x02 89 #define TWL6030_CFG_STATE_SLEEP 0x03 90 #define TWL6030_CFG_STATE_GRP_SHIFT 5 91 #define TWL6030_CFG_STATE_APP_SHIFT 2 92 #define TWL6030_CFG_STATE_APP_MASK (0x03 << TWL6030_CFG_STATE_APP_SHIFT) 93 #define TWL6030_CFG_STATE_APP(v) (((v) & TWL6030_CFG_STATE_APP_MASK) >>\ 94 TWL6030_CFG_STATE_APP_SHIFT) 95 96 /* Flags for SMPS Voltage reading */ 97 #define SMPS_OFFSET_EN BIT(0) 98 #define SMPS_EXTENDED_EN BIT(1) 99 100 /* twl6025 SMPS EPROM values */ 101 #define TWL6030_SMPS_OFFSET 0xB0 102 #define TWL6030_SMPS_MULT 0xB3 103 #define SMPS_MULTOFFSET_SMPS4 BIT(0) 104 #define SMPS_MULTOFFSET_VIO BIT(1) 105 #define SMPS_MULTOFFSET_SMPS3 BIT(6) 106 107 static inline int 108 twlreg_read(struct twlreg_info *info, unsigned slave_subgp, unsigned offset) 109 { 110 u8 value; 111 int status; 112 113 status = twl_i2c_read_u8(slave_subgp, 114 &value, info->base + offset); 115 return (status < 0) ? status : value; 116 } 117 118 static inline int 119 twlreg_write(struct twlreg_info *info, unsigned slave_subgp, unsigned offset, 120 u8 value) 121 { 122 return twl_i2c_write_u8(slave_subgp, 123 value, info->base + offset); 124 } 125 126 /*----------------------------------------------------------------------*/ 127 128 /* generic power resource operations, which work on all regulators */ 129 130 static int twlreg_grp(struct regulator_dev *rdev) 131 { 132 return twlreg_read(rdev_get_drvdata(rdev), TWL_MODULE_PM_RECEIVER, 133 VREG_GRP); 134 } 135 136 /* 137 * Enable/disable regulators by joining/leaving the P1 (processor) group. 138 * We assume nobody else is updating the DEV_GRP registers. 139 */ 140 /* definition for 4030 family */ 141 #define P3_GRP_4030 BIT(7) /* "peripherals" */ 142 #define P2_GRP_4030 BIT(6) /* secondary processor, modem, etc */ 143 #define P1_GRP_4030 BIT(5) /* CPU/Linux */ 144 /* definition for 6030 family */ 145 #define P3_GRP_6030 BIT(2) /* secondary processor, modem, etc */ 146 #define P2_GRP_6030 BIT(1) /* "peripherals" */ 147 #define P1_GRP_6030 BIT(0) /* CPU/Linux */ 148 149 static int twl4030reg_is_enabled(struct regulator_dev *rdev) 150 { 151 int state = twlreg_grp(rdev); 152 153 if (state < 0) 154 return state; 155 156 return state & P1_GRP_4030; 157 } 158 159 static int twl6030reg_is_enabled(struct regulator_dev *rdev) 160 { 161 struct twlreg_info *info = rdev_get_drvdata(rdev); 162 int grp = 0, val; 163 164 if (!(twl_class_is_6030() && (info->features & TWL6025_SUBCLASS))) 165 grp = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_GRP); 166 if (grp < 0) 167 return grp; 168 169 if (!(twl_class_is_6030() && (info->features & TWL6025_SUBCLASS))) 170 grp &= P1_GRP_6030; 171 else 172 grp = 1; 173 174 val = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_STATE); 175 val = TWL6030_CFG_STATE_APP(val); 176 177 return grp && (val == TWL6030_CFG_STATE_ON); 178 } 179 180 static int twl4030reg_enable(struct regulator_dev *rdev) 181 { 182 struct twlreg_info *info = rdev_get_drvdata(rdev); 183 int grp; 184 int ret; 185 186 grp = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_GRP); 187 if (grp < 0) 188 return grp; 189 190 grp |= P1_GRP_4030; 191 192 ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_GRP, grp); 193 194 udelay(info->delay); 195 196 return ret; 197 } 198 199 static int twl6030reg_enable(struct regulator_dev *rdev) 200 { 201 struct twlreg_info *info = rdev_get_drvdata(rdev); 202 int grp = 0; 203 int ret; 204 205 if (!(twl_class_is_6030() && (info->features & TWL6025_SUBCLASS))) 206 grp = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_GRP); 207 if (grp < 0) 208 return grp; 209 210 ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE, 211 grp << TWL6030_CFG_STATE_GRP_SHIFT | 212 TWL6030_CFG_STATE_ON); 213 214 udelay(info->delay); 215 216 return ret; 217 } 218 219 static int twl4030reg_disable(struct regulator_dev *rdev) 220 { 221 struct twlreg_info *info = rdev_get_drvdata(rdev); 222 int grp; 223 int ret; 224 225 grp = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_GRP); 226 if (grp < 0) 227 return grp; 228 229 grp &= ~(P1_GRP_4030 | P2_GRP_4030 | P3_GRP_4030); 230 231 ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_GRP, grp); 232 233 return ret; 234 } 235 236 static int twl6030reg_disable(struct regulator_dev *rdev) 237 { 238 struct twlreg_info *info = rdev_get_drvdata(rdev); 239 int grp = 0; 240 int ret; 241 242 if (!(twl_class_is_6030() && (info->features & TWL6025_SUBCLASS))) 243 grp = P1_GRP_6030 | P2_GRP_6030 | P3_GRP_6030; 244 245 /* For 6030, set the off state for all grps enabled */ 246 ret = twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE, 247 (grp) << TWL6030_CFG_STATE_GRP_SHIFT | 248 TWL6030_CFG_STATE_OFF); 249 250 return ret; 251 } 252 253 static int twl4030reg_get_status(struct regulator_dev *rdev) 254 { 255 int state = twlreg_grp(rdev); 256 257 if (state < 0) 258 return state; 259 state &= 0x0f; 260 261 /* assume state != WARM_RESET; we'd not be running... */ 262 if (!state) 263 return REGULATOR_STATUS_OFF; 264 return (state & BIT(3)) 265 ? REGULATOR_STATUS_NORMAL 266 : REGULATOR_STATUS_STANDBY; 267 } 268 269 static int twl6030reg_get_status(struct regulator_dev *rdev) 270 { 271 struct twlreg_info *info = rdev_get_drvdata(rdev); 272 int val; 273 274 val = twlreg_grp(rdev); 275 if (val < 0) 276 return val; 277 278 val = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_STATE); 279 280 switch (TWL6030_CFG_STATE_APP(val)) { 281 case TWL6030_CFG_STATE_ON: 282 return REGULATOR_STATUS_NORMAL; 283 284 case TWL6030_CFG_STATE_SLEEP: 285 return REGULATOR_STATUS_STANDBY; 286 287 case TWL6030_CFG_STATE_OFF: 288 case TWL6030_CFG_STATE_OFF2: 289 default: 290 break; 291 } 292 293 return REGULATOR_STATUS_OFF; 294 } 295 296 static int twl4030reg_set_mode(struct regulator_dev *rdev, unsigned mode) 297 { 298 struct twlreg_info *info = rdev_get_drvdata(rdev); 299 unsigned message; 300 int status; 301 302 /* We can only set the mode through state machine commands... */ 303 switch (mode) { 304 case REGULATOR_MODE_NORMAL: 305 message = MSG_SINGULAR(DEV_GRP_P1, info->id, RES_STATE_ACTIVE); 306 break; 307 case REGULATOR_MODE_STANDBY: 308 message = MSG_SINGULAR(DEV_GRP_P1, info->id, RES_STATE_SLEEP); 309 break; 310 default: 311 return -EINVAL; 312 } 313 314 /* Ensure the resource is associated with some group */ 315 status = twlreg_grp(rdev); 316 if (status < 0) 317 return status; 318 if (!(status & (P3_GRP_4030 | P2_GRP_4030 | P1_GRP_4030))) 319 return -EACCES; 320 321 status = twl_i2c_write_u8(TWL_MODULE_PM_MASTER, 322 message >> 8, TWL4030_PM_MASTER_PB_WORD_MSB); 323 if (status < 0) 324 return status; 325 326 return twl_i2c_write_u8(TWL_MODULE_PM_MASTER, 327 message & 0xff, TWL4030_PM_MASTER_PB_WORD_LSB); 328 } 329 330 static int twl6030reg_set_mode(struct regulator_dev *rdev, unsigned mode) 331 { 332 struct twlreg_info *info = rdev_get_drvdata(rdev); 333 int grp = 0; 334 int val; 335 336 if (!(twl_class_is_6030() && (info->features & TWL6025_SUBCLASS))) 337 grp = twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_GRP); 338 339 if (grp < 0) 340 return grp; 341 342 /* Compose the state register settings */ 343 val = grp << TWL6030_CFG_STATE_GRP_SHIFT; 344 /* We can only set the mode through state machine commands... */ 345 switch (mode) { 346 case REGULATOR_MODE_NORMAL: 347 val |= TWL6030_CFG_STATE_ON; 348 break; 349 case REGULATOR_MODE_STANDBY: 350 val |= TWL6030_CFG_STATE_SLEEP; 351 break; 352 353 default: 354 return -EINVAL; 355 } 356 357 return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_STATE, val); 358 } 359 360 /*----------------------------------------------------------------------*/ 361 362 /* 363 * Support for adjustable-voltage LDOs uses a four bit (or less) voltage 364 * select field in its control register. We use tables indexed by VSEL 365 * to record voltages in milliVolts. (Accuracy is about three percent.) 366 * 367 * Note that VSEL values for VAUX2 changed in twl5030 and newer silicon; 368 * currently handled by listing two slightly different VAUX2 regulators, 369 * only one of which will be configured. 370 * 371 * VSEL values documented as "TI cannot support these values" are flagged 372 * in these tables as UNSUP() values; we normally won't assign them. 373 * 374 * VAUX3 at 3V is incorrectly listed in some TI manuals as unsupported. 375 * TI are revising the twl5030/tps659x0 specs to support that 3.0V setting. 376 */ 377 #ifdef CONFIG_TWL4030_ALLOW_UNSUPPORTED 378 #define UNSUP_MASK 0x0000 379 #else 380 #define UNSUP_MASK 0x8000 381 #endif 382 383 #define UNSUP(x) (UNSUP_MASK | (x)) 384 #define IS_UNSUP(x) (UNSUP_MASK & (x)) 385 #define LDO_MV(x) (~UNSUP_MASK & (x)) 386 387 388 static const u16 VAUX1_VSEL_table[] = { 389 UNSUP(1500), UNSUP(1800), 2500, 2800, 390 3000, 3000, 3000, 3000, 391 }; 392 static const u16 VAUX2_4030_VSEL_table[] = { 393 UNSUP(1000), UNSUP(1000), UNSUP(1200), 1300, 394 1500, 1800, UNSUP(1850), 2500, 395 UNSUP(2600), 2800, UNSUP(2850), UNSUP(3000), 396 UNSUP(3150), UNSUP(3150), UNSUP(3150), UNSUP(3150), 397 }; 398 static const u16 VAUX2_VSEL_table[] = { 399 1700, 1700, 1900, 1300, 400 1500, 1800, 2000, 2500, 401 2100, 2800, 2200, 2300, 402 2400, 2400, 2400, 2400, 403 }; 404 static const u16 VAUX3_VSEL_table[] = { 405 1500, 1800, 2500, 2800, 406 3000, 3000, 3000, 3000, 407 }; 408 static const u16 VAUX4_VSEL_table[] = { 409 700, 1000, 1200, UNSUP(1300), 410 1500, 1800, UNSUP(1850), 2500, 411 UNSUP(2600), 2800, UNSUP(2850), UNSUP(3000), 412 UNSUP(3150), UNSUP(3150), UNSUP(3150), UNSUP(3150), 413 }; 414 static const u16 VMMC1_VSEL_table[] = { 415 1850, 2850, 3000, 3150, 416 }; 417 static const u16 VMMC2_VSEL_table[] = { 418 UNSUP(1000), UNSUP(1000), UNSUP(1200), UNSUP(1300), 419 UNSUP(1500), UNSUP(1800), 1850, UNSUP(2500), 420 2600, 2800, 2850, 3000, 421 3150, 3150, 3150, 3150, 422 }; 423 static const u16 VPLL1_VSEL_table[] = { 424 1000, 1200, 1300, 1800, 425 UNSUP(2800), UNSUP(3000), UNSUP(3000), UNSUP(3000), 426 }; 427 static const u16 VPLL2_VSEL_table[] = { 428 700, 1000, 1200, 1300, 429 UNSUP(1500), 1800, UNSUP(1850), UNSUP(2500), 430 UNSUP(2600), UNSUP(2800), UNSUP(2850), UNSUP(3000), 431 UNSUP(3150), UNSUP(3150), UNSUP(3150), UNSUP(3150), 432 }; 433 static const u16 VSIM_VSEL_table[] = { 434 UNSUP(1000), UNSUP(1200), UNSUP(1300), 1800, 435 2800, 3000, 3000, 3000, 436 }; 437 static const u16 VDAC_VSEL_table[] = { 438 1200, 1300, 1800, 1800, 439 }; 440 static const u16 VDD1_VSEL_table[] = { 441 800, 1450, 442 }; 443 static const u16 VDD2_VSEL_table[] = { 444 800, 1450, 1500, 445 }; 446 static const u16 VIO_VSEL_table[] = { 447 1800, 1850, 448 }; 449 static const u16 VINTANA2_VSEL_table[] = { 450 2500, 2750, 451 }; 452 453 static int twl4030ldo_list_voltage(struct regulator_dev *rdev, unsigned index) 454 { 455 struct twlreg_info *info = rdev_get_drvdata(rdev); 456 int mV = info->table[index]; 457 458 return IS_UNSUP(mV) ? 0 : (LDO_MV(mV) * 1000); 459 } 460 461 static int 462 twl4030ldo_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV, 463 unsigned *selector) 464 { 465 struct twlreg_info *info = rdev_get_drvdata(rdev); 466 int vsel; 467 468 for (vsel = 0; vsel < info->table_len; vsel++) { 469 int mV = info->table[vsel]; 470 int uV; 471 472 if (IS_UNSUP(mV)) 473 continue; 474 uV = LDO_MV(mV) * 1000; 475 476 /* REVISIT for VAUX2, first match may not be best/lowest */ 477 478 /* use the first in-range value */ 479 if (min_uV <= uV && uV <= max_uV) { 480 *selector = vsel; 481 return twlreg_write(info, TWL_MODULE_PM_RECEIVER, 482 VREG_VOLTAGE, vsel); 483 } 484 } 485 486 return -EDOM; 487 } 488 489 static int twl4030ldo_get_voltage(struct regulator_dev *rdev) 490 { 491 struct twlreg_info *info = rdev_get_drvdata(rdev); 492 int vsel = twlreg_read(info, TWL_MODULE_PM_RECEIVER, 493 VREG_VOLTAGE); 494 495 if (vsel < 0) 496 return vsel; 497 498 vsel &= info->table_len - 1; 499 return LDO_MV(info->table[vsel]) * 1000; 500 } 501 502 static struct regulator_ops twl4030ldo_ops = { 503 .list_voltage = twl4030ldo_list_voltage, 504 505 .set_voltage = twl4030ldo_set_voltage, 506 .get_voltage = twl4030ldo_get_voltage, 507 508 .enable = twl4030reg_enable, 509 .disable = twl4030reg_disable, 510 .is_enabled = twl4030reg_is_enabled, 511 512 .set_mode = twl4030reg_set_mode, 513 514 .get_status = twl4030reg_get_status, 515 }; 516 517 static int twl6030ldo_list_voltage(struct regulator_dev *rdev, unsigned index) 518 { 519 struct twlreg_info *info = rdev_get_drvdata(rdev); 520 521 return ((info->min_mV + (index * 100)) * 1000); 522 } 523 524 static int 525 twl6030ldo_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV, 526 unsigned *selector) 527 { 528 struct twlreg_info *info = rdev_get_drvdata(rdev); 529 int vsel; 530 531 if ((min_uV/1000 < info->min_mV) || (max_uV/1000 > info->max_mV)) 532 return -EDOM; 533 534 /* 535 * Use the below formula to calculate vsel 536 * mV = 1000mv + 100mv * (vsel - 1) 537 */ 538 vsel = (min_uV/1000 - 1000)/100 + 1; 539 *selector = vsel; 540 return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE, vsel); 541 542 } 543 544 static int twl6030ldo_get_voltage(struct regulator_dev *rdev) 545 { 546 struct twlreg_info *info = rdev_get_drvdata(rdev); 547 int vsel = twlreg_read(info, TWL_MODULE_PM_RECEIVER, 548 VREG_VOLTAGE); 549 550 if (vsel < 0) 551 return vsel; 552 553 /* 554 * Use the below formula to calculate vsel 555 * mV = 1000mv + 100mv * (vsel - 1) 556 */ 557 return (1000 + (100 * (vsel - 1))) * 1000; 558 } 559 560 static struct regulator_ops twl6030ldo_ops = { 561 .list_voltage = twl6030ldo_list_voltage, 562 563 .set_voltage = twl6030ldo_set_voltage, 564 .get_voltage = twl6030ldo_get_voltage, 565 566 .enable = twl6030reg_enable, 567 .disable = twl6030reg_disable, 568 .is_enabled = twl6030reg_is_enabled, 569 570 .set_mode = twl6030reg_set_mode, 571 572 .get_status = twl6030reg_get_status, 573 }; 574 575 /*----------------------------------------------------------------------*/ 576 577 /* 578 * Fixed voltage LDOs don't have a VSEL field to update. 579 */ 580 static int twlfixed_list_voltage(struct regulator_dev *rdev, unsigned index) 581 { 582 struct twlreg_info *info = rdev_get_drvdata(rdev); 583 584 return info->min_mV * 1000; 585 } 586 587 static int twlfixed_get_voltage(struct regulator_dev *rdev) 588 { 589 struct twlreg_info *info = rdev_get_drvdata(rdev); 590 591 return info->min_mV * 1000; 592 } 593 594 static struct regulator_ops twl4030fixed_ops = { 595 .list_voltage = twlfixed_list_voltage, 596 597 .get_voltage = twlfixed_get_voltage, 598 599 .enable = twl4030reg_enable, 600 .disable = twl4030reg_disable, 601 .is_enabled = twl4030reg_is_enabled, 602 603 .set_mode = twl4030reg_set_mode, 604 605 .get_status = twl4030reg_get_status, 606 }; 607 608 static struct regulator_ops twl6030fixed_ops = { 609 .list_voltage = twlfixed_list_voltage, 610 611 .get_voltage = twlfixed_get_voltage, 612 613 .enable = twl6030reg_enable, 614 .disable = twl6030reg_disable, 615 .is_enabled = twl6030reg_is_enabled, 616 617 .set_mode = twl6030reg_set_mode, 618 619 .get_status = twl6030reg_get_status, 620 }; 621 622 static struct regulator_ops twl6030_fixed_resource = { 623 .enable = twl6030reg_enable, 624 .disable = twl6030reg_disable, 625 .is_enabled = twl6030reg_is_enabled, 626 .get_status = twl6030reg_get_status, 627 }; 628 629 /* 630 * SMPS status and control 631 */ 632 633 static int twl6030smps_list_voltage(struct regulator_dev *rdev, unsigned index) 634 { 635 struct twlreg_info *info = rdev_get_drvdata(rdev); 636 637 int voltage = 0; 638 639 switch (info->flags) { 640 case SMPS_OFFSET_EN: 641 voltage = 100000; 642 /* fall through */ 643 case 0: 644 switch (index) { 645 case 0: 646 voltage = 0; 647 break; 648 case 58: 649 voltage = 1350 * 1000; 650 break; 651 case 59: 652 voltage = 1500 * 1000; 653 break; 654 case 60: 655 voltage = 1800 * 1000; 656 break; 657 case 61: 658 voltage = 1900 * 1000; 659 break; 660 case 62: 661 voltage = 2100 * 1000; 662 break; 663 default: 664 voltage += (600000 + (12500 * (index - 1))); 665 } 666 break; 667 case SMPS_EXTENDED_EN: 668 switch (index) { 669 case 0: 670 voltage = 0; 671 break; 672 case 58: 673 voltage = 2084 * 1000; 674 break; 675 case 59: 676 voltage = 2315 * 1000; 677 break; 678 case 60: 679 voltage = 2778 * 1000; 680 break; 681 case 61: 682 voltage = 2932 * 1000; 683 break; 684 case 62: 685 voltage = 3241 * 1000; 686 break; 687 default: 688 voltage = (1852000 + (38600 * (index - 1))); 689 } 690 break; 691 case SMPS_OFFSET_EN | SMPS_EXTENDED_EN: 692 switch (index) { 693 case 0: 694 voltage = 0; 695 break; 696 case 58: 697 voltage = 4167 * 1000; 698 break; 699 case 59: 700 voltage = 2315 * 1000; 701 break; 702 case 60: 703 voltage = 2778 * 1000; 704 break; 705 case 61: 706 voltage = 2932 * 1000; 707 break; 708 case 62: 709 voltage = 3241 * 1000; 710 break; 711 default: 712 voltage = (2161000 + (38600 * (index - 1))); 713 } 714 break; 715 } 716 717 return voltage; 718 } 719 720 static int 721 twl6030smps_set_voltage(struct regulator_dev *rdev, int min_uV, int max_uV, 722 unsigned int *selector) 723 { 724 struct twlreg_info *info = rdev_get_drvdata(rdev); 725 int vsel = 0; 726 727 switch (info->flags) { 728 case 0: 729 if (min_uV == 0) 730 vsel = 0; 731 else if ((min_uV >= 600000) && (max_uV <= 1300000)) { 732 vsel = (min_uV - 600000) / 125; 733 if (vsel % 100) 734 vsel += 100; 735 vsel /= 100; 736 vsel++; 737 } 738 /* Values 1..57 for vsel are linear and can be calculated 739 * values 58..62 are non linear. 740 */ 741 else if ((min_uV > 1900000) && (max_uV >= 2100000)) 742 vsel = 62; 743 else if ((min_uV > 1800000) && (max_uV >= 1900000)) 744 vsel = 61; 745 else if ((min_uV > 1500000) && (max_uV >= 1800000)) 746 vsel = 60; 747 else if ((min_uV > 1350000) && (max_uV >= 1500000)) 748 vsel = 59; 749 else if ((min_uV > 1300000) && (max_uV >= 1350000)) 750 vsel = 58; 751 else 752 return -EINVAL; 753 break; 754 case SMPS_OFFSET_EN: 755 if (min_uV == 0) 756 vsel = 0; 757 else if ((min_uV >= 700000) && (max_uV <= 1420000)) { 758 vsel = (min_uV - 700000) / 125; 759 if (vsel % 100) 760 vsel += 100; 761 vsel /= 100; 762 vsel++; 763 } 764 /* Values 1..57 for vsel are linear and can be calculated 765 * values 58..62 are non linear. 766 */ 767 else if ((min_uV > 1900000) && (max_uV >= 2100000)) 768 vsel = 62; 769 else if ((min_uV > 1800000) && (max_uV >= 1900000)) 770 vsel = 61; 771 else if ((min_uV > 1350000) && (max_uV >= 1800000)) 772 vsel = 60; 773 else if ((min_uV > 1350000) && (max_uV >= 1500000)) 774 vsel = 59; 775 else if ((min_uV > 1300000) && (max_uV >= 1350000)) 776 vsel = 58; 777 else 778 return -EINVAL; 779 break; 780 case SMPS_EXTENDED_EN: 781 if (min_uV == 0) 782 vsel = 0; 783 else if ((min_uV >= 1852000) && (max_uV <= 4013600)) { 784 vsel = (min_uV - 1852000) / 386; 785 if (vsel % 100) 786 vsel += 100; 787 vsel /= 100; 788 vsel++; 789 } 790 break; 791 case SMPS_OFFSET_EN|SMPS_EXTENDED_EN: 792 if (min_uV == 0) 793 vsel = 0; 794 else if ((min_uV >= 2161000) && (max_uV <= 4321000)) { 795 vsel = (min_uV - 1852000) / 386; 796 if (vsel % 100) 797 vsel += 100; 798 vsel /= 100; 799 vsel++; 800 } 801 break; 802 } 803 804 *selector = vsel; 805 806 return twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE_SMPS, 807 vsel); 808 } 809 810 static int twl6030smps_get_voltage_sel(struct regulator_dev *rdev) 811 { 812 struct twlreg_info *info = rdev_get_drvdata(rdev); 813 814 return twlreg_read(info, TWL_MODULE_PM_RECEIVER, VREG_VOLTAGE_SMPS); 815 } 816 817 static struct regulator_ops twlsmps_ops = { 818 .list_voltage = twl6030smps_list_voltage, 819 820 .set_voltage = twl6030smps_set_voltage, 821 .get_voltage_sel = twl6030smps_get_voltage_sel, 822 823 .enable = twl6030reg_enable, 824 .disable = twl6030reg_disable, 825 .is_enabled = twl6030reg_is_enabled, 826 827 .set_mode = twl6030reg_set_mode, 828 829 .get_status = twl6030reg_get_status, 830 }; 831 832 /*----------------------------------------------------------------------*/ 833 834 #define TWL4030_FIXED_LDO(label, offset, mVolts, num, turnon_delay, \ 835 remap_conf) \ 836 TWL_FIXED_LDO(label, offset, mVolts, num, turnon_delay, \ 837 remap_conf, TWL4030, twl4030fixed_ops) 838 #define TWL6030_FIXED_LDO(label, offset, mVolts, num, turnon_delay) \ 839 TWL_FIXED_LDO(label, offset, mVolts, num, turnon_delay, \ 840 0x0, TWL6030, twl6030fixed_ops) 841 842 #define TWL4030_ADJUSTABLE_LDO(label, offset, num, turnon_delay, remap_conf) { \ 843 .base = offset, \ 844 .id = num, \ 845 .table_len = ARRAY_SIZE(label##_VSEL_table), \ 846 .table = label##_VSEL_table, \ 847 .delay = turnon_delay, \ 848 .remap = remap_conf, \ 849 .desc = { \ 850 .name = #label, \ 851 .id = TWL4030_REG_##label, \ 852 .n_voltages = ARRAY_SIZE(label##_VSEL_table), \ 853 .ops = &twl4030ldo_ops, \ 854 .type = REGULATOR_VOLTAGE, \ 855 .owner = THIS_MODULE, \ 856 }, \ 857 } 858 859 #define TWL6030_ADJUSTABLE_LDO(label, offset, min_mVolts, max_mVolts, num) { \ 860 .base = offset, \ 861 .id = num, \ 862 .min_mV = min_mVolts, \ 863 .max_mV = max_mVolts, \ 864 .desc = { \ 865 .name = #label, \ 866 .id = TWL6030_REG_##label, \ 867 .n_voltages = (max_mVolts - min_mVolts)/100, \ 868 .ops = &twl6030ldo_ops, \ 869 .type = REGULATOR_VOLTAGE, \ 870 .owner = THIS_MODULE, \ 871 }, \ 872 } 873 874 #define TWL6025_ADJUSTABLE_LDO(label, offset, min_mVolts, max_mVolts, num) { \ 875 .base = offset, \ 876 .id = num, \ 877 .min_mV = min_mVolts, \ 878 .max_mV = max_mVolts, \ 879 .desc = { \ 880 .name = #label, \ 881 .id = TWL6025_REG_##label, \ 882 .n_voltages = ((max_mVolts - min_mVolts)/100) + 1, \ 883 .ops = &twl6030ldo_ops, \ 884 .type = REGULATOR_VOLTAGE, \ 885 .owner = THIS_MODULE, \ 886 }, \ 887 } 888 889 #define TWL_FIXED_LDO(label, offset, mVolts, num, turnon_delay, remap_conf, \ 890 family, operations) { \ 891 .base = offset, \ 892 .id = num, \ 893 .min_mV = mVolts, \ 894 .delay = turnon_delay, \ 895 .remap = remap_conf, \ 896 .desc = { \ 897 .name = #label, \ 898 .id = family##_REG_##label, \ 899 .n_voltages = 1, \ 900 .ops = &operations, \ 901 .type = REGULATOR_VOLTAGE, \ 902 .owner = THIS_MODULE, \ 903 }, \ 904 } 905 906 #define TWL6030_FIXED_RESOURCE(label, offset, num, turnon_delay) { \ 907 .base = offset, \ 908 .id = num, \ 909 .delay = turnon_delay, \ 910 .desc = { \ 911 .name = #label, \ 912 .id = TWL6030_REG_##label, \ 913 .ops = &twl6030_fixed_resource, \ 914 .type = REGULATOR_VOLTAGE, \ 915 .owner = THIS_MODULE, \ 916 }, \ 917 } 918 919 #define TWL6025_ADJUSTABLE_SMPS(label, offset, num) { \ 920 .base = offset, \ 921 .id = num, \ 922 .min_mV = 600, \ 923 .max_mV = 2100, \ 924 .desc = { \ 925 .name = #label, \ 926 .id = TWL6025_REG_##label, \ 927 .n_voltages = 63, \ 928 .ops = &twlsmps_ops, \ 929 .type = REGULATOR_VOLTAGE, \ 930 .owner = THIS_MODULE, \ 931 }, \ 932 } 933 934 /* 935 * We list regulators here if systems need some level of 936 * software control over them after boot. 937 */ 938 static struct twlreg_info twl_regs[] = { 939 TWL4030_ADJUSTABLE_LDO(VAUX1, 0x17, 1, 100, 0x08), 940 TWL4030_ADJUSTABLE_LDO(VAUX2_4030, 0x1b, 2, 100, 0x08), 941 TWL4030_ADJUSTABLE_LDO(VAUX2, 0x1b, 2, 100, 0x08), 942 TWL4030_ADJUSTABLE_LDO(VAUX3, 0x1f, 3, 100, 0x08), 943 TWL4030_ADJUSTABLE_LDO(VAUX4, 0x23, 4, 100, 0x08), 944 TWL4030_ADJUSTABLE_LDO(VMMC1, 0x27, 5, 100, 0x08), 945 TWL4030_ADJUSTABLE_LDO(VMMC2, 0x2b, 6, 100, 0x08), 946 TWL4030_ADJUSTABLE_LDO(VPLL1, 0x2f, 7, 100, 0x00), 947 TWL4030_ADJUSTABLE_LDO(VPLL2, 0x33, 8, 100, 0x08), 948 TWL4030_ADJUSTABLE_LDO(VSIM, 0x37, 9, 100, 0x00), 949 TWL4030_ADJUSTABLE_LDO(VDAC, 0x3b, 10, 100, 0x08), 950 TWL4030_FIXED_LDO(VINTANA1, 0x3f, 1500, 11, 100, 0x08), 951 TWL4030_ADJUSTABLE_LDO(VINTANA2, 0x43, 12, 100, 0x08), 952 TWL4030_FIXED_LDO(VINTDIG, 0x47, 1500, 13, 100, 0x08), 953 TWL4030_ADJUSTABLE_LDO(VIO, 0x4b, 14, 1000, 0x08), 954 TWL4030_ADJUSTABLE_LDO(VDD1, 0x55, 15, 1000, 0x08), 955 TWL4030_ADJUSTABLE_LDO(VDD2, 0x63, 16, 1000, 0x08), 956 TWL4030_FIXED_LDO(VUSB1V5, 0x71, 1500, 17, 100, 0x08), 957 TWL4030_FIXED_LDO(VUSB1V8, 0x74, 1800, 18, 100, 0x08), 958 TWL4030_FIXED_LDO(VUSB3V1, 0x77, 3100, 19, 150, 0x08), 959 /* VUSBCP is managed *only* by the USB subchip */ 960 961 /* 6030 REG with base as PMC Slave Misc : 0x0030 */ 962 /* Turnon-delay and remap configuration values for 6030 are not 963 verified since the specification is not public */ 964 TWL6030_ADJUSTABLE_LDO(VAUX1_6030, 0x54, 1000, 3300, 1), 965 TWL6030_ADJUSTABLE_LDO(VAUX2_6030, 0x58, 1000, 3300, 2), 966 TWL6030_ADJUSTABLE_LDO(VAUX3_6030, 0x5c, 1000, 3300, 3), 967 TWL6030_ADJUSTABLE_LDO(VMMC, 0x68, 1000, 3300, 4), 968 TWL6030_ADJUSTABLE_LDO(VPP, 0x6c, 1000, 3300, 5), 969 TWL6030_ADJUSTABLE_LDO(VUSIM, 0x74, 1000, 3300, 7), 970 TWL6030_FIXED_LDO(VANA, 0x50, 2100, 15, 0), 971 TWL6030_FIXED_LDO(VCXIO, 0x60, 1800, 16, 0), 972 TWL6030_FIXED_LDO(VDAC, 0x64, 1800, 17, 0), 973 TWL6030_FIXED_LDO(VUSB, 0x70, 3300, 18, 0), 974 TWL6030_FIXED_RESOURCE(CLK32KG, 0x8C, 48, 0), 975 976 /* 6025 are renamed compared to 6030 versions */ 977 TWL6025_ADJUSTABLE_LDO(LDO2, 0x54, 1000, 3300, 1), 978 TWL6025_ADJUSTABLE_LDO(LDO4, 0x58, 1000, 3300, 2), 979 TWL6025_ADJUSTABLE_LDO(LDO3, 0x5c, 1000, 3300, 3), 980 TWL6025_ADJUSTABLE_LDO(LDO5, 0x68, 1000, 3300, 4), 981 TWL6025_ADJUSTABLE_LDO(LDO1, 0x6c, 1000, 3300, 5), 982 TWL6025_ADJUSTABLE_LDO(LDO7, 0x74, 1000, 3300, 7), 983 TWL6025_ADJUSTABLE_LDO(LDO6, 0x60, 1000, 3300, 16), 984 TWL6025_ADJUSTABLE_LDO(LDOLN, 0x64, 1000, 3300, 17), 985 TWL6025_ADJUSTABLE_LDO(LDOUSB, 0x70, 1000, 3300, 18), 986 987 TWL6025_ADJUSTABLE_SMPS(SMPS3, 0x34, 1), 988 TWL6025_ADJUSTABLE_SMPS(SMPS4, 0x10, 2), 989 TWL6025_ADJUSTABLE_SMPS(VIO, 0x16, 3), 990 }; 991 992 static u8 twl_get_smps_offset(void) 993 { 994 u8 value; 995 996 twl_i2c_read_u8(TWL_MODULE_PM_RECEIVER, &value, 997 TWL6030_SMPS_OFFSET); 998 return value; 999 } 1000 1001 static u8 twl_get_smps_mult(void) 1002 { 1003 u8 value; 1004 1005 twl_i2c_read_u8(TWL_MODULE_PM_RECEIVER, &value, 1006 TWL6030_SMPS_MULT); 1007 return value; 1008 } 1009 1010 static int __devinit twlreg_probe(struct platform_device *pdev) 1011 { 1012 int i; 1013 struct twlreg_info *info; 1014 struct regulator_init_data *initdata; 1015 struct regulation_constraints *c; 1016 struct regulator_dev *rdev; 1017 1018 for (i = 0, info = NULL; i < ARRAY_SIZE(twl_regs); i++) { 1019 if (twl_regs[i].desc.id != pdev->id) 1020 continue; 1021 info = twl_regs + i; 1022 break; 1023 } 1024 if (!info) 1025 return -ENODEV; 1026 1027 initdata = pdev->dev.platform_data; 1028 if (!initdata) 1029 return -EINVAL; 1030 1031 /* copy the features into regulator data */ 1032 info->features = (unsigned long)initdata->driver_data; 1033 1034 /* Constrain board-specific capabilities according to what 1035 * this driver and the chip itself can actually do. 1036 */ 1037 c = &initdata->constraints; 1038 c->valid_modes_mask &= REGULATOR_MODE_NORMAL | REGULATOR_MODE_STANDBY; 1039 c->valid_ops_mask &= REGULATOR_CHANGE_VOLTAGE 1040 | REGULATOR_CHANGE_MODE 1041 | REGULATOR_CHANGE_STATUS; 1042 switch (pdev->id) { 1043 case TWL4030_REG_VIO: 1044 case TWL4030_REG_VDD1: 1045 case TWL4030_REG_VDD2: 1046 case TWL4030_REG_VPLL1: 1047 case TWL4030_REG_VINTANA1: 1048 case TWL4030_REG_VINTANA2: 1049 case TWL4030_REG_VINTDIG: 1050 c->always_on = true; 1051 break; 1052 default: 1053 break; 1054 } 1055 1056 switch (pdev->id) { 1057 case TWL6025_REG_SMPS3: 1058 if (twl_get_smps_mult() & SMPS_MULTOFFSET_SMPS3) 1059 info->flags |= SMPS_EXTENDED_EN; 1060 if (twl_get_smps_offset() & SMPS_MULTOFFSET_SMPS3) 1061 info->flags |= SMPS_OFFSET_EN; 1062 break; 1063 case TWL6025_REG_SMPS4: 1064 if (twl_get_smps_mult() & SMPS_MULTOFFSET_SMPS4) 1065 info->flags |= SMPS_EXTENDED_EN; 1066 if (twl_get_smps_offset() & SMPS_MULTOFFSET_SMPS4) 1067 info->flags |= SMPS_OFFSET_EN; 1068 break; 1069 case TWL6025_REG_VIO: 1070 if (twl_get_smps_mult() & SMPS_MULTOFFSET_VIO) 1071 info->flags |= SMPS_EXTENDED_EN; 1072 if (twl_get_smps_offset() & SMPS_MULTOFFSET_VIO) 1073 info->flags |= SMPS_OFFSET_EN; 1074 break; 1075 } 1076 1077 rdev = regulator_register(&info->desc, &pdev->dev, initdata, info); 1078 if (IS_ERR(rdev)) { 1079 dev_err(&pdev->dev, "can't register %s, %ld\n", 1080 info->desc.name, PTR_ERR(rdev)); 1081 return PTR_ERR(rdev); 1082 } 1083 platform_set_drvdata(pdev, rdev); 1084 1085 if (twl_class_is_4030()) 1086 twlreg_write(info, TWL_MODULE_PM_RECEIVER, VREG_REMAP, 1087 info->remap); 1088 1089 /* NOTE: many regulators support short-circuit IRQs (presentable 1090 * as REGULATOR_OVER_CURRENT notifications?) configured via: 1091 * - SC_CONFIG 1092 * - SC_DETECT1 (vintana2, vmmc1/2, vaux1/2/3/4) 1093 * - SC_DETECT2 (vusb, vdac, vio, vdd1/2, vpll2) 1094 * - IT_CONFIG 1095 */ 1096 1097 return 0; 1098 } 1099 1100 static int __devexit twlreg_remove(struct platform_device *pdev) 1101 { 1102 regulator_unregister(platform_get_drvdata(pdev)); 1103 return 0; 1104 } 1105 1106 MODULE_ALIAS("platform:twl_reg"); 1107 1108 static struct platform_driver twlreg_driver = { 1109 .probe = twlreg_probe, 1110 .remove = __devexit_p(twlreg_remove), 1111 /* NOTE: short name, to work around driver model truncation of 1112 * "twl_regulator.12" (and friends) to "twl_regulator.1". 1113 */ 1114 .driver.name = "twl_reg", 1115 .driver.owner = THIS_MODULE, 1116 }; 1117 1118 static int __init twlreg_init(void) 1119 { 1120 return platform_driver_register(&twlreg_driver); 1121 } 1122 subsys_initcall(twlreg_init); 1123 1124 static void __exit twlreg_exit(void) 1125 { 1126 platform_driver_unregister(&twlreg_driver); 1127 } 1128 module_exit(twlreg_exit) 1129 1130 MODULE_DESCRIPTION("TWL regulator driver"); 1131 MODULE_LICENSE("GPL"); 1132