static void __init board_init(void)
{
	int package = OMAP_PACKAGE_CBS;
	int status;

	omap_board_config = board_config;
	omap_board_config_size = ARRAY_SIZE(board_config);

	board_set_osc_timings();

	if (omap_rev() == OMAP4430_REV_ES1_0)
		package = OMAP_PACKAGE_CBL;
	omap4_mux_init(board_mux, NULL, package);

	archos_memory_init();

	omap4_i2c_init();
	board_buttons_init();

	archos_usb_musb_init(&archos_vbus_info);
	archos_audio_twl6040_init(&twl6040_codec);
	archos_accel_mma8453q_init(&board_mma8453q_pdata);
	archos_compass_init(&board_akm8975_pdata);
	archos_battery_twl4030_bci_init(&board_bci_data);

	omap4_leds_init();

	platform_add_devices(a80h_devices, ARRAY_SIZE(a80h_devices));

	board_touch_init();
	wake_lock_init(&st_wk_lock, WAKE_LOCK_SUSPEND, "st_wake_lock");
	board_serial_init();
	board_wifi_init();

	usb_musb_init(&musb_board_data);

	omap4_twl6030_hsmmc_init(mmc);

	archos_omap4_ehci_init();
	archos_camera_mt9m114_init();

	omap_dmm_init();
	omap_board_display_init();

	archos_hsusb_ext_regulator_init();
	archos_hub_vcc_regulator_init();

	enable_board_wakeup_source();

	hardware_comp.tps62361 = 1;

	/* Vsel0 = gpio, vsel1 = gnd */
	status = omap_tps6236x_board_setup(true, TPS62361_GPIO, -1,
				OMAP_PIN_OFF_OUTPUT_HIGH, -1);
	if (status)
		pr_err("TPS62361 initialization failed: %d\n", status);

	omap_enable_smartreflex_on_init();

	if (omap_rev() >= OMAP4430_REV_ES2_3)
		if (enable_suspend_off)
			omap_pm_enable_off_mode();
}
static void __init board_init(void)
{
	int num_displays = 0;

	omap_board_config = board_config;
	omap_board_config_size = ARRAY_SIZE(board_config);

	init_unused();
	
#ifdef CONFIG_CLOCKS_INIT
	archos_clocks_init(&board_clocks);
#endif	
	archos_leds_init();	// set it here mask hugly transitions 

	/* before omap_i2c_init() or IRQ will not forwarded to driver */
	if (display_config.nrev > hardware_rev)
		archos_hdmi_gpio_init(&display_config.rev[hardware_rev]);
	
	msecure_init();
	/* offmode config, before I2C config! */
	board_offmode_config();
	omap_i2c_init();
	/* Fix to prevent VIO leakage on wl127x */
	wl127x_vio_leakage_fix();

#if defined CONFIG_OMAP2_DSS
	if (archos_lcd_panel_init(&board_lcd_device) == 0) {
		board_dss_devices[num_displays++] = &board_lcd_device;
		board_dss_data.default_device = &board_lcd_device;
	}
	board_dss_devices[num_displays++] = &board_hdmi_device;
#ifdef CONFIG_OMAP2_DSS_DUMMY
	board_dss_devices[num_displays++] = &board_dummy_device;
	board_dss_data.default_device = &board_dummy_device;
#endif /* CONFIG_OMAP2_DSS_DUMMY */
	board_dss_data.num_devices = num_displays;
#endif/* CONFIG_OMAP2_DSS */

	platform_add_devices(board_devices, ARRAY_SIZE(board_devices));

	omap_cfg_reg(H20_3430_UART3_RX_IRRX);
	omap_serial_init();
	usb_musb_init();

	archos_usb_ohci_init();

	archos_accel_init(&board_mma7660fc_pdata);

	if ( hardware_rev < 2 ) {
		ads7846_dev_init();
	}

	archos_mmc1_setup_gpios(&mmc[0], &board_vmmc_ext);
	twl4030_mmc_init(mmc);
	board_vmmc_ext_supply.dev = mmc[0].dev;
	board_vmmc2_supply.dev = mmc[1].dev;
	
	archos_audio_gpio_init();

	archos_camera_ov7675_init();
	archos_keys_init();
	enable_board_wakeup_source();
}
static void __init omap_4430sdp_init(void)
{
	int status;
	int package = OMAP_PACKAGE_CBS;

	if (omap_rev() == OMAP4430_REV_ES1_0)
		package = OMAP_PACKAGE_CBL;
	omap4_mux_init(board_mux, NULL, package);

	if (cpu_is_omap447x())
		omap_emif_setup_device_details(&emif_devices_4470,
					       &emif_devices_4470);
	else
		omap_emif_setup_device_details(&emif_devices, &emif_devices);

	omap_board_config = sdp4430_config;
	omap_board_config_size = ARRAY_SIZE(sdp4430_config);

	omap_init_board_version(0);

	omap4_audio_conf();
	omap4_create_board_props();
	blaze_pmic_mux_init();
	blaze_set_osc_timings();
	omap4_i2c_init();
	blaze_sensor_init();
	blaze_touch_init();
	omap4_register_ion();
	platform_add_devices(sdp4430_devices, ARRAY_SIZE(sdp4430_devices));
	wake_lock_init(&st_wk_lock, WAKE_LOCK_SUSPEND, "st_wake_lock");
	board_serial_init();
	omap4_sdp4430_wifi_init();
	omap4_twl6030_hsmmc_init(mmc);

	/* blaze_modem_init shall be called before omap4_ehci_ohci_init */
	if (!strcmp(modem_ipc, "hsi"))
		blaze_modem_init(true);
	else
		blaze_modem_init(false);

	omap4_ehci_ohci_init();

	usb_musb_init(&musb_board_data);

	status = omap_ethernet_init();
	if (status) {
		pr_err("Ethernet initialization failed: %d\n", status);
	} else {
		sdp4430_spi_board_info[0].irq = gpio_to_irq(ETH_KS8851_IRQ);
		spi_register_board_info(sdp4430_spi_board_info,
				ARRAY_SIZE(sdp4430_spi_board_info));
	}

	status = omap4_keyboard_init(&sdp4430_keypad_data);
	if (status)
		pr_err("Keypad initialization failed: %d\n", status);

	omap_dmm_init();
	omap_4430sdp_display_init();
	blaze_panel_init();
	blaze_keypad_init();
	init_duty_governor();
	if (cpu_is_omap446x()) {
		/* Vsel0 = gpio, vsel1 = gnd */
		status = omap_tps6236x_board_setup(true, TPS62361_GPIO, -1,
					OMAP_PIN_OFF_OUTPUT_HIGH, -1);
		if (status)
			pr_err("TPS62361 initialization failed: %d\n", status);
	}

	omap_enable_smartreflex_on_init();
	if (enable_suspend_off)
		omap_pm_enable_off_mode();

}
static void __init omap_4430sdp_init(void)
{
	int package = OMAP_PACKAGE_CBS;

	if (omap_rev() == OMAP4430_REV_ES1_0)
		package = OMAP_PACKAGE_CBL;
	omap4_mux_init(board_mux, NULL, package);

	lpddr_init();

	omap_board_config = sdp4430_config;
	omap_board_config_size = ARRAY_SIZE(sdp4430_config);

	omap_init_board_version(0);

	omap4_create_board_props();
	blaze_pmic_mux_init();
	
	omap4_i2c_init();
	/* JossCheng, 20111221, Porting gyro sensor and e-compass {*/	
#ifdef CONFIG_MPU_SENSORS_MPU6050B1
	mpu6050b1_init();
#endif
	/* JossCheng, 20111221, Porting gyro sensor and e-compass }*/
	//blaze_sensor_init();
// Anvoi, 2011/12/14, Porting Light sensor driver to ICS
	omap4_als_init();
// Anvoi, 2011/12/14, Porting Light sensor driver to ICS
	//blaze_touch_init();
	omap4_register_ion();
/*SW5, Anvoi, 20111215, Config key VolumeUp/VolumeDown{*/	
	platform_add_devices(bowser_devices, ARRAY_SIZE(bowser_devices));
/*SW5, Anvoi, 20111215, Config key VolumeUp/VolumeDown}*/
	board_serial_init();
	omap4_twl6030_hsmmc_init(mmc);
	bowser_wifi_init();
	omap4_sdp4430_bt_init();

	omap4_ehci_ohci_init();
	usb_musb_init(&musb_board_data);

// BokeeLi, 2011/12/14, Porting proximity driver
#ifdef CONFIG_INPUT_PIC12LF1822_PROXIMITY
	omap4_proximity_init();
#endif
// BokeeLi, 2011/12/14, Porting proximity driver

/*SW5, Jamestsai, 1213, enable cypress{*/
#if defined(CONFIG_TOUCHSCREEN_CYPRESS_TTSP) || (CONFIG_TOUCHSCREEN_ATMEL_MXT)
	omap4_touch_init();
#endif
/*}SW5, Jamestsai, 1213, enable cypress*/

#ifdef CONFIG_MACH_OMAP4_BOWSER_SUBTYPE_JEM
	jem_dev_init();
#endif

	omap_dmm_init();

	//omap_4430sdp_display_init();
	bowser_panel_init();


	omap_enable_smartreflex_on_init();
        if (enable_suspend_off)
                omap_pm_enable_off_mode();

}
Beispiel #5
0
static void __init omap3_evm_init(void)
{
	omap3_evm_get_revision();

	if (get_omap3_evm_rev() >= OMAP3EVM_BOARD_GEN_2)
		omap3evm_twldata.vaux2 = &omap3evm_vaux2;
	else
		omap3evm_twldata.vusb = &omap3_evm_vusb;

	if (cpu_is_omap3630())
		omap3_mux_init(omap36x_board_mux, OMAP_PACKAGE_CBB);
	else
		omap3_mux_init(omap35x_board_mux, OMAP_PACKAGE_CBB);

	omap3_evm_i2c_init();

	platform_add_devices(omap3_evm_devices, ARRAY_SIZE(omap3_evm_devices));

	spi_register_board_info(omap3evm_spi_board_info,
				ARRAY_SIZE(omap3evm_spi_board_info));

	omap_serial_init();

	/* OMAP3EVM uses ISP1504 phy and so register nop transceiver */
	usb_nop_xceiv_register(0);

	if (get_omap3_evm_rev() >= OMAP3EVM_BOARD_GEN_2) {
		/* enable EHCI VBUS using GPIO22 */
		omap_mux_init_gpio(22, OMAP_PIN_INPUT_PULLUP);
		gpio_request(OMAP3_EVM_EHCI_VBUS, "enable EHCI VBUS");
		gpio_direction_output(OMAP3_EVM_EHCI_VBUS, 0);
		gpio_set_value(OMAP3_EVM_EHCI_VBUS, 1);

		/* Select EHCI port on main board */
		omap_mux_init_gpio(61, OMAP_PIN_INPUT_PULLUP);
		gpio_request(OMAP3_EVM_EHCI_SELECT, "select EHCI port");
		gpio_direction_output(OMAP3_EVM_EHCI_SELECT, 0);
		gpio_set_value(OMAP3_EVM_EHCI_SELECT, 0);

		/* setup EHCI phy reset config */
		omap_mux_init_gpio(21, OMAP_PIN_INPUT_PULLUP);
		ehci_pdata.reset_gpio_port[1] = 21;

		/* EVM REV >= E can supply 500mA with EXTVBUS programming */
		musb_board_data.power = 500;
		musb_board_data.extvbus = 1;
	} else {
		/* setup EHCI phy reset on MDC */
		omap_mux_init_gpio(135, OMAP_PIN_OUTPUT);
		ehci_pdata.reset_gpio_port[1] = 135;
	}
	usb_musb_init(&musb_board_data);
	usb_ehci_init(&ehci_pdata);
	ads7846_dev_init();
	omap3evm_init_smsc911x();
	omap3_evm_display_init();
	/* NAND */
	board_nand_init(omap3_evm_nand_partitions,
			ARRAY_SIZE(omap3_evm_nand_partitions),
			0, NAND_BUSWIDTH_16);
	board_onenand_init(omap3_evm_onenand_partitions,
			ARRAY_SIZE(omap3_evm_onenand_partitions), 0);
}
static void __init ti81xx_evm_init(void)
{
	omap_serial_init();
	omap_sdrc_init(NULL, NULL);
	usb_musb_init(&musb_board_data);
}
Beispiel #7
0
static void __init omap3_evm_init(void)
{
	omap3_evm_get_revision();

	if (cpu_is_omap3630())
		omap3_mux_init(omap36x_board_mux, OMAP_PACKAGE_CBB);
	else
		omap3_mux_init(omap35x_board_mux, OMAP_PACKAGE_CBB);

	omap_board_config = omap3_evm_config;
	omap_board_config_size = ARRAY_SIZE(omap3_evm_config);

	omap3_evm_i2c_init();

	omap_display_init(&omap3_evm_dss_data);

	spi_register_board_info(omap3evm_spi_board_info,
				ARRAY_SIZE(omap3evm_spi_board_info));

	omap_serial_init();

	/* OMAP3EVM uses ISP1504 phy and so register nop transceiver */
	usb_nop_xceiv_register();

	if (get_omap3_evm_rev() >= OMAP3EVM_BOARD_GEN_2) {
		/* enable EHCI VBUS using GPIO22 */
		omap_mux_init_gpio(22, OMAP_PIN_INPUT_PULLUP);
		gpio_request(OMAP3_EVM_EHCI_VBUS, "enable EHCI VBUS");
		gpio_direction_output(OMAP3_EVM_EHCI_VBUS, 0);
		gpio_set_value(OMAP3_EVM_EHCI_VBUS, 1);

		/* Select EHCI port on main board */
		omap_mux_init_gpio(61, OMAP_PIN_INPUT_PULLUP);
		gpio_request(OMAP3_EVM_EHCI_SELECT, "select EHCI port");
		gpio_direction_output(OMAP3_EVM_EHCI_SELECT, 0);
		gpio_set_value(OMAP3_EVM_EHCI_SELECT, 0);

		/* setup EHCI phy reset config */
		omap_mux_init_gpio(21, OMAP_PIN_INPUT_PULLUP);
		usbhs_bdata.reset_gpio_port[1] = 21;

		/* EVM REV >= E can supply 500mA with EXTVBUS programming */
		musb_board_data.power = 500;
		musb_board_data.extvbus = 1;
	} else {
		/* setup EHCI phy reset on MDC */
		omap_mux_init_gpio(135, OMAP_PIN_OUTPUT);
		usbhs_bdata.reset_gpio_port[1] = 135;
	}
	usb_musb_init(&musb_board_data);
	usbhs_init(&usbhs_bdata);
	ads7846_dev_init();
	omap3evm_init_smsc911x();
	omap3_evm_display_init();

#ifdef CONFIG_WL12XX_PLATFORM_DATA
	/* WL12xx WLAN Init */
	if (wl12xx_set_platform_data(&omap3evm_wlan_data))
		pr_err("error setting wl12xx data\n");
	platform_device_register(&omap3evm_wlan_regulator);
#endif
}
Beispiel #8
0
void __init evt_peripherals_init(void)
{
//&*&*&*SJ1_20110419, Add /proc file to display software and hardware version.
#if defined (CONFIG_PROCFS_DISPLAY_SW_HW_VERSION)
	get_share_region();	
#endif
//&*&*&*SJ2_20110419, Add /proc file to display software and hardware version.

//&*&*&*BC1_110615: fix the issue that system can not enter off mode
	twl4030_get_scripts(&evt_t2scripts_data);
//&*&*&*BC2_110615: fix the issue that system can not enter off mode

    
#ifdef CONFIG_ANDROID_RAM_CONSOLE
    platform_device_register(&ram_console_device);
#endif
    
    omap_i2c_init();
    platform_add_devices( evt_board_devices, ARRAY_SIZE(evt_board_devices) );
    platform_add_devices( evt_board_devices_2, ARRAY_SIZE(evt_board_devices_2) );
    
#ifdef CONFIG_ENCORE_MODEM_MGR
    if (is_encore_3g()) {
        platform_device_register(&encore_modem_mgr_device);
    }
#endif 

#ifdef CONFIG_SND_SOC_TLV320DAC3100
    audio_dac_3100_dev_init();
#endif
/***++++20110115, jimmySu add backlight driver for PWM***/
#ifdef CONFIG_LEDS_OMAP_DISPLAY
	gptimer8 = (unsigned long)ioremap(0x4903E000, 16);
//&*&*&*HC1_20110826, modify pwm init sequence
	//zoom_pwm_init();
	omap_set_primary_brightness(100);
//&*&*&*HC2_20110826, modify pwm init sequence
#endif // CONFIG_LEDS_OMAP_DISPLAY
/***-----20110115, jimmySu add backlight driver for PWM***/


    /* NOTE: Please deselect CONFIG_MACH_OMAP_USE_UART3 in order to init 
    *  only UART1 and UART2, all in the name of saving some power.
    */
    omap_serial_init(omap_serial_platform_data);
    evt_lcd_panel_init();
//    kxtf9_dev_init();

#ifdef CONFIG_BATTERY_MAX17042
    max17042_dev_init();
#endif

    usb_musb_init(&musb_board_data);

//&*&*&*SJ1_20110607
#if defined (CONFIG_ANDROID_FACTORY_DEFAULT_REBOOT)
	android_factory_default_init();
#endif
//&*&*&*SJ2_20110607
/*+++++20110902, JimmySu add board ID*/
	int board_id;

	board_id = ep_get_hardware_id();	
	switch(board_id)
	{ 
		case BOARD_ID_EVT1: 
			peripheral_hw_version =3;
			break;
		default:
			peripheral_hw_version =6;
			break;
	}
/*----20110902, JimmySu add board ID*/
}
Beispiel #9
0
static inline void __init overo_init_musb(void)
{
	usb_musb_init(NULL);
}
static void __init omap3_beagle_init(void)
{
	omap3_mux_init(board_mux, OMAP_PACKAGE_CBB);
	omap3_beagle_init_rev();

	if ((!strcmp(expansionboard_name, "zippy")) || (!strcmp(expansionboard_name, "zippy2")))
	{
		pr_info("Beagle expansionboard: initializing zippy mmc\n");
		platform_device_register(&omap_zippy_device);

		expansion_config.i2c_settings = EXPANSION_I2C_ZIPPY;
		expansion_config.mmc_settings = EXPANSION_MMC_ZIPPY;

		omap_mux_init_gpio(OMAP3BEAGLE_GPIO_ZIPPY_MMC_WP, OMAP_PIN_INPUT);
		omap_mux_init_gpio(OMAP3BEAGLE_GPIO_ZIPPY_MMC_CD, OMAP_PIN_INPUT);
	}

	if ((!strcmp(expansionboard_name, "bbtoys-wifi")) || (!strcmp(expansionboard_name, "lsr-com6l-adpt")))
	{
	#if defined(CONFIG_WL12XX) || defined(CONFIG_WL12XX_MODULE)
		pr_info("Beagle expansion: wl12xx: setting up gpio pinmux\n");

		omap_mux_init_gpio(OMAP_BEAGLE_FM_EN_BT_WU, OMAP_PIN_OUTPUT);
		omap_mux_init_gpio(OMAP_BEAGLE_BT_EN_GPIO, OMAP_PIN_OUTPUT);
		omap_mux_init_gpio(OMAP_BEAGLE_WLAN_EN_GPIO, OMAP_PIN_OUTPUT);

		omap_mux_init_gpio(OMAP_BEAGLE_WLAN_IRQ_GPIO, OMAP_PIN_INPUT_PULLUP);

		/* WLAN SDIO: MMC2 CLK */
		omap_mux_init_signal("sdmmc2_clk.sdmmc2_clk", OMAP_PIN_INPUT_PULLUP);

		/* WLAN SDIO: MMC2 CMD */
		omap_mux_init_signal("sdmmc2_cmd.sdmmc2_cmd", OMAP_PIN_INPUT_PULLUP);

		/* WLAN SDIO: MMC2 DAT[0-3] */
		omap_mux_init_signal("sdmmc2_dat0.sdmmc2_dat0", OMAP_PIN_INPUT_PULLUP);
		omap_mux_init_signal("sdmmc2_dat1.sdmmc2_dat1", OMAP_PIN_INPUT_PULLUP);
		omap_mux_init_signal("sdmmc2_dat2.sdmmc2_dat2", OMAP_PIN_INPUT_PULLUP);
		omap_mux_init_signal("sdmmc2_dat3.sdmmc2_dat3", OMAP_PIN_INPUT_PULLUP);

		expansion_config.mmc_settings = EXPANSION_MMC_WIFI;
		expansion_config.i2c_settings = EXPANSION_I2C_COM6L;
	#endif
	}

	if (!strcmp(expansionboard2_name, "bbtoys-ulcd"))
	{
		int r;
		expansion_config.i2c_settings = EXPANSION_I2C_7ULCD;

		/* TODO: set lcd_driver_name by command line or device tree */
		beagle_config.lcd_driver_name = "tfc_s9700rtwv35tr-01b",
		lcd_panel.name = beagle_config.lcd_driver_name;

		r = gpio_request_one(beagle_config.lcd_pwren, GPIOF_OUT_INIT_LOW, "LCD power");
		if (r < 0)
			pr_err("Beagle expansionboard: Unable to get LCD power enable GPIO\n");
	}

	if (gpio_is_valid(beagle_config.mmc1_gpio_wp))
		omap_mux_init_gpio(beagle_config.mmc1_gpio_wp, OMAP_PIN_INPUT);

	switch (expansion_config.mmc_settings) {
	case EXPANSION_MMC_WIFI:
		mmcbbt[0].caps = beagle_config.mmc_caps;
		omap_hsmmc_init(mmcbbt);
		break;
	case EXPANSION_MMC_ZIPPY:
		mmc_zippy[0].caps = beagle_config.mmc_caps;
		omap_hsmmc_init(mmc_zippy);
		break;
	default:
		mmc[0].caps = beagle_config.mmc_caps;
		omap_hsmmc_init(mmc);
	}

	omap3_beagle_i2c_init();

	gpio_buttons[0].gpio = beagle_config.usr_button_gpio;

	platform_add_devices(omap3_beagle_devices,
			ARRAY_SIZE(omap3_beagle_devices));
	if (gpio_is_valid(beagle_config.dvi_pd_gpio))
		omap_mux_init_gpio(beagle_config.dvi_pd_gpio, OMAP_PIN_OUTPUT);
	omap_display_init(&beagle_dss_data);
	omap_serial_init();
	omap_sdrc_init(mt46h32m32lf6_sdrc_params,
				  mt46h32m32lf6_sdrc_params);

	if (!strcmp(expansionboard_name, "zippy"))
	{
		pr_info("Beagle expansionboard: initializing enc28j60\n");
		omap3beagle_enc28j60_init();
	}

	if (!strcmp(expansionboard_name, "zippy2"))
	{
		pr_info("Beagle expansionboard: initializing ks_8851\n");
		omap3beagle_ks8851_init();
	}

	if (!strcmp(expansionboard_name, "trainer"))
	{
		pr_info("Beagle expansionboard: exporting GPIOs 130-141,162 to userspace\n");
		gpio_request(130, "sysfs");
		gpio_export(130, 1);
		gpio_request(131, "sysfs");
		gpio_export(131, 1);
		gpio_request(132, "sysfs");
		gpio_export(132, 1);
		gpio_request(133, "sysfs");
		gpio_export(133, 1);
		gpio_request(134, "sysfs");
		gpio_export(134, 1);
		gpio_request(135, "sysfs");
		gpio_export(135, 1);
		gpio_request(136, "sysfs");
		gpio_export(136, 1);
		gpio_request(137, "sysfs");
		gpio_export(137, 1);
		gpio_request(138, "sysfs");
		gpio_export(138, 1);
		gpio_request(139, "sysfs");
		gpio_export(139, 1);
		gpio_request(140, "sysfs");
		gpio_export(140, 1);
		gpio_request(141, "sysfs");
		gpio_export(141, 1);
		gpio_request(162, "sysfs");
		gpio_export(162, 1);
	}

	if ((!strcmp(expansionboard_name, "bbtoys-wifi")) || (!strcmp(expansionboard_name, "lsr-com6l-adpt")))
	{
	#if defined(CONFIG_WL12XX) || defined(CONFIG_WL12XX_MODULE)
		pr_info("Beagle expansionboard: initializing wl12xx platform\n");

		if (!strcmp(wl12xx_name, "wl12xx_26mhz")) {
			pr_info("wl12xx: 26Mhz reference clock (TiWi5)\n");
			omap_beagle_wlan_data_26mhz.irq = gpio_to_irq(OMAP_BEAGLE_WLAN_IRQ_GPIO);
			if (wl12xx_set_platform_data(&omap_beagle_wlan_data_26mhz))
				pr_err("error setting wl12xx data\n");
		} else {
			pr_info("wl12xx: 38.4Mhz reference clock (TiWi2/TiWi-BLE)\n");
			pr_info("wl12xx: for (TiWi5) support pass kernel [wl12xx_clk=wl12xx_26mhz]\n");
			omap_beagle_wlan_data.irq = gpio_to_irq(OMAP_BEAGLE_WLAN_IRQ_GPIO);
			if (wl12xx_set_platform_data(&omap_beagle_wlan_data))
				pr_err("error setting wl12xx data\n");
		}

		pr_info("Beagle expansionboard: registering wl12xx bt platform device\n");
		platform_device_register(&wl12xx_device);
		platform_device_register(&btwilink_device);
		pr_info("Beagle expansionboard: registering wl12xx wifi platform device\n");
		platform_device_register(&omap_vwlan_device);
	#endif
	}

	if (!strcmp(expansionboard_name, "beaglefpga"))
	{
		pr_info("Beagle expansionboard: enabling SPIdev for McSPI3/4 and pin muxing for McBSP3 slave mode\n");

		/* FPGA pin settings configure McSPI 3, McSPI 4 and McBSP 3 */
		omap3_beagle_config_fpga_mux();

		/* register McSPI 3 and McSPI 4 for FPGA programming and control */
		spi_register_board_info(beagle_mcspi_board_info, ARRAY_SIZE(beagle_mcspi_board_info));
	}

	if (!strcmp(expansionboard_name, "spidev"))
	{
		pr_info("Beagle expansionboard: registering spidev\n");
		omap3_beagle_config_mcspi3_mux();
		omap3_beagle_config_mcspi4_mux();
		spi_register_board_info(beagle_mcspi_board_info, ARRAY_SIZE(beagle_mcspi_board_info));
	}

	if (!strcmp(expansionboard2_name, "bbtoys-ulcd"))
	{
	#if defined(CONFIG_TOUCHSCREEN_TSC2007) || defined(CONFIG_TOUCHSCREEN_TSC2007_MODULE)
		pr_info("Beagle expansionboard: initializing touchscreen: tsc2007\n");
		omap3beagle_tsc2007_init();
	#endif
	}

	usb_musb_init(NULL);
	usbhs_init(&usbhs_bdata);
	omap_nand_flash_init(NAND_BUSWIDTH_16, omap3beagle_nand_partitions,
			     ARRAY_SIZE(omap3beagle_nand_partitions));
	omap_twl4030_audio_init("omap3beagle");

	/* Ensure msecure is mux'd to be able to set the RTC. */
	omap_mux_init_signal("sys_drm_msecure", OMAP_PIN_OFF_OUTPUT_HIGH);

	/* Ensure SDRC pins are mux'd for self-refresh */
	omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
	omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);
}
Beispiel #11
0
static void __init omap_4430sdp_init(void)
{
	int status;
	int package = OMAP_PACKAGE_CBS;

	if (omap_rev() == OMAP4430_REV_ES1_0)
		package = OMAP_PACKAGE_CBL;

	/* Modification for ELPIDA LPDDR2-s4 8Gb memory device */
	omap_emif_set_device_details(1, &lpddr2_elpida_8G_S4_x2_info,
			lpddr2_elpida_8G_S4_timings,
			ARRAY_SIZE(lpddr2_elpida_8G_S4_timings),
			&lpddr2_elpida_S4_min_tck,
			&custom_configs);

	omap_emif_set_device_details(2, &lpddr2_elpida_8G_S4_x2_info,
			lpddr2_elpida_8G_S4_timings,
			ARRAY_SIZE(lpddr2_elpida_8G_S4_timings),
			&lpddr2_elpida_S4_min_tck,
			&custom_configs);

	omap4_mux_init(board_mux, NULL, package);

	omap_board_config = sdp4430_config;
	omap_board_config_size = ARRAY_SIZE(sdp4430_config);

	omap4_i2c_init();
	omap4_twl6030_hsmmc_init(mmc);
	omap_sfh7741prox_init();
	platform_add_devices(sdp4430_devices, ARRAY_SIZE(sdp4430_devices));
	omap_serial_init();
	omap_sdrc_init(NULL, NULL);
	omap4_sdp4430_wifi_init();

	usb_musb_init(&musb_board_data);

	status = omap_ethernet_init();
	if (status) {
		pr_err("Ethernet initialization failed: %d\n", status);
	} else {
		sdp4430_spi_board_info[0].irq = gpio_to_irq(ETH_KS8851_IRQ);
		spi_register_board_info(sdp4430_spi_board_info,
				ARRAY_SIZE(sdp4430_spi_board_info));
	}

	status = omap4_keyboard_init(&sdp4430_keypad_data, &keypad_data);
	if (status)
		pr_err("Keypad initialization failed: %d\n", status);

	omap_4430sdp_display_init();

	if (cpu_is_omap446x()) {
		/* Vsel0 = gpio, vsel1 = gnd */
		status = omap_tps6236x_board_setup(true, TPS62361_GPIO, -1,
					OMAP_PIN_OFF_OUTPUT_HIGH, -1);
		if (status)
			pr_err("TPS62361 initialization failed: %d\n", status);
	}
	omap_enable_smartreflex_on_init();
	omap_rprm_regulator_init(sdp4430_rprm_regulators,
				 ARRAY_SIZE(sdp4430_rprm_regulators));

	enable_board_wakeups();
}
static void __init VAR_SOM_OM3X_init(void)
{
	VAR_SOM_OM3X_twldata.vaux2 = &VAR_SOM_OM3X_vaux2;

	omap3_mux_init(board_mux, OMAP_PACKAGE_CUS);
	
	// USB phy enable
	if (gpio_request(24,"GPIO24")<0)
		printk(KERN_ERR "Can't get GPIO24 for USB phy reset\n");
	gpio_direction_output(24, 1);
	gpio_set_value(24, 1);


	// SMSC 9221 interrupt
	if (gpio_request(29,"GPIO29")<0)
		printk(KERN_ERR "Can't get GPIO29 for ETH0\n");
	gpio_direction_input(29);

#if 0
#ifdef VER_2_1
	omap_mux_init_gpio(VAR_SOM_OM3X_USB3_PWR_ENn, OMAP_PIN_INPUT_PULLUP);
	if (gpio_request(VAR_SOM_OM3X_USB3_PWR_ENn,"USB3_PWR_ENn")<0)
		printk(KERN_ERR "Can't get 167 for USB3 power enable\n");
	gpio_direction_output(VAR_SOM_OM3X_USB3_PWR_ENn, 1);
	gpio_set_value(VAR_SOM_OM3X_USB3_PWR_ENn, 1);
#endif
#endif

	VAR_SOM_OM3X_i2c_init();

	platform_add_devices(VAR_SOM_OM3X_devices, ARRAY_SIZE(VAR_SOM_OM3X_devices));

#if defined (CONFIG_TOUCHSCREEN_CTW6120) || defined (CONFIG_TOUCHSCREEN_ADS7846)
	spi_register_board_info(VAR_SOM_OM3X_spi_board_info,
				ARRAY_SIZE(VAR_SOM_OM3X_spi_board_info));
#endif

	omap_serial_init();
#ifdef CONFIG_NOP_USB_XCEIV
	usb_nop_xceiv_register();
#endif

	omap_mux_init_gpio(VAR_SOM_OM3X_DVI_PANEL_EN_GPIO, OMAP_PIN_INPUT_PULLUP);


	usb_musb_init();

	usb_ehci_init(&ehci_pdata);
	VAR_SOM_OM3X_flash_init();
		ads7846_dev_init();
	ctw6120_dev_init();
	VAR_SOM_OM3X_init_smsc911x();

#ifdef CONFIG_PANEL_VARISCITE
	VAR_SOM_OM3X_display_init();
#endif
	/* Ensure SDRC pins are mux'd for self-refresh */
	omap_mux_init_signal("sdrc_cke0", OMAP_PIN_OUTPUT);
	omap_mux_init_signal("sdrc_cke1", OMAP_PIN_OUTPUT);

	/* Push Buttons */
	bp_add_device_buttons();
}