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