[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_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", "mpu.0"),
};

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);
9495d1e2	76	omap_pmic_init(1, 400, pmic_type, 7 + OMAP44XX_IRQ_GIC_START, pmic_data);
8eaeb939	77
9495d1e2 PU	78	/* Register additional devices on i2c1 bus if needed */
	79	if (devices)
	80	i2c_register_board_info(1, devices, nr_devices);
8eaeb939 PU	81	}
8eaeb939 PU	82
46232a36 KH	83	void __init omap_pmic_late_init(void)
46232a36 KH	84	{
9495d1e2 PU	85	/* Init the OMAP TWL parameters (if PMIC has been registerd) */
	86	if (!pmic_i2c_board_info.irq)
	87	return;
	88
	89	omap3_twl_init();
	90	omap4_twl_init();
46232a36 KH	91	}
46232a36 KH	92
d12d1fca	93	#if defined(CONFIG_ARCH_OMAP3)
827ed9ae PU	94	static struct twl4030_usb_data omap3_usb_pdata = {
	95	.usb_mode = T2_USB_MODE_ULPI,
	96	};
	97
	98	static int omap3_batt_table[] = {
	99	/* 0 C */
	100	30800, 29500, 28300, 27100,
	101	26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
	102	17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
	103	11600, 11200, 10800, 10400, 10000, 9630, 9280, 8950, 8620, 8310,
	104	8020, 7730, 7460, 7200, 6950, 6710, 6470, 6250, 6040, 5830,
	105	5640, 5450, 5260, 5090, 4920, 4760, 4600, 4450, 4310, 4170,
	106	4040, 3910, 3790, 3670, 3550
	107	};
	108
	109	static struct twl4030_bci_platform_data omap3_bci_pdata = {
	110	.battery_tmp_tbl = omap3_batt_table,
	111	.tblsize = ARRAY_SIZE(omap3_batt_table),
	112	};
	113
	114	static struct twl4030_madc_platform_data omap3_madc_pdata = {
	115	.irq_line = 1,
	116	};
	117
4ae6df5e	118	static struct twl4030_codec_data omap3_codec;
827ed9ae	119
4ae6df5e	120	static struct twl4030_audio_data omap3_audio_pdata = {
827ed9ae	121	.audio_mclk = 26000000,
4ae6df5e	122	.codec = &omap3_codec,
827ed9ae PU	123	};
827ed9ae PU	124
b252b0ef PU	125	static struct regulator_consumer_supply omap3_vdda_dac_supplies[] = {
	126	REGULATOR_SUPPLY("vdda_dac", "omapdss_venc"),
	127	};
	128
	129	static struct regulator_init_data omap3_vdac_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_vdda_dac_supplies),
	139	.consumer_supplies = omap3_vdda_dac_supplies,
	140	};
	141
	142	static struct regulator_consumer_supply omap3_vpll2_supplies[] = {
	143	REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
7c68dd96	144	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.0"),
b252b0ef PU	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
23e22a5e	160	static struct regulator_consumer_supply omap3_vdd1_supply[] = {
24d7b40a	161	REGULATOR_SUPPLY("vcc", "cpu0"),
23e22a5e TK	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
49c008ec TK	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
d12d1fca PU	202	void __init omap3_pmic_get_config(struct twl4030_platform_data *pmic_data,
	203	u32 pdata_flags, u32 regulators_flags)
	204	{
49c008ec TK	205	if (!pmic_data->vdd1) {
	206	omap3_vdd1.driver_data = &omap3_vdd1_drvdata;
	207	omap3_vdd1_drvdata.data = voltdm_lookup("mpu_iva");
23e22a5e	208	pmic_data->vdd1 = &omap3_vdd1;
49c008ec TK	209	}
	210	if (!pmic_data->vdd2) {
	211	omap3_vdd2.driver_data = &omap3_vdd2_drvdata;
	212	omap3_vdd2_drvdata.data = voltdm_lookup("core");
23e22a5e	213	pmic_data->vdd2 = &omap3_vdd2;
49c008ec	214	}
d12d1fca PU	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 = {
d12d1fca PU	240	};
d12d1fca PU	241
8a3d895b TV	242	static struct regulator_consumer_supply omap4_vdda_hdmi_dac_supplies[] = {
	243	REGULATOR_SUPPLY("vdda_hdmi_dac", "omapdss_hdmi"),
	244	};
	245
b22f954b PU	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	},
8a3d895b TV	255	.num_consumer_supplies = ARRAY_SIZE(omap4_vdda_hdmi_dac_supplies),
8a3d895b TV	256	.consumer_supplies = omap4_vdda_hdmi_dac_supplies,
fde0190d	257	.supply_regulator = "V2V1",
b22f954b PU	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
4e6a0ab0 TV	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
b22f954b PU	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,
4e6a0ab0	344	.always_on = true,
b22f954b	345	},
4e6a0ab0 TV	346	.num_consumer_supplies = ARRAY_SIZE(omap4_vcxio_supply),
4e6a0ab0 TV	347	.consumer_supplies = omap4_vcxio_supply,
fde0190d	348	.supply_regulator = "V2V1",
b22f954b PU	349	};
	350
	351	static struct regulator_init_data omap4_vusb_idata = {
	352	.constraints = {
	353	.min_uV = 3300000,
	354	.max_uV = 3300000,
b22f954b PU	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
e160dda0 TK	368	static struct regulator_consumer_supply omap4_vdd1_supply[] = {
	369	REGULATOR_SUPPLY("vcc", "mpu.0"),
	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
fde0190d PU	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
b22f954b PU	467	void __init omap4_pmic_get_config(struct twl4030_platform_data *pmic_data,
	468	u32 pdata_flags, u32 regulators_flags)
	469	{
e160dda0 TK	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
b22f954b PU	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;
fde0190d PU	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;
b22f954b	526	}
d12d1fca	527	#endif /* CONFIG_ARCH_OMAP4 */
552d9dc3 PU	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	static struct omap_tw4030_pdata omap_twl4030_audio_data;
	534
	535	static struct platform_device audio_device = {
	536	.name = "omap-twl4030",
	537	.id = -1,
	538	.dev = {
	539	.platform_data = &omap_twl4030_audio_data,
	540	},
	541	};
	542
	543	void __init omap_twl4030_audio_init(char *card_name)
	544	{
	545	omap_twl4030_audio_data.card_name = card_name;
	546	platform_device_register(&audio_device);
	547	}
	548
	549	#else /* SOC_OMAP_TWL4030 */
eda21d37	550	void __init omap_twl4030_audio_init(char *card_name)
552d9dc3 PU	551	{
	552	return;
	553	}
	554	#endif /* SOC_OMAP_TWL4030 */