static void __init kona_i2c_init(void)
{
	u32 r;

	omap_i2c_hwspinlock_init(1, 0, &kona_i2c_1_bus_pdata);
	omap_i2c_hwspinlock_init(2, 1, &kona_i2c_2_bus_pdata);
	omap_i2c_hwspinlock_init(3, 2, &kona_i2c_3_bus_pdata);
	omap_i2c_hwspinlock_init(4, 3, &kona_i2c_4_bus_pdata);

	omap_register_i2c_bus_board_data(1, &kona_i2c_1_bus_pdata);
	omap_register_i2c_bus_board_data(2, &kona_i2c_2_bus_pdata);
	omap_register_i2c_bus_board_data(3, &kona_i2c_3_bus_pdata);
	omap_register_i2c_bus_board_data(4, &kona_i2c_4_bus_pdata);
	/*
	 * Phoenix Audio IC needs I2C1 to
	 * start with 400 KHz or less
	 */
	omap_register_i2c_bus(1, 400, NULL, 0);
	omap_register_i2c_bus(2, 400, kona_i2c_board_info,
			      ARRAY_SIZE(kona_i2c_board_info));
	omap_register_i2c_bus(3, 400, NULL, 0);
	omap_register_i2c_bus(4, 400, NULL, 0);

	r = omap4_ctrl_pad_readl(OMAP4_CTRL_MODULE_PAD_CORE_CONTROL_I2C_0);
	r |= (1 << OMAP4_I2C3_SDA_PULLUPRESX_SHIFT);
	r |= (1 << OMAP4_I2C3_SCL_PULLUPRESX_SHIFT);
	omap4_ctrl_pad_writel(r, OMAP4_CTRL_MODULE_PAD_CORE_CONTROL_I2C_0);
}
static int __init omap4_i2c_init(void)
{
	int i2c_bus_devices = 0;

	omap_i2c_hwspinlock_init(1, 0, &mapphone_i2c_1_bus_pdata);
	omap_i2c_hwspinlock_init(2, 1, &mapphone_i2c_2_bus_pdata);
	omap_i2c_hwspinlock_init(3, 2, &mapphone_i2c_3_bus_pdata);
	omap_i2c_hwspinlock_init(4, 3, &mapphone_i2c_4_bus_pdata);

	omap_register_i2c_bus_board_data(1, &mapphone_i2c_1_bus_pdata);
	omap_register_i2c_bus_board_data(2, &mapphone_i2c_2_bus_pdata);
	omap_register_i2c_bus_board_data(3, &mapphone_i2c_3_bus_pdata);
	omap_register_i2c_bus_board_data(4, &mapphone_i2c_4_bus_pdata);

	/* Populate I2C bus 1 devices */
	i2c_bus_devices = initialize_i2c_bus_info(
			1, mapphone_i2c_bus1_board_info,
			I2C_BUS_MAX_DEVICES,
			mapphone_i2c_1_boardinfo,
			ARRAY_SIZE(mapphone_i2c_1_boardinfo));
	omap_register_i2c_bus(1, 400,
			mapphone_i2c_bus1_board_info, i2c_bus_devices);

	/* Populate I2C bus 2 devices */
	i2c_bus_devices = initialize_i2c_bus_info(
			2, mapphone_i2c_bus2_board_info,
			I2C_BUS_MAX_DEVICES,
			mapphone_i2c_2_boardinfo,
			ARRAY_SIZE(mapphone_i2c_2_boardinfo));
	omap_register_i2c_bus(2, 400,
			mapphone_i2c_bus2_board_info, i2c_bus_devices);

	/* Populate I2C bus 3 devices */
	i2c_bus_devices = initialize_i2c_bus_info(
			3, mapphone_i2c_bus3_board_info,
			I2C_BUS_MAX_DEVICES,
			mapphone_i2c_3_boardinfo,
			ARRAY_SIZE(mapphone_i2c_3_boardinfo));
	omap_register_i2c_bus(3, 400,
			mapphone_i2c_bus3_board_info, i2c_bus_devices);

	/* Populate I2C bus 4 devices */
	i2c_bus_devices = initialize_i2c_bus_info(
			4, mapphone_i2c_bus4_board_info,
			I2C_BUS_MAX_DEVICES,
			mapphone_i2c_4_boardinfo,
			ARRAY_SIZE(mapphone_i2c_4_boardinfo));
	omap_register_i2c_bus(4, 400,
			mapphone_i2c_bus4_board_info, i2c_bus_devices);

	/*
	 * This will allow unused regulator to be shutdown. This flag
	 * should be set in the board file. Before regulators are registered.
	 */
	regulator_has_full_constraints();

	return 0;
}
static void __init t1_i2c_init(void)
{
	u32 reg_val;
	/* Disable internal pull ups for i2c 1 and 2
				and enable for i2c 3 and 4 */
	reg_val = omap4_ctrl_pad_readl(
			OMAP4_CTRL_MODULE_PAD_CORE_CONTROL_I2C_0);
	PULLUP_DISABLE(reg_val, SCL, I2C1);
	PULLUP_DISABLE(reg_val, SDA, I2C1);
	PULLUP_DISABLE(reg_val, SCL, I2C2);
	PULLUP_DISABLE(reg_val, SDA, I2C2);
	PULLUP_ENABLE(reg_val, SCL, I2C3);
	PULLUP_ENABLE(reg_val, SDA, I2C3);
	PULLUP_ENABLE(reg_val, SCL, I2C4);
	PULLUP_ENABLE(reg_val, SDA, I2C4);
	SET_LOAD(reg_val, SCL, I2C3, LOAD_860_OHM);
	SET_LOAD(reg_val, SDA, I2C3, LOAD_860_OHM);
	SET_LOAD(reg_val, SCL, I2C4, LOAD_860_OHM);
	SET_LOAD(reg_val, SDA, I2C4, LOAD_860_OHM);
	omap4_ctrl_pad_writel(reg_val,
			OMAP4_CTRL_MODULE_PAD_CORE_CONTROL_I2C_0);

	/* 860 k, SR Enable Internal Pull up */
	reg_val = omap4_ctrl_wk_pad_readl(
			OMAP4_CTRL_MODULE_PAD_WKUP_CONTROL_I2C_2);
	PULLUP_ENABLE(reg_val, SCL, SR);
	PULLUP_ENABLE(reg_val, SDA, SR);
	SET_LOAD(reg_val, SCL, SR, LOAD_860_OHM);
	SET_LOAD(reg_val, SDA, SR, LOAD_860_OHM);
	omap4_ctrl_wk_pad_writel(reg_val,
			OMAP4_CTRL_MODULE_PAD_WKUP_CONTROL_I2C_2);

	omap_i2c_hwspinlock_init(1, 0, &t1_i2c1_bus_pdata);
	omap_i2c_hwspinlock_init(2, 1, &t1_i2c2_bus_pdata);
	omap_i2c_hwspinlock_init(3, 2, &t1_i2c3_bus_pdata);
	omap_i2c_hwspinlock_init(4, 3, &t1_i2c4_bus_pdata);

	omap_register_i2c_bus_board_data(1, &t1_i2c1_bus_pdata);
	omap_register_i2c_bus_board_data(2, &t1_i2c2_bus_pdata);
	omap_register_i2c_bus_board_data(3, &t1_i2c3_bus_pdata);
	omap_register_i2c_bus_board_data(4, &t1_i2c4_bus_pdata);

	/*
	 * Phoenix Audio IC needs I2C1 to
	 * start with 400 KHz or less
	 */
#ifdef CONFIG_REGULATOR_TPS6130X
	omap_register_i2c_bus(1, 400, t1_i2c1_board_info,
			      ARRAY_SIZE(t1_i2c_board_info));
#else
	omap_register_i2c_bus(1, 400, NULL, 0);
#endif
	omap_register_i2c_bus(2, 400, t1_i2c_board_info,
			      ARRAY_SIZE(t1_i2c_board_info));
	omap_register_i2c_bus(3, 400, NULL, 0);
	omap_register_i2c_bus(4, 400, NULL, 0);
}
static int __init omap4_i2c_init(void)
{
	omap_i2c_hwspinlock_init(1, 0, &ovation_i2c_1_bus_pdata);
	omap_i2c_hwspinlock_init(2, 1, &ovation_i2c_2_bus_pdata);
	omap_i2c_hwspinlock_init(3, 2, &ovation_i2c_3_bus_pdata);

	omap_register_i2c_bus_board_data(1, &ovation_i2c_1_bus_pdata);
	omap_register_i2c_bus_board_data(2, &ovation_i2c_2_bus_pdata);
	omap_register_i2c_bus_board_data(3, &ovation_i2c_3_bus_pdata);

	bn_power_init();

	//set kxtf9 address
	if (system_rev >= OVATION_EVT1A) {
		printk(KERN_INFO "kxtf9 i2c address = 0xe \n");
		ovation_i2c_kxtf9_boardinfo.addr = 0xe;
	}
	i2c_register_board_info(1, &ovation_i2c_kxtf9_boardinfo, 1);

	if (system_rev >= OVATION_EVT1B) {
		i2c_register_board_info(1, &ovation_i2c_bq27520_boardinfo, 1);
		i2c_register_board_info(1, &ovation_i2c_bq24196_boardinfo, 1);
	}

	/* Disable i2c2, same pins for uart1 console */
	//omap_register_i2c_bus(2, 400, NULL, 0);

	//i2c_register_board_info(3, ovation_i2c_3_boardinfo,
	//			ARRAY_SIZE(ovation_i2c_3_boardinfo));
	omap_register_i2c_bus(3, 400, NULL, 0);

	// Disable the strong pull-ups on I2C3 and I2C4
	omap2_i2c_pullups_en_dis(3, 0);

	/*
	 * This will allow unused regulator to be shutdown. This flag
	 * should be set in the board file. Before regulators are registered.
	 */
	regulator_has_full_constraints();

	/*
	 * Drive MSECURE high for TWL6030 write access.
	 */
	omap_mux_init_signal("fref_clk0_out.gpio_wk6", OMAP_PIN_OUTPUT);
	gpio_request(6, "msecure");
	gpio_direction_output(6, 1);

	return 0;
}
Beispiel #5
0
static int __init omap4_i2c_init(void)
{
	omap_i2c_hwspinlock_init(1, 0, &sdp4430_i2c_1_bus_pdata);
	omap_i2c_hwspinlock_init(2, 1, &sdp4430_i2c_2_bus_pdata);
	omap_i2c_hwspinlock_init(3, 2, &sdp4430_i2c_3_bus_pdata);
	omap_i2c_hwspinlock_init(4, 3, &sdp4430_i2c_4_bus_pdata);

	omap_register_i2c_bus_board_data(1, &sdp4430_i2c_1_bus_pdata);
	omap_register_i2c_bus_board_data(2, &sdp4430_i2c_2_bus_pdata);
	omap_register_i2c_bus_board_data(3, &sdp4430_i2c_3_bus_pdata);
	omap_register_i2c_bus_board_data(4, &sdp4430_i2c_4_bus_pdata);

	omap4_pmic_init("twl6030", &tablet_twldata); //	i2c_register_board_info(1, &sdp4430_i2c_boardinfo, 1);

#ifdef CONFIG_INPUT_KXTF9
	kxtf9_gpio_for_irq = 66;
	sdp4430_i2c_boardinfo[I2C_INDEX_1_KXTF9].irq = OMAP_GPIO_IRQ(kxtf9_gpio_for_irq);
	kxtf9_dev_init();
#endif //CONFIG_INPUT_KXTF9
#ifdef CONFIG_BATTERY_MAX17042
	max17042_gpio_for_irq = 65;
	sdp4430_i2c_boardinfo[I2C_INDEX_1_MAX17042].irq = OMAP_GPIO_IRQ(max17042_gpio_for_irq);
	max17042_dev_init();
#endif //CONFIG_BATTERY_MAX17042
	i2c_register_board_info(1, sdp4430_i2c_boardinfo, ARRAY_SIZE(sdp4430_i2c_boardinfo));
	i2c_register_board_info(2, tablet_i2c_3_boardinfo, ARRAY_SIZE(tablet_i2c_3_boardinfo));
	omap_register_i2c_bus(2, 400, NULL, 0);
	omap_register_i2c_bus(3, 400, NULL, 0);
	omap_register_i2c_bus(4, 400, NULL, 0);

	omap2_i2c_pullup(3, I2C_PULLUP_STD_860_OM_FAST_500_OM);

	/*
	 * This will allow unused regulator to be shutdown. This flag
	 * should be set in the board file. Before regulators are registered.
	 */
	regulator_has_full_constraints();

	/*
	 * Drive MSECURE high for TWL6030 write access.
	 */
	omap_mux_init_signal("fref_clk0_out.gpio_wk6", OMAP_PIN_OUTPUT);
	gpio_request(6, "msecure");
	gpio_direction_output(6, 1);

	return 0;
}
static int __init omap4_i2c_init(void)
{
	omap_i2c_hwspinlock_init(1, 0, &sdp4430_i2c_1_bus_pdata);
	omap_i2c_hwspinlock_init(2, 1, &sdp4430_i2c_2_bus_pdata);
	omap_i2c_hwspinlock_init(3, 2, &sdp4430_i2c_3_bus_pdata);
	omap_i2c_hwspinlock_init(4, 3, &sdp4430_i2c_4_bus_pdata);

	omap_register_i2c_bus_board_data(1, &sdp4430_i2c_1_bus_pdata);
	omap_register_i2c_bus_board_data(2, &sdp4430_i2c_2_bus_pdata);
	omap_register_i2c_bus_board_data(3, &sdp4430_i2c_3_bus_pdata);
	omap_register_i2c_bus_board_data(4, &sdp4430_i2c_4_bus_pdata);

	/*
	 * VCORE3 & VMEM are not used in 4460. By register it to regulator
	 * framework will ensures that resources are disabled.
	 */
	if (cpu_is_omap446x()) {
		tablet_twldata.vdd3 = &tablet_vcore3;
		tablet_twldata.vmem = &tablet_vmem;
	}

	omap4_pmic_init("twl6030", &tablet_twldata);
	i2c_register_board_info(1, sdp4430_i2c_boardinfo,
				ARRAY_SIZE(sdp4430_i2c_boardinfo));
	omap_register_i2c_bus(2, 400, NULL, 0);
	omap_register_i2c_bus(3, 400, tablet_i2c_3_boardinfo,
				ARRAY_SIZE(tablet_i2c_3_boardinfo));
	omap_register_i2c_bus(4, 400, NULL, 0);

	omap2_i2c_pullup(3, I2C_PULLUP_STD_860_OM_FAST_500_OM);

	/*
	 * This will allow unused regulator to be shutdown. This flag
	 * should be set in the board file. Before regulators are registered.
	 */
	regulator_has_full_constraints();

	/*
	 * Drive MSECURE high for TWL6030 write access.
	 */
	omap_mux_init_signal("fref_clk0_out.gpio_wk6", OMAP_PIN_OUTPUT);
	gpio_request(6, "msecure");
	gpio_direction_output(6, 1);

	return 0;
}
static int __init omap4_i2c_init(void)
{

	omap_i2c_hwspinlock_init(1, 0, &sdp4430_i2c_1_bus_pdata);
	omap_i2c_hwspinlock_init(2, 1, &sdp4430_i2c_2_bus_pdata);
	omap_i2c_hwspinlock_init(3, 2, &sdp4430_i2c_3_bus_pdata);
	omap_i2c_hwspinlock_init(4, 3, &sdp4430_i2c_4_bus_pdata);

	omap_register_i2c_bus_board_data(1, &sdp4430_i2c_1_bus_pdata);
	omap_register_i2c_bus_board_data(2, &sdp4430_i2c_2_bus_pdata);
	omap_register_i2c_bus_board_data(3, &sdp4430_i2c_3_bus_pdata);
	omap_register_i2c_bus_board_data(4, &sdp4430_i2c_4_bus_pdata);

	omap4_pmic_init("twl6030", &sdp4430_twldata);
	/*SW5, Jamestsai, 1213, enable cypress{*/
	//omap_register_i2c_bus(2, 400, NULL, 0);
	omap_register_i2c_bus(2, 400, sdp4430_i2c_2_boardinfo, 
				ARRAY_SIZE(sdp4430_i2c_2_boardinfo));
	/*}SW5, Jamestsai, 1213, enable cypress*/
        /* JossCheng, 20111221, change clock of i2c bus3 to be 400K Hz { */
	omap_register_i2c_bus(3, 400, sdp4430_i2c_3_boardinfo,
				ARRAY_SIZE(sdp4430_i2c_3_boardinfo));
        /* JossCheng, 20111221, change clock of i2c bus3 to be 400K Hz } */
	omap_register_i2c_bus(4, 400, sdp4430_i2c_4_boardinfo,
				ARRAY_SIZE(sdp4430_i2c_4_boardinfo));

#ifdef CONFIG_MACH_OMAP4_BOWSER_SUBTYPE_JEM
	omap2_i2c_pullup(3, I2C_PULLUP_STD_860_OM_FAST_500_OM);
#endif

	/*
	 * This will allow unused regulator to be shutdown. This flag
	 * should be set in the board file. Before regulators are registered.
	 */
	regulator_has_full_constraints();

	/*
	 * Drive MSECURE high for TWL6030/6032 write access.
	 */
	omap_mux_init_signal("fref_clk3_req.gpio_wk30", OMAP_PIN_OUTPUT); 
	gpio_request(30, "msecure");
	gpio_direction_output(30, 1);

	return 0;
}
static void __init espresso_i2c_init(void)
{
	omap_i2c_hwspinlock_init(1, 0, &espresso_i2c_1_bus_pdata);
	omap_i2c_hwspinlock_init(2, 1, &espresso_i2c_2_bus_pdata);
	omap_i2c_hwspinlock_init(3, 2, &espresso_i2c_3_bus_pdata);
	omap_i2c_hwspinlock_init(4, 3, &espresso_i2c_4_bus_pdata);

	omap_register_i2c_bus_board_data(1, &espresso_i2c_1_bus_pdata);
	omap_register_i2c_bus_board_data(2, &espresso_i2c_2_bus_pdata);
	omap_register_i2c_bus_board_data(3, &espresso_i2c_3_bus_pdata);
	omap_register_i2c_bus_board_data(4, &espresso_i2c_4_bus_pdata);
	/*
	 * Phoenix Audio IC needs I2C1 to
	 * start with 400 KHz or less
	 */
	omap_register_i2c_bus(1, 400, NULL, 0);
	omap_register_i2c_bus(2, 400, espresso_i2c_board_info,
			      ARRAY_SIZE(espresso_i2c_board_info));
	omap_register_i2c_bus(3, 400, NULL, 0);
	omap_register_i2c_bus(4, 400, NULL, 0);
}
static int __init omap4_i2c_init(void)
{
	omap_i2c_hwspinlock_init(1, 0, &sdp4430_i2c_bus_pdata);
	omap_i2c_hwspinlock_init(2, 1, &sdp4430_i2c_2_bus_pdata);
	omap_i2c_hwspinlock_init(3, 2, &sdp4430_i2c_3_bus_pdata);
	omap_i2c_hwspinlock_init(4, 3, &sdp4430_i2c_4_bus_pdata);

	regulator_has_full_constraints();

	/*
	 * Phoenix Audio IC needs I2C1 to
	 * start with 400 KHz or less
	 */
	omap_register_i2c_bus(1, 400, &sdp4430_i2c_bus_pdata,
			sdp4430_i2c_boardinfo, ARRAY_SIZE(sdp4430_i2c_boardinfo));
	omap_register_i2c_bus(2, 400, &sdp4430_i2c_2_bus_pdata,
			sdp4430_i2c_2_boardinfo, ARRAY_SIZE(sdp4430_i2c_2_boardinfo));
	omap_register_i2c_bus(3, 400, &sdp4430_i2c_3_bus_pdata,
			sdp4430_i2c_3_boardinfo, ARRAY_SIZE(sdp4430_i2c_3_boardinfo));
	omap_register_i2c_bus(4, 400, &sdp4430_i2c_4_bus_pdata,
			sdp4430_i2c_4_boardinfo, ARRAY_SIZE(sdp4430_i2c_4_boardinfo));
	return 0;
}
static int __init omap4_i2c_init(void)
{

	omap_i2c_hwspinlock_init(1, 0, &sdp4430_i2c_1_bus_pdata);
	omap_i2c_hwspinlock_init(2, 1, &sdp4430_i2c_2_bus_pdata);
	omap_i2c_hwspinlock_init(3, 2, &sdp4430_i2c_3_bus_pdata);
	omap_i2c_hwspinlock_init(4, 3, &sdp4430_i2c_4_bus_pdata);

	omap_register_i2c_bus_board_data(1, &sdp4430_i2c_1_bus_pdata);
	omap_register_i2c_bus_board_data(2, &sdp4430_i2c_2_bus_pdata);
	omap_register_i2c_bus_board_data(3, &sdp4430_i2c_3_bus_pdata);
	omap_register_i2c_bus_board_data(4, &sdp4430_i2c_4_bus_pdata);

	omap4_power_init();
	i2c_register_board_info(1, sdp4430_i2c_boardinfo,
				ARRAY_SIZE(sdp4430_i2c_boardinfo));
	omap_register_i2c_bus(2, 400, NULL, 0);
	omap_register_i2c_bus(3, 400, sdp4430_i2c_3_boardinfo,
				ARRAY_SIZE(sdp4430_i2c_3_boardinfo));
	omap_register_i2c_bus(4, 400, sdp4430_i2c_4_boardinfo,
				ARRAY_SIZE(sdp4430_i2c_4_boardinfo));

	/*
	 * This will allow unused regulator to be shutdown. This flag
	 * should be set in the board file. Before regulators are registered.
	 */
	regulator_has_full_constraints();

	/*
	 * Drive MSECURE high for TWL6030/6032 write access.
	 */
	omap_mux_init_signal("fref_clk0_out.gpio_wk6", OMAP_PIN_OUTPUT);
	gpio_request(6, "msecure");
	gpio_direction_output(6, 1);

	return 0;
}
static int __init omap4_i2c_init(void)
{
	omap_i2c_hwspinlock_init(1, 0, &board_i2c_1_bus_pdata);
	omap_i2c_hwspinlock_init(2, 1, &board_i2c_2_bus_pdata);
	omap_i2c_hwspinlock_init(3, 2, &board_i2c_3_bus_pdata);
	omap_i2c_hwspinlock_init(4, 3, &board_i2c_4_bus_pdata);

	omap_register_i2c_bus_board_data(1, &board_i2c_1_bus_pdata);
	omap_register_i2c_bus_board_data(2, &board_i2c_2_bus_pdata);
	omap_register_i2c_bus_board_data(3, &board_i2c_3_bus_pdata);
	omap_register_i2c_bus_board_data(4, &board_i2c_4_bus_pdata);

	omap4_pmic_init("twl6030", &board_twldata);
	omap_register_i2c_bus(2, 100, board_i2c_2_boardinfo, 
			ARRAY_SIZE(board_i2c_2_boardinfo)); // FIXME speed
	omap_register_i2c_bus(3, 100, board_i2c_3_boardinfo, 
			ARRAY_SIZE(board_i2c_3_boardinfo)); // FIXME speed
	omap_register_i2c_bus(4, 400, NULL, 0);

	/*
	 * This will allow unused regulator to be shutdown. This flag
	 * should be set in the board file. Before regulators are registered.
	 */
	regulator_has_full_constraints();

	/* To access twl registers we enable gpio_wk30
	 * we need this so the RTC driver can work.
	 */
	gpio_request(GPIO_MSECURE, "MSECURE");
	gpio_direction_output(GPIO_MSECURE, 1);

	omap_mux_init_gpio(GPIO_MSECURE, \
		OMAP_PIN_OUTPUT | OMAP_PIN_OFF_NONE);

	return 0;
}
static int __init omap4_panda_i2c_init(void)
{
	omap_i2c_hwspinlock_init(1, 0, &panda_i2c_1_bus_pdata);
	omap_i2c_hwspinlock_init(2, 1, &panda_i2c_2_bus_pdata);
	omap_i2c_hwspinlock_init(3, 2, &panda_i2c_3_bus_pdata);
	omap_i2c_hwspinlock_init(4, 3, &panda_i2c_4_bus_pdata);

	omap_register_i2c_bus_board_data(1, &panda_i2c_1_bus_pdata);
	omap_register_i2c_bus_board_data(2, &panda_i2c_2_bus_pdata);
	omap_register_i2c_bus_board_data(3, &panda_i2c_3_bus_pdata);
	omap_register_i2c_bus_board_data(4, &panda_i2c_4_bus_pdata);

	omap4_pmic_get_config(&omap4_panda_twldata, TWL_COMMON_PDATA_USB,
			TWL_COMMON_REGULATOR_VDAC |
			TWL_COMMON_REGULATOR_VAUX2 |
			TWL_COMMON_REGULATOR_VAUX3 |
			TWL_COMMON_REGULATOR_VMMC |
			TWL_COMMON_REGULATOR_VPP |
			TWL_COMMON_REGULATOR_VANA |
			TWL_COMMON_REGULATOR_VCXIO |
			TWL_COMMON_REGULATOR_VUSB |
			TWL_COMMON_REGULATOR_CLK32KG |
			TWL_COMMON_REGULATOR_V1V8 |
			TWL_COMMON_REGULATOR_V2V1);
	omap4_pmic_init("twl6030", &omap4_panda_twldata,
			&twl6040_data, OMAP44XX_IRQ_SYS_2N);
	omap_register_i2c_bus(2, 400, NULL, 0);
	/*
	 * Bus 3 is attached to the DVI port where devices like the pico DLP
	 * projector don't work reliably with 400kHz
	 */
	omap_register_i2c_bus(3, 100, panda_i2c_eeprom,
					ARRAY_SIZE(panda_i2c_eeprom));
	omap_register_i2c_bus(4, 400, NULL, 0);
	return 0;
}