[deliverable/linux.git] / arch / arm / mach-omap2 / twl-common.c

/*
 * twl-common.c
 *
 * Copyright (C) 2011 Texas Instruments, Inc..
 * Author: Peter Ujfalusi <peter.ujfalusi@ti.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */

#include <linux/i2c.h>
#include <linux/i2c/twl.h>
#include <linux/gpio.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/fixed.h>

#include <plat/i2c.h>
#include <plat/usb.h>

#include "soc.h"
#include "twl-common.h"
#include "pm.h"
#include "voltage.h"
#include "mux.h"

static struct i2c_board_info __initdata pmic_i2c_board_info = {
	.addr		= 0x48,
	.flags		= I2C_CLIENT_WAKE,
};

#if defined(CONFIG_ARCH_OMAP3) || defined(CONFIG_ARCH_OMAP4)
static int twl_set_voltage(void *data, int target_uV)
{
	struct voltagedomain *voltdm = (struct voltagedomain *)data;
	return voltdm_scale(voltdm, target_uV);
}

static int twl_get_voltage(void *data)
{
	struct voltagedomain *voltdm = (struct voltagedomain *)data;
	return voltdm_get_voltage(voltdm);
}
#endif

void __init omap_pmic_init(int bus, u32 clkrate,
			   const char *pmic_type, int pmic_irq,
			   struct twl4030_platform_data *pmic_data)
{
	omap_mux_init_signal("sys_nirq", OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_WAKEUPENABLE);
	strncpy(pmic_i2c_board_info.type, pmic_type,
		sizeof(pmic_i2c_board_info.type));
	pmic_i2c_board_info.irq = pmic_irq;
	pmic_i2c_board_info.platform_data = pmic_data;

	omap_register_i2c_bus(bus, clkrate, &pmic_i2c_board_info, 1);
}

void __init omap4_pmic_init(const char *pmic_type,
		    struct twl4030_platform_data *pmic_data,
		    struct i2c_board_info *devices, int nr_devices)
{
	/* PMIC part*/
	omap_mux_init_signal("sys_nirq1", OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_WAKEUPENABLE);
	omap_mux_init_signal("fref_clk0_out.sys_drm_msecure", OMAP_PIN_OUTPUT);
	omap_pmic_init(1, 400, pmic_type, 7 + OMAP44XX_IRQ_GIC_START, pmic_data);

	/* Register additional devices on i2c1 bus if needed */
	if (devices)
		i2c_register_board_info(1, devices, nr_devices);
}

void __init omap_pmic_late_init(void)
{
	/* Init the OMAP TWL parameters (if PMIC has been registerd) */
	if (!pmic_i2c_board_info.irq)
		return;

	omap3_twl_init();
	omap4_twl_init();
}

#if defined(CONFIG_ARCH_OMAP3)
static struct twl4030_usb_data omap3_usb_pdata = {
	.usb_mode	= T2_USB_MODE_ULPI,
};

static int omap3_batt_table[] = {
/* 0 C */
30800, 29500, 28300, 27100,
26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
11600, 11200, 10800, 10400, 10000, 9630,  9280,  8950,  8620,  8310,
8020,  7730,  7460,  7200,  6950,  6710,  6470,  6250,  6040,  5830,
5640,  5450,  5260,  5090,  4920,  4760,  4600,  4450,  4310,  4170,
4040,  3910,  3790,  3670,  3550
};

static struct twl4030_bci_platform_data omap3_bci_pdata = {
	.battery_tmp_tbl	= omap3_batt_table,
	.tblsize		= ARRAY_SIZE(omap3_batt_table),
};

static struct twl4030_madc_platform_data omap3_madc_pdata = {
	.irq_line	= 1,
};

static struct twl4030_codec_data omap3_codec;

static struct twl4030_audio_data omap3_audio_pdata = {
	.audio_mclk = 26000000,
	.codec = &omap3_codec,
};

static struct regulator_consumer_supply omap3_vdda_dac_supplies[] = {
	REGULATOR_SUPPLY("vdda_dac", "omapdss_venc"),
};

static struct regulator_init_data omap3_vdac_idata = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= ARRAY_SIZE(omap3_vdda_dac_supplies),
	.consumer_supplies	= omap3_vdda_dac_supplies,
};

static struct regulator_consumer_supply omap3_vpll2_supplies[] = {
	REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.0"),
};

