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

#ifdef CONFIG_ARCH_OMAP4
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*/
	unsigned int irq;

	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);
	irq = omap4_xlate_irq(7 + OMAP44XX_IRQ_GIC_START);
	omap_pmic_init(1, 400, pmic_type, irq, pmic_data);

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

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

	omap3_twl_init();
	omap4_twl_init();
}

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

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

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

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

static struct twl4030_codec_data omap3_codec;

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

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

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

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