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