static struct regulator_init_data omap3_vpll2_idata = {
	.constraints = {
		.min_uV                 = 1800000,
		.max_uV                 = 1800000,
		.valid_modes_mask       = REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask         = REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies		= ARRAY_SIZE(omap3_vpll2_supplies),
	.consumer_supplies		= omap3_vpll2_supplies,
};

static struct regulator_consumer_supply omap3_vdd1_supply[] = {
	REGULATOR_SUPPLY("vcc", "cpu0"),
};

static struct regulator_consumer_supply omap3_vdd2_supply[] = {
	REGULATOR_SUPPLY("vcc", "l3_main.0"),
};

static struct regulator_init_data omap3_vdd1 = {
	.constraints = {
		.name			= "vdd_mpu_iva",
		.min_uV			= 600000,
		.max_uV			= 1450000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE,
	},
	.num_consumer_supplies		= ARRAY_SIZE(omap3_vdd1_supply),
	.consumer_supplies		= omap3_vdd1_supply,
};

static struct regulator_init_data omap3_vdd2 = {
	.constraints = {
		.name			= "vdd_core",
		.min_uV			= 600000,
		.max_uV			= 1450000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE,
	},
	.num_consumer_supplies		= ARRAY_SIZE(omap3_vdd2_supply),
	.consumer_supplies		= omap3_vdd2_supply,
};

static struct twl_regulator_driver_data omap3_vdd1_drvdata = {
	.get_voltage = twl_get_voltage,
	.set_voltage = twl_set_voltage,
};

static struct twl_regulator_driver_data omap3_vdd2_drvdata = {
	.get_voltage = twl_get_voltage,
	.set_voltage = twl_set_voltage,
};

void __init omap3_pmic_get_config(struct twl4030_platform_data *pmic_data,
				  u32 pdata_flags, u32 regulators_flags)
{
	if (!pmic_data->vdd1) {
		omap3_vdd1.driver_data = &omap3_vdd1_drvdata;
		omap3_vdd1_drvdata.data = voltdm_lookup("mpu_iva");
		pmic_data->vdd1 = &omap3_vdd1;
	}
	if (!pmic_data->vdd2) {
		omap3_vdd2.driver_data = &omap3_vdd2_drvdata;
		omap3_vdd2_drvdata.data = voltdm_lookup("core");
		pmic_data->vdd2 = &omap3_vdd2;
	}

	/* Common platform data configurations */
	if (pdata_flags & TWL_COMMON_PDATA_USB && !pmic_data->usb)
		pmic_data->usb = &omap3_usb_pdata;

	if (pdata_flags & TWL_COMMON_PDATA_BCI && !pmic_data->bci)
		pmic_data->bci = &omap3_bci_pdata;

	if (pdata_flags & TWL_COMMON_PDATA_MADC && !pmic_data->madc)
		pmic_data->madc = &omap3_madc_pdata;

	if (pdata_flags & TWL_COMMON_PDATA_AUDIO && !pmic_data->audio)
		pmic_data->audio = &omap3_audio_pdata;

	/* Common regulator configurations */
	if (regulators_flags & TWL_COMMON_REGULATOR_VDAC && !pmic_data->vdac)
		pmic_data->vdac = &omap3_vdac_idata;

	if (regulators_flags & TWL_COMMON_REGULATOR_VPLL2 && !pmic_data->vpll2)
		pmic_data->vpll2 = &omap3_vpll2_idata;
}
#endif /* CONFIG_ARCH_OMAP3 */

#if defined(CONFIG_ARCH_OMAP4)
static struct twl4030_usb_data omap4_usb_pdata = {
};

static struct regulator_consumer_supply omap4_vdda_hdmi_dac_supplies[] = {
	REGULATOR_SUPPLY("vdda_hdmi_dac", "omapdss_hdmi"),
};

static struct regulator_init_data omap4_vdac_idata = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= ARRAY_SIZE(omap4_vdda_hdmi_dac_supplies),
	.consumer_supplies	= omap4_vdda_hdmi_dac_supplies,
	.supply_regulator	= "V2V1",
};

