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