[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/string.h>
#include <linux/phy/phy.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/fixed.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);
	strlcpy(pmic_i2c_board_info.type, pmic_type,
		sizeof(pmic_i2c_board_info.type));
	pmic_i2c_board_info.irq = pmic_irq;
	pmic_i2c_board_info.platform_data = pmic_data;

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

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

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

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

	omap3_twl_init();
	omap4_twl_init();
}

#if defined(CONFIG_ARCH_OMAP3)
struct phy_consumer consumers[] = {
	PHY_CONSUMER("musb-hdrc.0", "usb"),
};

struct phy_init_data init_data = {
	.consumers = consumers,
	.num_consumers = ARRAY_SIZE(consumers),
};

static struct twl4030_usb_data omap3_usb_pdata = {
	.usb_mode	= T2_USB_MODE_ULPI,
	.init_data	= &init_data,
};

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_dpi.0"),
	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.0"),
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/* Commonly used configuration */
static struct omap_tw4030_pdata omap_twl4030_audio_data;

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

void omap_twl4030_audio_init(char *card_name,
				    struct omap_tw4030_pdata *pdata)
{
	if (!pdata)
		pdata = &omap_twl4030_audio_data;

	pdata->card_name = card_name;

	audio_device.dev.platform_data = pdata;
	platform_device_register(&audio_device);
}