static struct regulator_init_data omap4_vaux2_idata = {
	.constraints = {
		.min_uV			= 1200000,
		.max_uV			= 2800000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

static struct regulator_init_data omap4_vaux3_idata = {
	.constraints = {
		.min_uV			= 1000000,
		.max_uV			= 3000000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

static struct regulator_consumer_supply omap4_vmmc_supply[] = {
	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
};

/* VMMC1 for MMC1 card */
static struct regulator_init_data omap4_vmmc_idata = {
	.constraints = {
		.min_uV			= 1200000,
		.max_uV			= 3000000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies  = ARRAY_SIZE(omap4_vmmc_supply),
	.consumer_supplies      = omap4_vmmc_supply,
};

static struct regulator_init_data omap4_vpp_idata = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 2500000,
		.apply_uV		= true,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE
					| REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

static struct regulator_init_data omap4_vana_idata = {
	.constraints = {
		.min_uV			= 2100000,
		.max_uV			= 2100000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

static struct regulator_consumer_supply omap4_vcxio_supply[] = {
	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dss"),
	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.0"),
	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.1"),
};

static struct regulator_init_data omap4_vcxio_idata = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
		.always_on		= true,
	},
	.num_consumer_supplies	= ARRAY_SIZE(omap4_vcxio_supply),
	.consumer_supplies	= omap4_vcxio_supply,
	.supply_regulator	= "V2V1",
};

static struct regulator_init_data omap4_vusb_idata = {
	.constraints = {
		.min_uV			= 3300000,
		.max_uV			= 3300000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
};

static struct regulator_init_data omap4_clk32kg_idata = {
	.constraints = {
		.valid_ops_mask		= REGULATOR_CHANGE_STATUS,
	},
};

static struct regulator_consumer_supply omap4_vdd1_supply[] = {
	REGULATOR_SUPPLY("vcc", "cpu0"),
};

static struct regulator_consumer_supply omap4_vdd2_supply[] = {
	REGULATOR_SUPPLY("vcc", "iva.0"),
};

static struct regulator_consumer_supply omap4_vdd3_supply[] = {
	REGULATOR_SUPPLY("vcc", "l3_main.0"),
};

static struct regulator_init_data omap4_vdd1 = {
	.constraints = {
		.name			= "vdd_mpu",
		.min_uV			= 500000,
		.max_uV			= 1500000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE,
	},
	.num_consumer_supplies		= ARRAY_SIZE(omap4_vdd1_supply),
	.consumer_supplies		= omap4_vdd1_supply,
};

static struct regulator_init_data omap4_vdd2 = {
	.constraints = {
		.name			= "vdd_iva",
		.min_uV			= 500000,
		.max_uV			= 1500000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE,
	},
	.num_consumer_supplies		= ARRAY_SIZE(omap4_vdd2_supply),
	.consumer_supplies		= omap4_vdd2_supply,
};

static struct regulator_init_data omap4_vdd3 = {
	.constraints = {
		.name			= "vdd_core",
		.min_uV			= 500000,
		.max_uV			= 1500000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL,
		.valid_ops_mask		= REGULATOR_CHANGE_VOLTAGE,
	},
	.num_consumer_supplies		= ARRAY_SIZE(omap4_vdd3_supply),
	.consumer_supplies		= omap4_vdd3_supply,
};


static struct twl_regulator_driver_data omap4_vdd1_drvdata = {
	.get_voltage = twl_get_voltage,
	.set_voltage = twl_set_voltage,
};

static struct twl_regulator_driver_data omap4_vdd2_drvdata = {
	.get_voltage = twl_get_voltage,
	.set_voltage = twl_set_voltage,
};

static struct twl_regulator_driver_data omap4_vdd3_drvdata = {
	.get_voltage = twl_get_voltage,
	.set_voltage = twl_set_voltage,
};

static struct regulator_consumer_supply omap4_v1v8_supply[] = {
	REGULATOR_SUPPLY("vio", "1-004b"),
};

static struct regulator_init_data omap4_v1v8_idata = {
	.constraints = {
		.min_uV			= 1800000,
		.max_uV			= 1800000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
		.always_on		= true,
	},
	.num_consumer_supplies	= ARRAY_SIZE(omap4_v1v8_supply),
	.consumer_supplies	= omap4_v1v8_supply,
};

static struct regulator_consumer_supply omap4_v2v1_supply[] = {
	REGULATOR_SUPPLY("v2v1", "1-004b"),
};

static struct regulator_init_data omap4_v2v1_idata = {
	.constraints = {
		.min_uV			= 2100000,
		.max_uV			= 2100000,
		.valid_modes_mask	= REGULATOR_MODE_NORMAL
					| REGULATOR_MODE_STANDBY,
		.valid_ops_mask		= REGULATOR_CHANGE_MODE
					| REGULATOR_CHANGE_STATUS,
	},
	.num_consumer_supplies	= ARRAY_SIZE(omap4_v2v1_supply),
	.consumer_supplies	= omap4_v2v1_supply,
};

void __init omap4_pmic_get_config(struct twl4030_platform_data *pmic_data,
				  u32 pdata_flags, u32 regulators_flags)
{
	if (!pmic_data->vdd1) {
		omap4_vdd1.driver_data = &omap4_vdd1_drvdata;
		omap4_vdd1_drvdata.data = voltdm_lookup("mpu");
		pmic_data->vdd1 = &omap4_vdd1;
	}

	if (!pmic_data->vdd2) {
		omap4_vdd2.driver_data = &omap4_vdd2_drvdata;
		omap4_vdd2_drvdata.data = voltdm_lookup("iva");
		pmic_data->vdd2 = &omap4_vdd2;
	}

	if (!pmic_data->vdd3) {
		omap4_vdd3.driver_data = &omap4_vdd3_drvdata;
		omap4_vdd3_drvdata.data = voltdm_lookup("core");
		pmic_data->vdd3 = &omap4_vdd3;
	}

	/* Common platform data configurations */
	if (pdata_flags & TWL_COMMON_PDATA_USB && !pmic_data->usb)
		pmic_data->usb = &omap4_usb_pdata;

	/* Common regulator configurations */
	if (regulators_flags & TWL_COMMON_REGULATOR_VDAC && !pmic_data->vdac)
		pmic_data->vdac = &omap4_vdac_idata;

	if (regulators_flags & TWL_COMMON_REGULATOR_VAUX2 && !pmic_data->vaux2)
		pmic_data->vaux2 = &omap4_vaux2_idata;

	if (regulators_flags & TWL_COMMON_REGULATOR_VAUX3 && !pmic_data->vaux3)
		pmic_data->vaux3 = &omap4_vaux3_idata;

	if (regulators_flags & TWL_COMMON_REGULATOR_VMMC && !pmic_data->vmmc)
		pmic_data->vmmc = &omap4_vmmc_idata;

	if (regulators_flags & TWL_COMMON_REGULATOR_VPP && !pmic_data->vpp)
		pmic_data->vpp = &omap4_vpp_idata;

	if (regulators_flags & TWL_COMMON_REGULATOR_VANA && !pmic_data->vana)
		pmic_data->vana = &omap4_vana_idata;

	if (regulators_flags & TWL_COMMON_REGULATOR_VCXIO && !pmic_data->vcxio)
		pmic_data->vcxio = &omap4_vcxio_idata;

	if (regulators_flags & TWL_COMMON_REGULATOR_VUSB && !pmic_data->vusb)
		pmic_data->vusb = &omap4_vusb_idata;

	if (regulators_flags & TWL_COMMON_REGULATOR_CLK32KG &&
	    !pmic_data->clk32kg)
		pmic_data->clk32kg = &omap4_clk32kg_idata;

	if (regulators_flags & TWL_COMMON_REGULATOR_V1V8 && !pmic_data->v1v8)
		pmic_data->v1v8 = &omap4_v1v8_idata;

	if (regulators_flags & TWL_COMMON_REGULATOR_V2V1 && !pmic_data->v2v1)
		pmic_data->v2v1 = &omap4_v2v1_idata;
}
#endif /* CONFIG_ARCH_OMAP4 */

#if defined(CONFIG_SND_OMAP_SOC_OMAP_TWL4030) || \
	defined(CONFIG_SND_OMAP_SOC_OMAP_TWL4030_MODULE)
#include <linux/platform_data/omap-twl4030.h>

static struct omap_tw4030_pdata omap_twl4030_audio_data;

static struct platform_device audio_device = {
	.name		= "omap-twl4030",
	.id		= -1,
	.dev = {
		.platform_data = &omap_twl4030_audio_data,
	},
};

void __init omap_twl4030_audio_init(char *card_name)
{
	omap_twl4030_audio_data.card_name = card_name;
	platform_device_register(&audio_device);
}

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