[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 "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,
};

static struct i2c_board_info __initdata omap4_i2c1_board_info[] = {
	{
		.addr		= 0x48,
		.flags		= I2C_CLIENT_WAKE,
	},
	{
		I2C_BOARD_INFO("twl6040", 0x4b),
	},
};

#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 twl6040_platform_data *twl6040_data, int twl6040_irq)
{
	/* PMIC part*/
	omap_mux_init_signal("sys_nirq1", OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_WAKEUPENABLE);
	strncpy(omap4_i2c1_board_info[0].type, pmic_type,
		sizeof(omap4_i2c1_board_info[0].type));
	omap4_i2c1_board_info[0].irq = OMAP44XX_IRQ_SYS_1N;
	omap4_i2c1_board_info[0].platform_data = pmic_data;

	/* TWL6040 audio IC part */
	omap4_i2c1_board_info[1].irq = twl6040_irq;
	omap4_i2c1_board_info[1].platform_data = twl6040_data;

	omap_register_i2c_bus(1, 400, omap4_i2c1_board_info, 2);

}

void __init omap_pmic_late_init(void)
{
	/* Init the OMAP TWL parameters (if PMIC has been registered) */
	if (pmic_i2c_board_info.irq)
		omap3_twl_init();
	if (omap4_i2c1_board_info[0].irq)
		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", "mpu.0"),
};

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 = {
	.phy_init	= omap4430_phy_init,
	.phy_exit	= omap4430_phy_exit,
	.phy_power	= omap4430_phy_power,
	.phy_set_clock	= omap4430_phy_set_clk,
	.phy_suspend	= omap4430_phy_suspend,
};

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