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