/* * Board support file for OMAP44xx tablet. * * Copyright (C) 2009 Texas Instruments * * Author: Dan Murphy * * Based on mach-omap2/board-4430sdp.c * * 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. */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "mux.h" #include "hsmmc.h" #include "timer-gp.h" #include "control.h" #include "pm.h" #include "board-44xx-tablet.h" #include "omap_ram_console.h" #define WILINK_UART_DEV_NAME "/dev/ttyO1" #define ETH_KS8851_IRQ 34 #define ETH_KS8851_POWER_ON 48 #define ETH_KS8851_QUART 138 #define GPIO_WIFI_PMENA 54 #define GPIO_WIFI_IRQ 53 #define TPS62361_GPIO 7 #define OMAP4_MDM_PWR_EN_GPIO 157 #define GPIO_USB3320_PHY_RESETB 171 #define GPIO_WK30 30 #define OMAP4_HSIC_AUX_GPIO 42 static struct spi_board_info tablet_spi_board_info[] __initdata = { { .modalias = "ks8851", .bus_num = 1, .chip_select = 0, .max_speed_hz = 24000000, .irq = ETH_KS8851_IRQ, }, }; static struct gpio tablet_eth_gpios[] __initdata = { { ETH_KS8851_POWER_ON, GPIOF_OUT_INIT_HIGH, "eth_power" }, { ETH_KS8851_QUART, GPIOF_OUT_INIT_HIGH, "quart" }, { ETH_KS8851_IRQ, GPIOF_IN, "eth_irq" }, }; static int __init omap_ethernet_init(void) { int status; /* Request of GPIO lines */ status = gpio_request_array(tablet_eth_gpios, ARRAY_SIZE(tablet_eth_gpios)); if (status) pr_err("Cannot request ETH GPIOs\n"); return status; } /* TODO: handle suspend/resume here. * Upon every suspend, make sure the wilink chip is * capable enough to wake-up the OMAP host. */ static int plat_wlink_kim_suspend(struct platform_device *pdev, pm_message_t state) { return 0; } static int plat_wlink_kim_resume(struct platform_device *pdev) { return 0; } static bool uart_req; static struct wake_lock st_wk_lock; /* Call the uart disable of serial driver */ static int plat_uart_disable(void) { int port_id = 0; int err = 0; if (uart_req) { sscanf(WILINK_UART_DEV_NAME, "/dev/ttyO%d", &port_id); err = omap_serial_ext_uart_disable(port_id); if (!err) uart_req = false; } wake_unlock(&st_wk_lock); return err; } /* Call the uart enable of serial driver */ static int plat_uart_enable(void) { int port_id = 0; int err = 0; if (!uart_req) { sscanf(WILINK_UART_DEV_NAME, "/dev/ttyO%d", &port_id); err = omap_serial_ext_uart_enable(port_id); if (!err) uart_req = true; } wake_lock(&st_wk_lock); return err; } /* wl128x BT, FM, GPS connectivity chip */ static struct ti_st_plat_data wilink_pdata = { .nshutdown_gpio = 55, .dev_name = WILINK_UART_DEV_NAME, .flow_cntrl = 1, .baud_rate = 3686400, .suspend = plat_wlink_kim_suspend, .resume = plat_wlink_kim_resume, .chip_asleep = plat_uart_disable, .chip_awake = plat_uart_enable, .chip_enable = plat_uart_enable, .chip_disable = plat_uart_disable, }; static struct platform_device wl128x_device = { .name = "kim", .id = -1, .dev.platform_data = &wilink_pdata, }; static struct platform_device btwilink_device = { .name = "btwilink", .id = -1, }; static struct omap_board_config_kernel tablet_config[] __initdata = { }; static void __init omap_tablet_init_early(void) { omap2_init_common_infrastructure(); omap2_init_common_devices(NULL, NULL); #ifdef CONFIG_OMAP_32K_TIMER omap2_gp_clockevent_set_gptimer(1); #endif } static struct omap_musb_board_data musb_board_data = { .interface_type = MUSB_INTERFACE_UTMI, #ifdef CONFIG_USB_MUSB_OTG .mode = MUSB_OTG, #else .mode = MUSB_PERIPHERAL, #endif .power = 200, }; static struct omap2_hsmmc_info mmc[] = { { .mmc = 2, .caps = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA | MMC_CAP_1_8V_DDR, .gpio_cd = -EINVAL, .gpio_wp = -EINVAL, .nonremovable = true, .ocr_mask = MMC_VDD_29_30, .no_off_init = true, }, { .mmc = 1, .caps = MMC_CAP_4_BIT_DATA | MMC_CAP_8_BIT_DATA | MMC_CAP_1_8V_DDR, .gpio_wp = -EINVAL, }, { .mmc = 5, .caps = MMC_CAP_4_BIT_DATA | MMC_CAP_POWER_OFF_CARD, .gpio_cd = -EINVAL, .gpio_wp = -EINVAL, .ocr_mask = MMC_VDD_165_195, .nonremovable = true, }, {} /* Terminator */ }; static struct regulator_consumer_supply omap4_tablet_vmmc5_supply = { .supply = "vmmc", .dev_name = "omap_hsmmc.4", }; static struct regulator_init_data tablet_vmmc5 = { .constraints = { .valid_ops_mask = REGULATOR_CHANGE_STATUS, }, .num_consumer_supplies = 1, .consumer_supplies = &omap4_tablet_vmmc5_supply, }; static struct fixed_voltage_config tablet_vwlan = { .supply_name = "vwl1271", .microvolts = 1800000, /* 1.8V */ .gpio = GPIO_WIFI_PMENA, .startup_delay = 70000, /* 70msec */ .enable_high = 1, .enabled_at_boot = 0, .init_data = &tablet_vmmc5, }; static struct platform_device omap_vwlan_device = { .name = "reg-fixed-voltage", .id = 1, .dev = { .platform_data = &tablet_vwlan, }, }; static int omap4_twl6030_hsmmc_late_init(struct device *dev) { int ret = 0; struct platform_device *pdev = container_of(dev, struct platform_device, dev); struct omap_mmc_platform_data *pdata = dev->platform_data; /* Setting MMC1 Card detect Irq */ if (pdev->id == 0) { ret = twl6030_mmc_card_detect_config(); if (ret) pr_err("Failed configuring MMC1 card detect\n"); pdata->slots[0].card_detect_irq = TWL6030_IRQ_BASE + MMCDETECT_INTR_OFFSET; pdata->slots[0].card_detect = twl6030_mmc_card_detect; } /* Setting MMC5 SDIO card .built-in variable * This is to make sure that if WiFi driver is not loaded * at all, then the MMC/SD/SDIO driver does not keep * turning on/off the voltage to the SDIO card */ if (pdev->id == 4) { ret = 0; pdata->slots[0].mmc_data.built_in = 1; } return ret; } static __init void omap4_twl6030_hsmmc_set_late_init(struct device *dev) { struct omap_mmc_platform_data *pdata; /* dev can be null if CONFIG_MMC_OMAP_HS is not set */ if (!dev) { pr_err("Failed %s\n", __func__); return; } pdata = dev->platform_data; pdata->init = omap4_twl6030_hsmmc_late_init; } static int __init omap4_twl6030_hsmmc_init(struct omap2_hsmmc_info *controllers) { struct omap2_hsmmc_info *c; omap2_hsmmc_init(controllers); for (c = controllers; c->mmc; c++) omap4_twl6030_hsmmc_set_late_init(c->dev); return 0; } static void omap4_audio_conf(void) { /* twl6040 naudint */ omap_mux_init_signal("sys_nirq2.sys_nirq2", \ OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_WAKEUPENABLE); } static int tps6130x_enable(int on) { u8 rev, gpo, val = 0; int ret; ret = twl_i2c_read_u8(TWL_MODULE_AUDIO_VOICE, &rev, TWL6040_REG_ASICREV); if (ret < 0) { pr_err("%s: failed to read ASICREV %d\n", __func__, ret); return ret; } /* * tps6130x NRESET driven by: * - GPO2 in TWL6040 * - GPO in TWL6041 (only one GPO supported) */ if (rev >= TWL6041_REV_2_0) gpo = TWL6040_GPO1; else gpo = TWL6040_GPO2; ret = twl_i2c_read_u8(TWL_MODULE_AUDIO_VOICE, &val, TWL6040_REG_GPOCTL); if (ret < 0) { pr_err("%s: failed to read GPOCTL %d\n", __func__, ret); return ret; } if (on) val |= gpo; else val &= ~gpo; ret = twl_i2c_write_u8(TWL_MODULE_AUDIO_VOICE, val, TWL6040_REG_GPOCTL); if (ret < 0) pr_err("%s: failed to write GPOCTL %d\n", __func__, ret); return ret; } static struct tps6130x_platform_data tps6130x_pdata = { .chip_enable = tps6130x_enable, }; static struct regulator_consumer_supply twl6040_vddhf_supply[] = { REGULATOR_SUPPLY("vddhf", "twl6040-codec"), }; static struct regulator_init_data twl6040_vddhf = { .constraints = { .min_uV = 4075000, .max_uV = 4950000, .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(twl6040_vddhf_supply), .consumer_supplies = twl6040_vddhf_supply, .driver_data = &tps6130x_pdata, }; static struct bq2415x_platform_data sdp4430_bqdata = { .max_charger_voltagemV = 4200, .max_charger_currentmA = 1550, }; /* * The Clock Driver Chip (TCXO) on OMAP4 based SDP needs to * be programmed to output CLK1 based on REQ1 from OMAP. * By default CLK1 is driven based on an internal REQ1INT signal * which is always set to 1. * Doing this helps gate sysclk (from CLK1) to OMAP while OMAP * is in sleep states. */ static struct cdc_tcxo_platform_data sdp4430_cdc_data = { .buf = { CDC_TCXO_REQ4INT | CDC_TCXO_REQ1INT | CDC_TCXO_REQ4POL | CDC_TCXO_REQ3POL | CDC_TCXO_REQ2POL | CDC_TCXO_REQ1POL, CDC_TCXO_MREQ4 | CDC_TCXO_MREQ3 | CDC_TCXO_MREQ2 | CDC_TCXO_MREQ1, CDC_TCXO_LDOEN1, 0, }, }; static struct i2c_board_info __initdata sdp4430_i2c_boardinfo[] = { { I2C_BOARD_INFO("bq24156", 0x6a), .platform_data = &sdp4430_bqdata, }, { I2C_BOARD_INFO("tps6130x", 0x33), .platform_data = &twl6040_vddhf, }, { I2C_BOARD_INFO("cdc_tcxo_driver", 0x6c), .platform_data = &sdp4430_cdc_data, }, }; static void __init tablet_pmic_mux_init(void) { omap_mux_init_signal("sys_nirq1", OMAP_PIN_INPUT_PULLUP | OMAP_WAKEUP_EN); } static void __init omap_i2c_hwspinlock_init(int bus_id, int spinlock_id, struct omap_i2c_bus_board_data *pdata) { /* spinlock_id should be -1 for a generic lock request */ if (spinlock_id < 0) pdata->handle = hwspin_lock_request(); else pdata->handle = hwspin_lock_request_specific(spinlock_id); if (pdata->handle != NULL) { pdata->hwspin_lock_timeout = hwspin_lock_timeout; pdata->hwspin_unlock = hwspin_unlock; } else { pr_err("I2C hwspinlock request failed for bus %d\n", \ bus_id); } } static struct omap_i2c_bus_board_data __initdata sdp4430_i2c_1_bus_pdata; static struct omap_i2c_bus_board_data __initdata sdp4430_i2c_2_bus_pdata; static struct omap_i2c_bus_board_data __initdata sdp4430_i2c_3_bus_pdata; static struct omap_i2c_bus_board_data __initdata sdp4430_i2c_4_bus_pdata; 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, 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/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 bool enable_suspend_off = true; module_param(enable_suspend_off, bool, S_IRUSR | S_IRGRP | S_IROTH); #ifdef CONFIG_OMAP_MUX static struct omap_board_mux board_mux[] __initdata = { OMAP4_MUX(USBB2_ULPITLL_CLK, OMAP_MUX_MODE3 | OMAP_PIN_OUTPUT | OMAP_PULL_ENA), /* IO optimization pdpu and offmode settings to reduce leakage */ OMAP4_MUX(GPMC_A17, OMAP_MUX_MODE3 | OMAP_INPUT_EN), OMAP4_MUX(GPMC_NCS4, OMAP_MUX_MODE3 | OMAP_INPUT_EN), OMAP4_MUX(GPMC_NCS5, OMAP_MUX_MODE3 | OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_OFF_EN | OMAP_OFF_PULL_EN), OMAP4_MUX(GPMC_NCS7, OMAP_MUX_MODE3 | OMAP_INPUT_EN), OMAP4_MUX(GPMC_NBE1, OMAP_MUX_MODE3 | OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_OFF_EN | OMAP_OFF_PULL_EN), OMAP4_MUX(GPMC_WAIT0, OMAP_MUX_MODE3 | OMAP_INPUT_EN), OMAP4_MUX(GPMC_NOE, OMAP_MUX_MODE1 | OMAP_INPUT_EN), OMAP4_MUX(MCSPI1_CS1, OMAP_MUX_MODE3 | OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_OFF_EN | OMAP_OFF_PULL_EN), OMAP4_MUX(MCSPI1_CS2, OMAP_MUX_MODE3 | OMAP_PULL_ENA | OMAP_PULL_UP | OMAP_OFF_EN | OMAP_OFF_PULL_EN), OMAP4_MUX(SDMMC5_CLK, OMAP_MUX_MODE0 | OMAP_INPUT_EN | OMAP_OFF_EN | OMAP_OFF_PULL_EN), OMAP4_MUX(GPMC_NCS1, OMAP_MUX_MODE3 | OMAP_INPUT_EN | OMAP_WAKEUP_EN), OMAP4_MUX(GPMC_A24, OMAP_MUX_MODE3 | OMAP_INPUT_EN | OMAP_WAKEUP_EN), { .reg_offset = OMAP_MUX_TERMINATOR }, }; #else #define board_mux NULL #define board_wkup_mux NULL #endif /* * LPDDR2 Configuration Data for 4430/4460 SOMs: * The memory organization is as below : * EMIF1 - CS0 - 2 Gb * CS1 - 2 Gb * EMIF2 - CS0 - 2 Gb * CS1 - 2 Gb * -------------------- * TOTAL - 8 Gb * * Same devices installed on EMIF1 and EMIF2 */ static __initdata struct emif_device_details emif_devices = { .cs0_device = &lpddr2_elpida_2G_S4_dev, .cs1_device = &lpddr2_elpida_2G_S4_dev }; /* * LPDDR2 Configuration Data for 4470 SOMs: * The memory organization is as below : * EMIF1 - CS0 - 4 Gb * EMIF2 - CS0 - 4 Gb * -------------------- * TOTAL - 8 Gb * * Same devices installed on EMIF1 and EMIF2 */ static __initdata struct emif_device_details emif_devices_4470 = { .cs0_device = &lpddr2_elpida_4G_S4_dev, }; static void omap4_tablet_wifi_mux_init(void) { omap_mux_init_gpio(GPIO_WIFI_IRQ, OMAP_PIN_INPUT | OMAP_PIN_OFF_WAKEUPENABLE); omap_mux_init_gpio(GPIO_WIFI_PMENA, OMAP_PIN_OUTPUT); omap_mux_init_signal("sdmmc5_cmd.sdmmc5_cmd", OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP); omap_mux_init_signal("sdmmc5_clk.sdmmc5_clk", OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP); omap_mux_init_signal("sdmmc5_dat0.sdmmc5_dat0", OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP); omap_mux_init_signal("sdmmc5_dat1.sdmmc5_dat1", OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP); omap_mux_init_signal("sdmmc5_dat2.sdmmc5_dat2", OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP); omap_mux_init_signal("sdmmc5_dat3.sdmmc5_dat3", OMAP_MUX_MODE0 | OMAP_PIN_INPUT_PULLUP); } static struct wl12xx_platform_data omap4_tablet_wlan_data __initdata = { .irq = OMAP_GPIO_IRQ(GPIO_WIFI_IRQ), .board_ref_clock = WL12XX_REFCLOCK_26, .board_tcxo_clock = WL12XX_TCXOCLOCK_26, }; static void omap4_tablet_wifi_init(void) { omap4_tablet_wifi_mux_init(); if (wl12xx_set_platform_data(&omap4_tablet_wlan_data)) pr_err("Error setting wl12xx data\n"); platform_device_register(&omap_vwlan_device); } #if defined(CONFIG_USB_EHCI_HCD_OMAP) || defined(CONFIG_USB_OHCI_HCD_OMAP3) static struct usbhs_omap_board_data usbhs_bdata __initdata = { .port_mode[0] = OMAP_EHCI_PORT_MODE_PHY, .port_mode[1] = OMAP_USBHS_PORT_MODE_UNUSED, .port_mode[2] = OMAP_USBHS_PORT_MODE_UNUSED, .phy_reset = false, .reset_gpio_port[0] = -EINVAL, .reset_gpio_port[1] = -EINVAL, .reset_gpio_port[2] = -EINVAL, .hsic_aux_port[0] = -EINVAL, .hsic_aux_port[1] = OMAP4_HSIC_AUX_GPIO, .hsic_aux_port[2] = -EINVAL }; static int __init setup_usb_hsic(char *buf) { extern bool omap4_tablet_uses_hsic; omap4_tablet_uses_hsic = true; usbhs_bdata.port_mode[0] = OMAP_USBHS_PORT_MODE_UNUSED; usbhs_bdata.port_mode[1] = OMAP_EHCI_PORT_MODE_HSIC; return 0; } early_param("omap4_tablet_uses_hsic", setup_usb_hsic); static void __init omap4_ehci_ohci_init(void) { omap_mux_init_signal("fref_clk3_req.gpio_wk30", \ OMAP_PIN_OUTPUT | \ OMAP_PIN_OFF_NONE | OMAP_PULL_ENA); /* Enable 5V,1A USB power on external HS-USB ports */ if (gpio_is_valid(GPIO_WK30)) { gpio_request(GPIO_WK30, "USB POWER GPIO"); gpio_direction_output(GPIO_WK30, 1); gpio_set_value(GPIO_WK30, 0); } omap_mux_init_signal("usbb2_ulpitll_clk.gpio_157", \ OMAP_PIN_OUTPUT | \ OMAP_PIN_OFF_NONE); /* Power on the ULPI PHY */ if ((usbhs_bdata.port_mode[0] == OMAP_EHCI_PORT_MODE_PHY) && gpio_is_valid(OMAP4_MDM_PWR_EN_GPIO)) { gpio_request(OMAP4_MDM_PWR_EN_GPIO, "USBB1 PHY VMDM_3V3"); gpio_direction_output(OMAP4_MDM_PWR_EN_GPIO, 1); } omap_mux_init_signal("gpmc_a18.gpio_42", OMAP_PIN_INPUT_PULLUP | OMAP_PIN_OFF_INPUT_PULLUP); usbhs_init(&usbhs_bdata); return; } #else static void __init omap4_ehci_ohci_init(void){} #endif static struct platform_device *tablet4430_devices[] __initdata = { &wl128x_device, &btwilink_device, }; static void __init tablet_camera_mux_init(void) { u32 r = 0; /* Enable CSI22 pads for 4460 and 4470*/ if ((cpu_is_omap446x() || cpu_is_omap447x()) && (omap_get_board_version() >= OMAP4_TABLET_2_0)) { r = omap4_ctrl_pad_readl(OMAP4_CTRL_MODULE_PAD_CORE_CONTROL_CAMERA_RX); r |= (0x7 << OMAP4_CAMERARX_CSI22_LANEENABLE_SHIFT); omap4_ctrl_pad_writel(r, OMAP4_CTRL_MODULE_PAD_CORE_CONTROL_CAMERA_RX); omap_mux_init_signal("csi22_dx2.csi22_dx2", OMAP_PIN_INPUT | OMAP_MUX_MODE0); omap_mux_init_signal("csi22_dy2.csi22_dy2", OMAP_PIN_INPUT | OMAP_MUX_MODE0); } } static void tablet_set_osc_timings(void) { /* Device Oscilator * tstart = 2ms + 2ms = 4ms. * tshut = Not defined in oscillator data sheet so setting to 1us */ omap_pm_set_osc_lp_time(4000, 1); } static void __init omap_tablet_init(void) { int status; int package = OMAP_PACKAGE_CBS; int tablet_rev = 0; 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 = tablet_config; omap_board_config_size = ARRAY_SIZE(tablet_config); tablet_rev = omap_init_board_version(0); omap4_create_board_props(); omap4_audio_conf(); omap4_i2c_init(); tablet_touch_init(); tablet_camera_mux_init(); omap_dmm_init(); tablet_panel_init(); tablet_pmic_mux_init(); tablet_set_osc_timings(); tablet_button_init(); omap4_register_ion(); board_serial_init(); omap4_tablet_wifi_init(); omap4_twl6030_hsmmc_init(mmc); tablet_sensor_init(); platform_add_devices(tablet4430_devices, ARRAY_SIZE(tablet4430_devices)); wake_lock_init(&st_wk_lock, WAKE_LOCK_SUSPEND, "st_wake_lock"); 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 { tablet_spi_board_info[0].irq = gpio_to_irq(ETH_KS8851_IRQ); spi_register_board_info(tablet_spi_board_info, ARRAY_SIZE(tablet_spi_board_info)); } 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_tablet_map_io(void) { omap2_set_globals_443x(); omap44xx_map_common_io(); } static void __init omap_tablet_reserve(void) { omap_init_ram_size(); #ifdef CONFIG_ION_OMAP tablet_android_display_setup(get_omap_ion_platform_data()); omap_ion_init(); #else tablet_android_display_setup(NULL); #endif omap_ram_console_init(OMAP_RAM_CONSOLE_START_DEFAULT, OMAP_RAM_CONSOLE_SIZE_DEFAULT); /* do the static reservations first */ memblock_remove(PHYS_ADDR_SMC_MEM, PHYS_ADDR_SMC_SIZE); memblock_remove(PHYS_ADDR_DUCATI_MEM, PHYS_ADDR_DUCATI_SIZE); /* ipu needs to recognize secure input buffer area as well */ omap_ipu_set_static_mempool(PHYS_ADDR_DUCATI_MEM, PHYS_ADDR_DUCATI_SIZE + OMAP4_ION_HEAP_SECURE_INPUT_SIZE + OMAP4_ION_HEAP_SECURE_OUTPUT_WFDHDCP_SIZE); omap_reserve(); } MACHINE_START(OMAP_BLAZE, "OMAP4 blaze board") /* Maintainer: Dan Murphy - Texas Instruments Inc */ .boot_params = 0x80000100, .reserve = omap_tablet_reserve, .map_io = omap_tablet_map_io, .init_early = omap_tablet_init_early, .init_irq = gic_init_irq, .init_machine = omap_tablet_init, .timer = &omap_timer, MACHINE_END