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