arch/arm/mach-omap2/twl-common.c

   1 /*
   2  * twl-common.c
   3  *
   4  * Copyright (C) 2011 Texas Instruments, Inc..
   5  * Author: Peter Ujfalusi <peter.ujfalusi@ti.com>
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * version 2 as published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
  19  * 02110-1301 USA
  20  *
  21  */
  22
  23 #include <linux/i2c.h>
  24 #include <linux/i2c/twl.h>
  25 #include <linux/gpio.h>
  26 #include <linux/regulator/machine.h>
  27 #include <linux/regulator/fixed.h>
  28
  29 #include <plat/hardware.h>
  30 #include <plat/i2c.h>
  31 #include <plat/usb.h>
  32
  33 #include "twl-common.h"
  34 #include "pm.h"
  35 #include "voltage.h"
  36 #include "mux.h"
  37
  38 static struct i2c_board_info __initdata pmic_i2c_board_info = {
  39         .addr           = 0x48,
  40         .flags          = I2C_CLIENT_WAKE,
  41 };
  42
  43 static struct i2c_board_info __initdata omap4_i2c1_board_info[] = {
  44         {
  45                 .addr           = 0x48,
  46                 .flags          = I2C_CLIENT_WAKE,
  47         },
  48         {
  49                 I2C_BOARD_INFO("twl6040", 0x4b),
  50         },
  51 };
  52
  53 #if defined(CONFIG_ARCH_OMAP3) || defined(CONFIG_ARCH_OMAP4)
  54 static int twl_set_voltage(void *data, int target_uV)
  55 {
  56         struct voltagedomain *voltdm = (struct voltagedomain *)data;
  57         return voltdm_scale(voltdm, target_uV);
  58 }
  59
  60 static int twl_get_voltage(void *data)
  61 {
  62         struct voltagedomain *voltdm = (struct voltagedomain *)data;
  63         return voltdm_get_voltage(voltdm);
  64 }
  65 #endif
  66
  67 void __init omap_pmic_init(int bus, u32 clkrate,
  68                            const char *pmic_type, int pmic_irq,
  69                            struct twl4030_platform_data *pmic_data)
  70 {
  71         omap_mux_init_signal("sys_nirq", OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_WAKEUPENABLE);
  72         strncpy(pmic_i2c_board_info.type, pmic_type,
  73                 sizeof(pmic_i2c_board_info.type));
  74         pmic_i2c_board_info.irq = pmic_irq;
  75         pmic_i2c_board_info.platform_data = pmic_data;
  76
  77         omap_register_i2c_bus(bus, clkrate, &pmic_i2c_board_info, 1);
  78 }
  79
  80 void __init omap4_pmic_init(const char *pmic_type,
  81                     struct twl4030_platform_data *pmic_data,
  82                     struct twl6040_platform_data *twl6040_data, int twl6040_irq)
  83 {
  84         /* PMIC part*/
  85         omap_mux_init_signal("sys_nirq1", OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_WAKEUPENABLE);
  86         strncpy(omap4_i2c1_board_info[0].type, pmic_type,
  87                 sizeof(omap4_i2c1_board_info[0].type));
  88         omap4_i2c1_board_info[0].irq = 7 + OMAP44XX_IRQ_GIC_START;
  89         omap4_i2c1_board_info[0].platform_data = pmic_data;
  90
  91         /* TWL6040 audio IC part */
  92         omap4_i2c1_board_info[1].irq = twl6040_irq;
  93         omap4_i2c1_board_info[1].platform_data = twl6040_data;
  94
  95         omap_register_i2c_bus(1, 400, omap4_i2c1_board_info, 2);
  96
  97 }
  98
  99 void __init omap_pmic_late_init(void)
 100 {
 101         /* Init the OMAP TWL parameters (if PMIC has been registered) */
 102         if (pmic_i2c_board_info.irq)
 103                 omap3_twl_init();
 104         if (omap4_i2c1_board_info[0].irq)
 105                 omap4_twl_init();
 106 }
 107
 108 #if defined(CONFIG_ARCH_OMAP3)
 109 static struct twl4030_usb_data omap3_usb_pdata = {
 110         .usb_mode       = T2_USB_MODE_ULPI,
 111 };
 112
 113 static int omap3_batt_table[] = {
 114 /* 0 C */
 115 30800, 29500, 28300, 27100,
 116 26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
 117 17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
 118 11600, 11200, 10800, 10400, 10000, 9630,  9280,  8950,  8620,  8310,
 119 8020,  7730,  7460,  7200,  6950,  6710,  6470,  6250,  6040,  5830,
 120 5640,  5450,  5260,  5090,  4920,  4760,  4600,  4450,  4310,  4170,
 121 4040,  3910,  3790,  3670,  3550
 122 };
 123
 124 static struct twl4030_bci_platform_data omap3_bci_pdata = {
 125         .battery_tmp_tbl        = omap3_batt_table,
 126         .tblsize                = ARRAY_SIZE(omap3_batt_table),
 127 };
 128
 129 static struct twl4030_madc_platform_data omap3_madc_pdata = {
 130         .irq_line       = 1,
 131 };
 132
 133 static struct twl4030_codec_data omap3_codec;
 134
 135 static struct twl4030_audio_data omap3_audio_pdata = {
 136         .audio_mclk = 26000000,
 137         .codec = &omap3_codec,
 138 };
 139
 140 static struct regulator_consumer_supply omap3_vdda_dac_supplies[] = {
 141         REGULATOR_SUPPLY("vdda_dac", "omapdss_venc"),
 142 };
 143
 144 static struct regulator_init_data omap3_vdac_idata = {
 145         .constraints = {
 146                 .min_uV                 = 1800000,
 147                 .max_uV                 = 1800000,
 148                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 149                                         | REGULATOR_MODE_STANDBY,
 150                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 151                                         | REGULATOR_CHANGE_STATUS,
 152         },
 153         .num_consumer_supplies  = ARRAY_SIZE(omap3_vdda_dac_supplies),
 154         .consumer_supplies      = omap3_vdda_dac_supplies,
 155 };
 156
 157 static struct regulator_consumer_supply omap3_vpll2_supplies[] = {
 158         REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
 159         REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.0"),
 160 };
 161
 162 static struct regulator_init_data omap3_vpll2_idata = {
 163         .constraints = {
 164                 .min_uV                 = 1800000,
 165                 .max_uV                 = 1800000,
 166                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 167                                         | REGULATOR_MODE_STANDBY,
 168                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 169                                         | REGULATOR_CHANGE_STATUS,
 170         },
 171         .num_consumer_supplies          = ARRAY_SIZE(omap3_vpll2_supplies),
 172         .consumer_supplies              = omap3_vpll2_supplies,
 173 };
 174
 175 static struct regulator_consumer_supply omap3_vdd1_supply[] = {
 176         REGULATOR_SUPPLY("vcc", "mpu.0"),
 177 };
 178
 179 static struct regulator_consumer_supply omap3_vdd2_supply[] = {
 180         REGULATOR_SUPPLY("vcc", "l3_main.0"),
 181 };
 182
 183 static struct regulator_init_data omap3_vdd1 = {
 184         .constraints = {
 185                 .name                   = "vdd_mpu_iva",
 186                 .min_uV                 = 600000,
 187                 .max_uV                 = 1450000,
 188                 .valid_modes_mask       = REGULATOR_MODE_NORMAL,
 189                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE,
 190         },
 191         .num_consumer_supplies          = ARRAY_SIZE(omap3_vdd1_supply),
 192         .consumer_supplies              = omap3_vdd1_supply,
 193 };
 194
 195 static struct regulator_init_data omap3_vdd2 = {
 196         .constraints = {
 197                 .name                   = "vdd_core",
 198                 .min_uV                 = 600000,
 199                 .max_uV                 = 1450000,
 200                 .valid_modes_mask       = REGULATOR_MODE_NORMAL,
 201                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE,
 202         },
 203         .num_consumer_supplies          = ARRAY_SIZE(omap3_vdd2_supply),
 204         .consumer_supplies              = omap3_vdd2_supply,
 205 };
 206
 207 static struct twl_regulator_driver_data omap3_vdd1_drvdata = {
 208         .get_voltage = twl_get_voltage,
 209         .set_voltage = twl_set_voltage,
 210 };
 211
 212 static struct twl_regulator_driver_data omap3_vdd2_drvdata = {
 213         .get_voltage = twl_get_voltage,
 214         .set_voltage = twl_set_voltage,
 215 };
 216
 217 void __init omap3_pmic_get_config(struct twl4030_platform_data *pmic_data,
 218                                   u32 pdata_flags, u32 regulators_flags)
 219 {
 220         if (!pmic_data->vdd1) {
 221                 omap3_vdd1.driver_data = &omap3_vdd1_drvdata;
 222                 omap3_vdd1_drvdata.data = voltdm_lookup("mpu_iva");
 223                 pmic_data->vdd1 = &omap3_vdd1;
 224         }
 225         if (!pmic_data->vdd2) {
 226                 omap3_vdd2.driver_data = &omap3_vdd2_drvdata;
 227                 omap3_vdd2_drvdata.data = voltdm_lookup("core");
 228                 pmic_data->vdd2 = &omap3_vdd2;
 229         }
 230
 231         /* Common platform data configurations */
 232         if (pdata_flags & TWL_COMMON_PDATA_USB && !pmic_data->usb)
 233                 pmic_data->usb = &omap3_usb_pdata;
 234
 235         if (pdata_flags & TWL_COMMON_PDATA_BCI && !pmic_data->bci)
 236                 pmic_data->bci = &omap3_bci_pdata;
 237
 238         if (pdata_flags & TWL_COMMON_PDATA_MADC && !pmic_data->madc)
 239                 pmic_data->madc = &omap3_madc_pdata;
 240
 241         if (pdata_flags & TWL_COMMON_PDATA_AUDIO && !pmic_data->audio)
 242                 pmic_data->audio = &omap3_audio_pdata;
 243
 244         /* Common regulator configurations */
 245         if (regulators_flags & TWL_COMMON_REGULATOR_VDAC && !pmic_data->vdac)
 246                 pmic_data->vdac = &omap3_vdac_idata;
 247
 248         if (regulators_flags & TWL_COMMON_REGULATOR_VPLL2 && !pmic_data->vpll2)
 249                 pmic_data->vpll2 = &omap3_vpll2_idata;
 250 }
 251 #endif /* CONFIG_ARCH_OMAP3 */
 252
 253 #if defined(CONFIG_ARCH_OMAP4)
 254 static struct twl4030_usb_data omap4_usb_pdata = {
 255         .phy_init       = omap4430_phy_init,
 256         .phy_exit       = omap4430_phy_exit,
 257         .phy_power      = omap4430_phy_power,
 258         .phy_set_clock  = omap4430_phy_set_clk,
 259         .phy_suspend    = omap4430_phy_suspend,
 260 };
 261
 262 static struct regulator_init_data omap4_vdac_idata = {
 263         .constraints = {
 264                 .min_uV                 = 1800000,
 265                 .max_uV                 = 1800000,
 266                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 267                                         | REGULATOR_MODE_STANDBY,
 268                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 269                                         | REGULATOR_CHANGE_STATUS,
 270         },
 271         .supply_regulator       = "V2V1",
 272 };
 273
 274 static struct regulator_init_data omap4_vaux2_idata = {
 275         .constraints = {
 276                 .min_uV                 = 1200000,
 277                 .max_uV                 = 2800000,
 278                 .apply_uV               = true,
 279                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 280                                         | REGULATOR_MODE_STANDBY,
 281                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 282                                         | REGULATOR_CHANGE_MODE
 283                                         | REGULATOR_CHANGE_STATUS,
 284         },
 285 };
 286
 287 static struct regulator_init_data omap4_vaux3_idata = {
 288         .constraints = {
 289                 .min_uV                 = 1000000,
 290                 .max_uV                 = 3000000,
 291                 .apply_uV               = true,
 292                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 293                                         | REGULATOR_MODE_STANDBY,
 294                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 295                                         | REGULATOR_CHANGE_MODE
 296                                         | REGULATOR_CHANGE_STATUS,
 297         },
 298 };
 299
 300 static struct regulator_consumer_supply omap4_vmmc_supply[] = {
 301         REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
 302 };
 303
 304 /* VMMC1 for MMC1 card */
 305 static struct regulator_init_data omap4_vmmc_idata = {
 306         .constraints = {
 307                 .min_uV                 = 1200000,
 308                 .max_uV                 = 3000000,
 309                 .apply_uV               = true,
 310                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 311                                         | REGULATOR_MODE_STANDBY,
 312                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 313                                         | REGULATOR_CHANGE_MODE
 314                                         | REGULATOR_CHANGE_STATUS,
 315         },
 316         .num_consumer_supplies  = ARRAY_SIZE(omap4_vmmc_supply),
 317         .consumer_supplies      = omap4_vmmc_supply,
 318 };
 319
 320 static struct regulator_init_data omap4_vpp_idata = {
 321         .constraints = {
 322                 .min_uV                 = 1800000,
 323                 .max_uV                 = 2500000,
 324                 .apply_uV               = true,
 325                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 326                                         | REGULATOR_MODE_STANDBY,
 327                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE
 328                                         | REGULATOR_CHANGE_MODE
 329                                         | REGULATOR_CHANGE_STATUS,
 330         },
 331 };
 332
 333 static struct regulator_init_data omap4_vana_idata = {
 334         .constraints = {
 335                 .min_uV                 = 2100000,
 336                 .max_uV                 = 2100000,
 337                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 338                                         | REGULATOR_MODE_STANDBY,
 339                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 340                                         | REGULATOR_CHANGE_STATUS,
 341         },
 342 };
 343
 344 static struct regulator_consumer_supply omap4_vcxio_supply[] = {
 345         REGULATOR_SUPPLY("vdds_dsi", "omapdss_dss"),
 346         REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.0"),
 347         REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.1"),
 348 };
 349
 350 static struct regulator_init_data omap4_vcxio_idata = {
 351         .constraints = {
 352                 .min_uV                 = 1800000,
 353                 .max_uV                 = 1800000,
 354                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 355                                         | REGULATOR_MODE_STANDBY,
 356                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 357                                         | REGULATOR_CHANGE_STATUS,
 358                 .always_on              = true,
 359         },
 360         .num_consumer_supplies  = ARRAY_SIZE(omap4_vcxio_supply),
 361         .consumer_supplies      = omap4_vcxio_supply,
 362         .supply_regulator       = "V2V1",
 363 };
 364
 365 static struct regulator_init_data omap4_vusb_idata = {
 366         .constraints = {
 367                 .min_uV                 = 3300000,
 368                 .max_uV                 = 3300000,
 369                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 370                                         | REGULATOR_MODE_STANDBY,
 371                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 372                                         | REGULATOR_CHANGE_STATUS,
 373         },
 374 };
 375
 376 static struct regulator_init_data omap4_clk32kg_idata = {
 377         .constraints = {
 378                 .valid_ops_mask         = REGULATOR_CHANGE_STATUS,
 379         },
 380 };
 381
 382 static struct regulator_consumer_supply omap4_vdd1_supply[] = {
 383         REGULATOR_SUPPLY("vcc", "mpu.0"),
 384 };
 385
 386 static struct regulator_consumer_supply omap4_vdd2_supply[] = {
 387         REGULATOR_SUPPLY("vcc", "iva.0"),
 388 };
 389
 390 static struct regulator_consumer_supply omap4_vdd3_supply[] = {
 391         REGULATOR_SUPPLY("vcc", "l3_main.0"),
 392 };
 393
 394 static struct regulator_init_data omap4_vdd1 = {
 395         .constraints = {
 396                 .name                   = "vdd_mpu",
 397                 .min_uV                 = 500000,
 398                 .max_uV                 = 1500000,
 399                 .valid_modes_mask       = REGULATOR_MODE_NORMAL,
 400                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE,
 401         },
 402         .num_consumer_supplies          = ARRAY_SIZE(omap4_vdd1_supply),
 403         .consumer_supplies              = omap4_vdd1_supply,
 404 };
 405
 406 static struct regulator_init_data omap4_vdd2 = {
 407         .constraints = {
 408                 .name                   = "vdd_iva",
 409                 .min_uV                 = 500000,
 410                 .max_uV                 = 1500000,
 411                 .valid_modes_mask       = REGULATOR_MODE_NORMAL,
 412                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE,
 413         },
 414         .num_consumer_supplies          = ARRAY_SIZE(omap4_vdd2_supply),
 415         .consumer_supplies              = omap4_vdd2_supply,
 416 };
 417
 418 static struct regulator_init_data omap4_vdd3 = {
 419         .constraints = {
 420                 .name                   = "vdd_core",
 421                 .min_uV                 = 500000,
 422                 .max_uV                 = 1500000,
 423                 .valid_modes_mask       = REGULATOR_MODE_NORMAL,
 424                 .valid_ops_mask         = REGULATOR_CHANGE_VOLTAGE,
 425         },
 426         .num_consumer_supplies          = ARRAY_SIZE(omap4_vdd3_supply),
 427         .consumer_supplies              = omap4_vdd3_supply,
 428 };
 429
 430
 431 static struct twl_regulator_driver_data omap4_vdd1_drvdata = {
 432         .get_voltage = twl_get_voltage,
 433         .set_voltage = twl_set_voltage,
 434 };
 435
 436 static struct twl_regulator_driver_data omap4_vdd2_drvdata = {
 437         .get_voltage = twl_get_voltage,
 438         .set_voltage = twl_set_voltage,
 439 };
 440
 441 static struct twl_regulator_driver_data omap4_vdd3_drvdata = {
 442         .get_voltage = twl_get_voltage,
 443         .set_voltage = twl_set_voltage,
 444 };
 445
 446 static struct regulator_consumer_supply omap4_v1v8_supply[] = {
 447         REGULATOR_SUPPLY("vio", "1-004b"),
 448 };
 449
 450 static struct regulator_init_data omap4_v1v8_idata = {
 451         .constraints = {
 452                 .min_uV                 = 1800000,
 453                 .max_uV                 = 1800000,
 454                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 455                                         | REGULATOR_MODE_STANDBY,
 456                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 457                                         | REGULATOR_CHANGE_STATUS,
 458                 .always_on              = true,
 459         },
 460         .num_consumer_supplies  = ARRAY_SIZE(omap4_v1v8_supply),
 461         .consumer_supplies      = omap4_v1v8_supply,
 462 };
 463
 464 static struct regulator_consumer_supply omap4_v2v1_supply[] = {
 465         REGULATOR_SUPPLY("v2v1", "1-004b"),
 466 };
 467
 468 static struct regulator_init_data omap4_v2v1_idata = {
 469         .constraints = {
 470                 .min_uV                 = 2100000,
 471                 .max_uV                 = 2100000,
 472                 .valid_modes_mask       = REGULATOR_MODE_NORMAL
 473                                         | REGULATOR_MODE_STANDBY,
 474                 .valid_ops_mask         = REGULATOR_CHANGE_MODE
 475                                         | REGULATOR_CHANGE_STATUS,
 476         },
 477         .num_consumer_supplies  = ARRAY_SIZE(omap4_v2v1_supply),
 478         .consumer_supplies      = omap4_v2v1_supply,
 479 };
 480
 481 void __init omap4_pmic_get_config(struct twl4030_platform_data *pmic_data,
 482                                   u32 pdata_flags, u32 regulators_flags)
 483 {
 484         if (!pmic_data->vdd1) {
 485                 omap4_vdd1.driver_data = &omap4_vdd1_drvdata;
 486                 omap4_vdd1_drvdata.data = voltdm_lookup("mpu");
 487                 pmic_data->vdd1 = &omap4_vdd1;
 488         }
 489
 490         if (!pmic_data->vdd2) {
 491                 omap4_vdd2.driver_data = &omap4_vdd2_drvdata;
 492                 omap4_vdd2_drvdata.data = voltdm_lookup("iva");
 493                 pmic_data->vdd2 = &omap4_vdd2;
 494         }
 495
 496         if (!pmic_data->vdd3) {
 497                 omap4_vdd3.driver_data = &omap4_vdd3_drvdata;
 498                 omap4_vdd3_drvdata.data = voltdm_lookup("core");
 499                 pmic_data->vdd3 = &omap4_vdd3;
 500         }
 501
 502         /* Common platform data configurations */
 503         if (pdata_flags & TWL_COMMON_PDATA_USB && !pmic_data->usb)
 504                 pmic_data->usb = &omap4_usb_pdata;
 505
 506         /* Common regulator configurations */
 507         if (regulators_flags & TWL_COMMON_REGULATOR_VDAC && !pmic_data->vdac)
 508                 pmic_data->vdac = &omap4_vdac_idata;
 509
 510         if (regulators_flags & TWL_COMMON_REGULATOR_VAUX2 && !pmic_data->vaux2)
 511                 pmic_data->vaux2 = &omap4_vaux2_idata;
 512
 513         if (regulators_flags & TWL_COMMON_REGULATOR_VAUX3 && !pmic_data->vaux3)
 514                 pmic_data->vaux3 = &omap4_vaux3_idata;
 515
 516         if (regulators_flags & TWL_COMMON_REGULATOR_VMMC && !pmic_data->vmmc)
 517                 pmic_data->vmmc = &omap4_vmmc_idata;
 518
 519         if (regulators_flags & TWL_COMMON_REGULATOR_VPP && !pmic_data->vpp)
 520                 pmic_data->vpp = &omap4_vpp_idata;
 521
 522         if (regulators_flags & TWL_COMMON_REGULATOR_VANA && !pmic_data->vana)
 523                 pmic_data->vana = &omap4_vana_idata;
 524
 525         if (regulators_flags & TWL_COMMON_REGULATOR_VCXIO && !pmic_data->vcxio)
 526                 pmic_data->vcxio = &omap4_vcxio_idata;
 527
 528         if (regulators_flags & TWL_COMMON_REGULATOR_VUSB && !pmic_data->vusb)
 529                 pmic_data->vusb = &omap4_vusb_idata;
 530
 531         if (regulators_flags & TWL_COMMON_REGULATOR_CLK32KG &&
 532             !pmic_data->clk32kg)
 533                 pmic_data->clk32kg = &omap4_clk32kg_idata;
 534
 535         if (regulators_flags & TWL_COMMON_REGULATOR_V1V8 && !pmic_data->v1v8)
 536                 pmic_data->v1v8 = &omap4_v1v8_idata;
 537
 538         if (regulators_flags & TWL_COMMON_REGULATOR_V2V1 && !pmic_data->v2v1)
 539                 pmic_data->v2v1 = &omap4_v2v1_idata;
 540 }
 541 #endif /* CONFIG_ARCH_OMAP4 */