[linux-2.6-block.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),
	},
};

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);
}

void __init omap_pmic_init(int bus, u32 clkrate,
			   const char *pmic_type, int pmic_irq,
			   struct twl4030_platform_data *pmic_data)
{
	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 registerd) */
	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->irq_base)
		pmic_data->irq_base = TWL4030_IRQ_BASE;
	if (!pmic_data->irq_end)
		pmic_data->irq_end = TWL4030_IRQ_END;
	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->irq_base)
		pmic_data->irq_base = TWL6030_IRQ_BASE;
	if (!pmic_data->irq_end)
		pmic_data->irq_end = TWL6030_IRQ_END;

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