#else /* SOC_OMAP_TWL4030 */
void omap_twl4030_audio_init(char *card_name,
				    struct omap_tw4030_pdata *pdata)
{
	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>
c8d4bafe	26	#include <linux/string.h>
6c27f939	27	#include <linux/phy/phy.h>
b22f954b PU	28	#include <linux/regulator/machine.h>
b22f954b PU	29	#include <linux/regulator/fixed.h>
a53b8e3b	30
dbc04161	31	#include "soc.h"
a53b8e3b	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
da0085ff	42	#if defined(CONFIG_ARCH_OMAP3) \|\| defined(CONFIG_ARCH_OMAP4)
49c008ec TK	43	static int twl_set_voltage(void *data, int target_uV)
	44	{
	45	struct voltagedomain voltdm = (struct voltagedomain )data;
	46	return voltdm_scale(voltdm, target_uV);
	47	}
	48
	49	static int twl_get_voltage(void *data)
	50	{
	51	struct voltagedomain voltdm = (struct voltagedomain )data;
	52	return voltdm_get_voltage(voltdm);
	53	}
da0085ff	54	#endif
49c008ec	55
a53b8e3b PU	56	void __init omap_pmic_init(int bus, u32 clkrate,
	57	const char *pmic_type, int pmic_irq,
	58	struct twl4030_platform_data *pmic_data)
	59	{
265a2bc8	60	omap_mux_init_signal("sys_nirq", OMAP_PIN_INPUT_PULLUP \| OMAP_PIN_OFF_WAKEUPENABLE);
c8d4bafe	61	strlcpy(pmic_i2c_board_info.type, pmic_type,
a53b8e3b PU	62	sizeof(pmic_i2c_board_info.type));
	63	pmic_i2c_board_info.irq = pmic_irq;
	64	pmic_i2c_board_info.platform_data = pmic_data;
	65
	66	omap_register_i2c_bus(bus, clkrate, &pmic_i2c_board_info, 1);
	67	}
b22f954b	68
8eaeb939 PU	69	void __init omap4_pmic_init(const char *pmic_type,
8eaeb939 PU	70	struct twl4030_platform_data *pmic_data,
9495d1e2	71	struct i2c_board_info *devices, int nr_devices)
8eaeb939 PU	72	{
8eaeb939 PU	73	/* PMIC part*/
5941b814	74	omap_mux_init_signal("sys_nirq1", OMAP_PIN_INPUT_PULLUP \| OMAP_PIN_OFF_WAKEUPENABLE);
1ef43369	75	omap_mux_init_signal("fref_clk0_out.sys_drm_msecure", OMAP_PIN_OUTPUT);
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)
6c27f939 KVA	94	struct phy_consumer consumers[] = {
	95	PHY_CONSUMER("musb-hdrc.0", "usb"),
	96	};
	97
	98	struct phy_init_data init_data = {
	99	.consumers = consumers,
	100	.num_consumers = ARRAY_SIZE(consumers),
	101	};
	102
827ed9ae PU	103	static struct twl4030_usb_data omap3_usb_pdata = {
827ed9ae PU	104	.usb_mode = T2_USB_MODE_ULPI,
6c27f939	105	.init_data = &init_data,
827ed9ae PU	106	};
	107
	108	static int omap3_batt_table[] = {
	109	/* 0 C */
	110	30800, 29500, 28300, 27100,
	111	26000, 24900, 23900, 22900, 22000, 21100, 20300, 19400, 18700, 17900,
	112	17200, 16500, 15900, 15300, 14700, 14100, 13600, 13100, 12600, 12100,
	113	11600, 11200, 10800, 10400, 10000, 9630, 9280, 8950, 8620, 8310,
	114	8020, 7730, 7460, 7200, 6950, 6710, 6470, 6250, 6040, 5830,
	115	5640, 5450, 5260, 5090, 4920, 4760, 4600, 4450, 4310, 4170,
	116	4040, 3910, 3790, 3670, 3550
	117	};
	118
	119	static struct twl4030_bci_platform_data omap3_bci_pdata = {
	120	.battery_tmp_tbl = omap3_batt_table,
	121	.tblsize = ARRAY_SIZE(omap3_batt_table),
	122	};
	123
	124	static struct twl4030_madc_platform_data omap3_madc_pdata = {
	125	.irq_line = 1,
	126	};
	127
4ae6df5e	128	static struct twl4030_codec_data omap3_codec;
827ed9ae	129
4ae6df5e	130	static struct twl4030_audio_data omap3_audio_pdata = {
827ed9ae	131	.audio_mclk = 26000000,
4ae6df5e	132	.codec = &omap3_codec,
827ed9ae PU	133	};
827ed9ae PU	134
b252b0ef PU	135	static struct regulator_consumer_supply omap3_vdda_dac_supplies[] = {
	136	REGULATOR_SUPPLY("vdda_dac", "omapdss_venc"),
	137	};
	138
	139	static struct regulator_init_data omap3_vdac_idata = {
	140	.constraints = {
	141	.min_uV = 1800000,
	142	.max_uV = 1800000,
	143	.valid_modes_mask = REGULATOR_MODE_NORMAL
	144	\| REGULATOR_MODE_STANDBY,
	145	.valid_ops_mask = REGULATOR_CHANGE_MODE
	146	\| REGULATOR_CHANGE_STATUS,
	147	},
	148	.num_consumer_supplies = ARRAY_SIZE(omap3_vdda_dac_supplies),
	149	.consumer_supplies = omap3_vdda_dac_supplies,
	150	};
	151
	152	static struct regulator_consumer_supply omap3_vpll2_supplies[] = {
	153	REGULATOR_SUPPLY("vdds_dsi", "omapdss"),
1f92a1a4	154	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dpi.0"),
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	171	static struct regulator_consumer_supply omap3_vdd1_supply[] = {
24d7b40a	172	REGULATOR_SUPPLY("vcc", "cpu0"),
23e22a5e TK	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	{
49c008ec TK	216	if (!pmic_data->vdd1) {
	217	omap3_vdd1.driver_data = &omap3_vdd1_drvdata;
	218	omap3_vdd1_drvdata.data = voltdm_lookup("mpu_iva");
23e22a5e	219	pmic_data->vdd1 = &omap3_vdd1;
49c008ec TK	220	}
	221	if (!pmic_data->vdd2) {
	222	omap3_vdd2.driver_data = &omap3_vdd2_drvdata;
	223	omap3_vdd2_drvdata.data = voltdm_lookup("core");
23e22a5e	224	pmic_data->vdd2 = &omap3_vdd2;
49c008ec	225	}
d12d1fca PU	226
	227	/* Common platform data configurations */
	228	if (pdata_flags & TWL_COMMON_PDATA_USB && !pmic_data->usb)
	229	pmic_data->usb = &omap3_usb_pdata;
	230
	231	if (pdata_flags & TWL_COMMON_PDATA_BCI && !pmic_data->bci)
	232	pmic_data->bci = &omap3_bci_pdata;
	233
	234	if (pdata_flags & TWL_COMMON_PDATA_MADC && !pmic_data->madc)
	235	pmic_data->madc = &omap3_madc_pdata;
	236
	237	if (pdata_flags & TWL_COMMON_PDATA_AUDIO && !pmic_data->audio)
	238	pmic_data->audio = &omap3_audio_pdata;
	239
	240	/* Common regulator configurations */
	241	if (regulators_flags & TWL_COMMON_REGULATOR_VDAC && !pmic_data->vdac)
	242	pmic_data->vdac = &omap3_vdac_idata;
	243
	244	if (regulators_flags & TWL_COMMON_REGULATOR_VPLL2 && !pmic_data->vpll2)
	245	pmic_data->vpll2 = &omap3_vpll2_idata;
	246	}
	247	#endif /* CONFIG_ARCH_OMAP3 */
	248
	249	#if defined(CONFIG_ARCH_OMAP4)
	250	static struct twl4030_usb_data omap4_usb_pdata = {
d12d1fca PU	251	};
d12d1fca PU	252
8a3d895b TV	253	static struct regulator_consumer_supply omap4_vdda_hdmi_dac_supplies[] = {
	254	REGULATOR_SUPPLY("vdda_hdmi_dac", "omapdss_hdmi"),
	255	};
	256
b22f954b PU	257	static struct regulator_init_data omap4_vdac_idata = {
	258	.constraints = {
	259	.min_uV = 1800000,
	260	.max_uV = 1800000,
	261	.valid_modes_mask = REGULATOR_MODE_NORMAL
	262	\| REGULATOR_MODE_STANDBY,
	263	.valid_ops_mask = REGULATOR_CHANGE_MODE
	264	\| REGULATOR_CHANGE_STATUS,
	265	},
8a3d895b TV	266	.num_consumer_supplies = ARRAY_SIZE(omap4_vdda_hdmi_dac_supplies),
8a3d895b TV	267	.consumer_supplies = omap4_vdda_hdmi_dac_supplies,
fde0190d	268	.supply_regulator = "V2V1",
b22f954b PU	269	};
	270
	271	static struct regulator_init_data omap4_vaux2_idata = {
	272	.constraints = {
	273	.min_uV = 1200000,
	274	.max_uV = 2800000,
	275	.apply_uV = true,
	276	.valid_modes_mask = REGULATOR_MODE_NORMAL
	277	\| REGULATOR_MODE_STANDBY,
	278	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	279	\| REGULATOR_CHANGE_MODE
	280	\| REGULATOR_CHANGE_STATUS,
	281	},
	282	};
	283
	284	static struct regulator_init_data omap4_vaux3_idata = {
	285	.constraints = {
	286	.min_uV = 1000000,
	287	.max_uV = 3000000,
	288	.apply_uV = true,
	289	.valid_modes_mask = REGULATOR_MODE_NORMAL
	290	\| REGULATOR_MODE_STANDBY,
	291	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	292	\| REGULATOR_CHANGE_MODE
	293	\| REGULATOR_CHANGE_STATUS,
	294	},
	295	};
	296
	297	static struct regulator_consumer_supply omap4_vmmc_supply[] = {
	298	REGULATOR_SUPPLY("vmmc", "omap_hsmmc.0"),
	299	};
	300
	301	/* VMMC1 for MMC1 card */
	302	static struct regulator_init_data omap4_vmmc_idata = {
	303	.constraints = {
	304	.min_uV = 1200000,
	305	.max_uV = 3000000,
	306	.apply_uV = true,
	307	.valid_modes_mask = REGULATOR_MODE_NORMAL
	308	\| REGULATOR_MODE_STANDBY,
	309	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	310	\| REGULATOR_CHANGE_MODE
	311	\| REGULATOR_CHANGE_STATUS,
	312	},
	313	.num_consumer_supplies = ARRAY_SIZE(omap4_vmmc_supply),
	314	.consumer_supplies = omap4_vmmc_supply,
	315	};
	316
	317	static struct regulator_init_data omap4_vpp_idata = {
	318	.constraints = {
	319	.min_uV = 1800000,
	320	.max_uV = 2500000,
	321	.apply_uV = true,
	322	.valid_modes_mask = REGULATOR_MODE_NORMAL
	323	\| REGULATOR_MODE_STANDBY,
	324	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE
	325	\| REGULATOR_CHANGE_MODE
	326	\| REGULATOR_CHANGE_STATUS,
	327	},
	328	};
	329
	330	static struct regulator_init_data omap4_vana_idata = {
	331	.constraints = {
	332	.min_uV = 2100000,
333	.max_uV = 2100000,
334	.valid_modes_mask = REGULATOR_MODE_NORMAL
335	\| REGULATOR_MODE_STANDBY,
336	.valid_ops_mask = REGULATOR_CHANGE_MODE
337	\| REGULATOR_CHANGE_STATUS,
338	},
339	};
340
4e6a0ab0 TV	341	static struct regulator_consumer_supply omap4_vcxio_supply[] = {
	342	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dss"),
	343	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.0"),
	344	REGULATOR_SUPPLY("vdds_dsi", "omapdss_dsi.1"),
	345	};
	346
b22f954b PU	347	static struct regulator_init_data omap4_vcxio_idata = {
	348	.constraints = {
	349	.min_uV = 1800000,
	350	.max_uV = 1800000,
	351	.valid_modes_mask = REGULATOR_MODE_NORMAL
	352	\| REGULATOR_MODE_STANDBY,
	353	.valid_ops_mask = REGULATOR_CHANGE_MODE
	354	\| REGULATOR_CHANGE_STATUS,
4e6a0ab0	355	.always_on = true,
b22f954b	356	},
4e6a0ab0 TV	357	.num_consumer_supplies = ARRAY_SIZE(omap4_vcxio_supply),
4e6a0ab0 TV	358	.consumer_supplies = omap4_vcxio_supply,
fde0190d	359	.supply_regulator = "V2V1",
b22f954b PU	360	};
	361
	362	static struct regulator_init_data omap4_vusb_idata = {
	363	.constraints = {
	364	.min_uV = 3300000,
	365	.max_uV = 3300000,
b22f954b PU	366	.valid_modes_mask = REGULATOR_MODE_NORMAL
	367	\| REGULATOR_MODE_STANDBY,
	368	.valid_ops_mask = REGULATOR_CHANGE_MODE
	369	\| REGULATOR_CHANGE_STATUS,
	370	},
	371	};
	372
	373	static struct regulator_init_data omap4_clk32kg_idata = {
	374	.constraints = {
	375	.valid_ops_mask = REGULATOR_CHANGE_STATUS,
	376	},
	377	};
	378
e160dda0	379	static struct regulator_consumer_supply omap4_vdd1_supply[] = {
73c503cb	380	REGULATOR_SUPPLY("vcc", "cpu0"),
e160dda0 TK	381	};
	382
	383	static struct regulator_consumer_supply omap4_vdd2_supply[] = {
	384	REGULATOR_SUPPLY("vcc", "iva.0"),
	385	};
	386
	387	static struct regulator_consumer_supply omap4_vdd3_supply[] = {
	388	REGULATOR_SUPPLY("vcc", "l3_main.0"),
	389	};
	390
	391	static struct regulator_init_data omap4_vdd1 = {
	392	.constraints = {
	393	.name = "vdd_mpu",
	394	.min_uV = 500000,
	395	.max_uV = 1500000,
	396	.valid_modes_mask = REGULATOR_MODE_NORMAL,
	397	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
	398	},
	399	.num_consumer_supplies = ARRAY_SIZE(omap4_vdd1_supply),
	400	.consumer_supplies = omap4_vdd1_supply,
	401	};
	402
	403	static struct regulator_init_data omap4_vdd2 = {
	404	.constraints = {
	405	.name = "vdd_iva",
	406	.min_uV = 500000,
	407	.max_uV = 1500000,
	408	.valid_modes_mask = REGULATOR_MODE_NORMAL,
	409	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
	410	},
	411	.num_consumer_supplies = ARRAY_SIZE(omap4_vdd2_supply),
	412	.consumer_supplies = omap4_vdd2_supply,
	413	};
	414
	415	static struct regulator_init_data omap4_vdd3 = {
	416	.constraints = {
	417	.name = "vdd_core",
	418	.min_uV = 500000,
	419	.max_uV = 1500000,
	420	.valid_modes_mask = REGULATOR_MODE_NORMAL,
	421	.valid_ops_mask = REGULATOR_CHANGE_VOLTAGE,
	422	},
	423	.num_consumer_supplies = ARRAY_SIZE(omap4_vdd3_supply),
	424	.consumer_supplies = omap4_vdd3_supply,
	425	};
	426
	427
	428	static struct twl_regulator_driver_data omap4_vdd1_drvdata = {
	429	.get_voltage = twl_get_voltage,
	430	.set_voltage = twl_set_voltage,
	431	};
	432
	433	static struct twl_regulator_driver_data omap4_vdd2_drvdata = {
	434	.get_voltage = twl_get_voltage,
	435	.set_voltage = twl_set_voltage,
	436	};
	437
	438	static struct twl_regulator_driver_data omap4_vdd3_drvdata = {
	439	.get_voltage = twl_get_voltage,
	440	.set_voltage = twl_set_voltage,
	441	};
	442
fde0190d PU	443	static struct regulator_consumer_supply omap4_v1v8_supply[] = {
	444	REGULATOR_SUPPLY("vio", "1-004b"),
	445	};
	446
	447	static struct regulator_init_data omap4_v1v8_idata = {
	448	.constraints = {
	449	.min_uV = 1800000,
	450	.max_uV = 1800000,
	451	.valid_modes_mask = REGULATOR_MODE_NORMAL
	452	\| REGULATOR_MODE_STANDBY,
	453	.valid_ops_mask = REGULATOR_CHANGE_MODE
	454	\| REGULATOR_CHANGE_STATUS,
	455	.always_on = true,
	456	},
	457	.num_consumer_supplies = ARRAY_SIZE(omap4_v1v8_supply),
	458	.consumer_supplies = omap4_v1v8_supply,
	459	};
	460
	461	static struct regulator_consumer_supply omap4_v2v1_supply[] = {
	462	REGULATOR_SUPPLY("v2v1", "1-004b"),
	463	};
	464
	465	static struct regulator_init_data omap4_v2v1_idata = {
	466	.constraints = {
	467	.min_uV = 2100000,
	468	.max_uV = 2100000,
	469	.valid_modes_mask = REGULATOR_MODE_NORMAL
	470	\| REGULATOR_MODE_STANDBY,
	471	.valid_ops_mask = REGULATOR_CHANGE_MODE
	472	\| REGULATOR_CHANGE_STATUS,
	473	},
	474	.num_consumer_supplies = ARRAY_SIZE(omap4_v2v1_supply),
	475	.consumer_supplies = omap4_v2v1_supply,
	476	};
	477
b22f954b PU	478	void __init omap4_pmic_get_config(struct twl4030_platform_data *pmic_data,
	479	u32 pdata_flags, u32 regulators_flags)
	480	{
e160dda0 TK	481	if (!pmic_data->vdd1) {
	482	omap4_vdd1.driver_data = &omap4_vdd1_drvdata;
	483	omap4_vdd1_drvdata.data = voltdm_lookup("mpu");
	484	pmic_data->vdd1 = &omap4_vdd1;
	485	}
	486
	487	if (!pmic_data->vdd2) {
	488	omap4_vdd2.driver_data = &omap4_vdd2_drvdata;
	489	omap4_vdd2_drvdata.data = voltdm_lookup("iva");
	490	pmic_data->vdd2 = &omap4_vdd2;
	491	}
	492
	493	if (!pmic_data->vdd3) {
	494	omap4_vdd3.driver_data = &omap4_vdd3_drvdata;
	495	omap4_vdd3_drvdata.data = voltdm_lookup("core");
	496	pmic_data->vdd3 = &omap4_vdd3;
	497	}
	498
b22f954b PU	499	/* Common platform data configurations */
	500	if (pdata_flags & TWL_COMMON_PDATA_USB && !pmic_data->usb)
	501	pmic_data->usb = &omap4_usb_pdata;
	502
	503	/* Common regulator configurations */
	504	if (regulators_flags & TWL_COMMON_REGULATOR_VDAC && !pmic_data->vdac)
	505	pmic_data->vdac = &omap4_vdac_idata;
	506
	507	if (regulators_flags & TWL_COMMON_REGULATOR_VAUX2 && !pmic_data->vaux2)
	508	pmic_data->vaux2 = &omap4_vaux2_idata;
	509
	510	if (regulators_flags & TWL_COMMON_REGULATOR_VAUX3 && !pmic_data->vaux3)
	511	pmic_data->vaux3 = &omap4_vaux3_idata;
	512
	513	if (regulators_flags & TWL_COMMON_REGULATOR_VMMC && !pmic_data->vmmc)
	514	pmic_data->vmmc = &omap4_vmmc_idata;
	515
	516	if (regulators_flags & TWL_COMMON_REGULATOR_VPP && !pmic_data->vpp)
	517	pmic_data->vpp = &omap4_vpp_idata;
	518
	519	if (regulators_flags & TWL_COMMON_REGULATOR_VANA && !pmic_data->vana)
	520	pmic_data->vana = &omap4_vana_idata;
	521
	522	if (regulators_flags & TWL_COMMON_REGULATOR_VCXIO && !pmic_data->vcxio)
	523	pmic_data->vcxio = &omap4_vcxio_idata;
	524
	525	if (regulators_flags & TWL_COMMON_REGULATOR_VUSB && !pmic_data->vusb)
	526	pmic_data->vusb = &omap4_vusb_idata;
	527
	528	if (regulators_flags & TWL_COMMON_REGULATOR_CLK32KG &&
	529	!pmic_data->clk32kg)
	530	pmic_data->clk32kg = &omap4_clk32kg_idata;
fde0190d PU	531
	532	if (regulators_flags & TWL_COMMON_REGULATOR_V1V8 && !pmic_data->v1v8)
	533	pmic_data->v1v8 = &omap4_v1v8_idata;
	534
	535	if (regulators_flags & TWL_COMMON_REGULATOR_V2V1 && !pmic_data->v2v1)
	536	pmic_data->v2v1 = &omap4_v2v1_idata;
b22f954b	537	}
d12d1fca	538	#endif /* CONFIG_ARCH_OMAP4 */
552d9dc3 PU	539
	540	#if defined(CONFIG_SND_OMAP_SOC_OMAP_TWL4030) \|\| \
	541	defined(CONFIG_SND_OMAP_SOC_OMAP_TWL4030_MODULE)
	542	#include <linux/platform_data/omap-twl4030.h>
	543
02553f5a	544	/* Commonly used configuration */
552d9dc3 PU	545	static struct omap_tw4030_pdata omap_twl4030_audio_data;
	546
	547	static struct platform_device audio_device = {
	548	.name = "omap-twl4030",
	549	.id = -1,
552d9dc3 PU	550	};
552d9dc3 PU	551
6689c875	552	void omap_twl4030_audio_init(char *card_name,
40234bf7	553	struct omap_tw4030_pdata *pdata)
552d9dc3	554	{
40234bf7 PU	555	if (!pdata)
	556	pdata = &omap_twl4030_audio_data;
	557
	558	pdata->card_name = card_name;
	559
	560	audio_device.dev.platform_data = pdata;
552d9dc3 PU	561	platform_device_register(&audio_device);
	562	}
	563
	564	#else /* SOC_OMAP_TWL4030 */
6689c875	565	void omap_twl4030_audio_init(char *card_name,
40234bf7	566	struct omap_tw4030_pdata *pdata)
552d9dc3 PU	567	{
	568	return;
	569	}
	570	#endif /* SOC_OMAP_TWL4030 */